@aura3d/engine 1.0.2 → 1.0.5

package/dist/engine/agent-api/index.js

@@ -1,4 +1,42 @@
 import { PhysicsDebugDraw, PhysicsStepper, PhysicsWorld, ScenePhysicsBridge, Shape as PhysicsShapeFactory } from "../../physics/index.js";
+import { createFrameLoop } from "./FrameLoop.js";
+import { createCombatWorld, createGameCameraDirector, createGameEffects, applyGameCombatEventsToRuntime, createGameAccessibilityFocus, createGameAccessibilityLabel, createGameAccessibilityRuntimeSettings, createGameHighContrastSource, createGameHudBindings, createGameHudComboBinding, createGameHudDebugToggleBinding, createGameHudHealthBinding, createGameHudMeterBinding, createGameHudRoundBinding, createGameHudSnapshot, createGameHudTimerBinding, createGameBoxCollider, createGameCapsuleCollider, createGameColliderDebugGeometry, createGameCombatDebugGeometry, createGameDebugOverlayData, createGameDebugSceneNodes, createGameHitboxDebugGeometry, createGameFighting2DRules, createGameInput, createGameInputReplay, createGameInputReplayDriver, createGameJumpAssist, createGameKinematicBody, createGamePauseControlsSource, createGameRectCollider, createGameReducedFlashSource, createGameReducedMotionSource, createGameSphereCollider, createGameTouchControlLayout, gameColliderAabb, gameColliders, gameEffectPresets, gameGuardboxes, gameHitboxes, gameHurtboxes, gameInputReplayEventsAt, gamePushboxes, gameTriggerVolumes } from "./GameRuntime.js";
+import { collectGameRuntimeEvidence as collectGameRuntimeEvidenceV105 } from "./GameEvidence.js";
+import { calculateRuntimeNodeBounds } from "./RuntimeNodeHandle.js";
+import { createRuntimeNodeSpec } from "./GameSceneBridge.js";
+import { createFightingGameKit, fighting as fightingGameKit } from "./game-kits/fighting.js";
+import { createPromptAnimationEpisodePlan, createPromptAnimationStoryBible, definePromptAnimationStoryboard } from "./PromptAnimationContract.js";
+import { applyShotPlaybackFrame, createShotPlaybackPlan, createShotTimeline, installShotPlayback, sampleShotPlaybackPlan } from "./ShotTimeline.js";
+import { captionCueAtTime, createCaptionTimingProof, deriveCaptionTrackFromDialogue } from "./DialoguePerformance.js";
+import { createAuraVoiceVisemeTrack, createGlbBlendshapeVisemeCue, createPrimitiveMouthVisemeCues, sampleVisemeTrack } from "./VisemeController.js";
+import { createAuraVoiceBridgePackage, createAuraVoiceDubRerenderProof, createAuraVoiceRerenderPlan, sampleAuraVoiceBridgeAtTime } from "./AuraVoiceBridge.js";
+import { createCartoonDirectorPlan } from "./CartoonDirector.js";
+import { createCartoonPerformance } from "./CartoonPerformance.js";
+import { createCartoonRenderOutputPackageMetadata, createCartoonRenderQueue } from "./CartoonRenderQueue.js";
+import { collectPromptAnimationEvidence } from "./PromptAnimationEvidence.js";
+export { Engine } from "../../core/index.js";
+export { asAuraAppHandle, isAuraAppHandle } from "./AuraAppHandle.js";
+export { FrameLoop, createFrameLoop } from "./FrameLoop.js";
+export { createCombatWorld, createGameCameraDirector, createGameEffects, applyGameCombatEventsToRuntime, createGameAccessibilityFocus, createGameAccessibilityLabel, createGameAccessibilityRuntimeSettings, createGameHighContrastSource, createGameHudBindings, createGameHudComboBinding, createGameHudDebugToggleBinding, createGameHudHealthBinding, createGameHudMeterBinding, createGameHudRoundBinding, createGameHudSnapshot, createGameHudTimerBinding, createGameBoxCollider, createGameCapsuleCollider, createGameColliderDebugGeometry, createGameCombatDebugGeometry, createGameDebugOverlayData, createGameDebugSceneNodes, createGameHitboxDebugGeometry, createGameInput, createGameInputReplay, createGameInputReplayDriver, createGameJumpAssist, createGameKinematicBody, createGamePauseControlsSource, createGameRectCollider, createGameReducedFlashSource, createGameReducedMotionSource, createGameSphereCollider, createGameTouchControlLayout, gameColliderAabb, gameColliders, gameInputReplayEventsAt, createGameLoopPlan } from "./GameRuntime.js";
+export { collectGameSceneRuntimeNodes, createGameSceneBridge, createRuntimeNodeSpec } from "./GameSceneBridge.js";
+export { calculateRuntimeNodeBounds, createRuntimeNodeEffectAttachment, runtimeNodeHasTag } from "./RuntimeNodeHandle.js";
+export { createFightingGameKit, fighting, fighterRuntimeNode } from "./game-kits/fighting.js";
+export { gameKits } from "./game-kits/index.js";
+export * from "./GameAssetValidation.js";
+export * from "./CharacterAssembly.js";
+export * from "./AssetEvidence.js";
+export * from "./AnimationController.js";
+export { gameAssetValidation, quaterniusGameReadyFighterValidationContract, validateQuaterniusGameReadyFighterAsset } from "./GameAssetValidation.js";
+export { createAnimationController } from "./AnimationController.js";
+export * from "./PromptAnimationContract.js";
+export * from "./AuraVoiceBridge.js";
+export * from "./ShotTimeline.js";
+export * from "./DialoguePerformance.js";
+export * from "./VisemeController.js";
+export * from "./PromptAnimationEvidence.js";
+export * from "./CartoonDirector.js";
+export * from "./CartoonPerformance.js";
+export * from "./CartoonRenderQueue.js";
 const auraAssetRefBrand = Symbol("AuraAssetRef");
 export function defineAuraAssets(definitions) {
     const refs = {};
@@ -44,6 +82,9 @@ export class AuraNodeBuilder {
     physics(spec) {
         return this.with({ physics: spec });
     }
+    runtime(spec) {
+        return this.with({ runtime: { mutable: true, ...spec } });
+    }
     toJSON() {
         return this.value;
     }
@@ -1145,7 +1186,7 @@ const rendererColorManagementPreset = {
     toneMapping: "aces-filmic",
     defaultExposure: 1.05,
     notes: [
-        "Three.js renderer uses SRGBColorSpace output and ACESFilmicToneMapping.",
+        "Aura3D WebGL2 renderer uses sRGB output and ACES filmic tone mapping.",
         "Exposure is selected by scene category to avoid blown-out product/material whites and crushed dark scenes."
     ]
 };
@@ -1237,7 +1278,7 @@ function createRendererDiagnosticReport(snapshot, runtime) {
         intensity: environment?.intensity,
         evidence: environment
             ? `${environment.environment} IBL requested at intensity ${environment.intensity}`
-            : "procedural fallback environment requested only; runtime PMREM status is unavailable until render"
+            : "procedural fallback environment requested only; runtime environment prefilter status is unavailable until render"
     };
     const postprocessEvidence = !postprocessRequested
         ? "no renderer postprocess effects requested"
@@ -2875,6 +2916,8 @@ export const games = {
     miniGolfCourse: () => prefabs.miniGolfCourse(),
     createMiniGolfState: () => createMiniGolfStateController(),
     miniGolfPointerShot: miniGolfPointerShotFromDrag,
+    fighting: fightingGameKit,
+    createFightingGameKit,
     miniGolfScene: () => scene()
         .background("#12321d")
         .addMany(prefabs.miniGolfHole())
@@ -2882,6 +2925,321 @@ export const games = {
         .camera(camera.follow({ targetNode: "white physics golf ball", distance: 4.2 }))
         .timeline(timeline.loop({ seconds: 8 }))
 };
+export function collectGameRuntimeEvidence(app, options = {}) {
+    return collectGameRuntimeEvidenceV105(app, options);
+}
+function createGameInputController(options) {
+    const actions = options.actions;
+    const axes = options.axes ?? {};
+    const bufferMs = options.bufferMs ?? 120;
+    const activeBindings = new Set();
+    const activeActionOverrides = new Set();
+    const previousHeld = new Map();
+    const currentHeld = new Map();
+    const pressedEdges = new Set();
+    const releasedEdges = new Set();
+    const lastPressedAt = new Map();
+    const replayEvents = [];
+    let frame = 0;
+    let time = 0;
+    let latestSnapshot = {
+        kind: "aura-game-input-snapshot",
+        frame,
+        time,
+        activeBindings: [],
+        actions: {}
+    };
+    const resolveHeld = (action) => {
+        if (activeActionOverrides.has(action))
+            return true;
+        const bindings = actions[action] ?? [];
+        return bindings.some((binding) => activeBindings.has(binding));
+    };
+    const record = (type, binding) => {
+        replayEvents.push({ frame, time, type, binding });
+    };
+    const pressBinding = (binding, shouldRecord = true) => {
+        activeBindings.add(binding);
+        if (actions[binding])
+            activeActionOverrides.add(binding);
+        if (shouldRecord)
+            record("press", binding);
+    };
+    const releaseBinding = (binding, shouldRecord = true) => {
+        activeBindings.delete(binding);
+        activeActionOverrides.delete(binding);
+        if (shouldRecord)
+            record("release", binding);
+    };
+    const toSnapshot = () => {
+        const actionStates = {};
+        const nowMs = time * 1000;
+        for (const action of Object.keys(actions)) {
+            const held = currentHeld.get(action) ?? false;
+            actionStates[action] = {
+                pressed: pressedEdges.has(action),
+                held,
+                released: releasedEdges.has(action),
+                buffered: pressedEdges.has(action) || nowMs - (lastPressedAt.get(action) ?? Number.NEGATIVE_INFINITY) <= bufferMs,
+                value: held ? 1 : 0
+            };
+        }
+        return {
+            kind: "aura-game-input-snapshot",
+            frame,
+            time,
+            activeBindings: [...activeBindings].sort(),
+            actions: actionStates
+        };
+    };
+    const update = (dt = 1 / 60) => {
+        frame += 1;
+        time += Math.max(0, dt);
+        pressedEdges.clear();
+        releasedEdges.clear();
+        for (const action of Object.keys(actions)) {
+            const held = resolveHeld(action);
+            const wasHeld = previousHeld.get(action) ?? false;
+            currentHeld.set(action, held);
+            if (held && !wasHeld) {
+                pressedEdges.add(action);
+                lastPressedAt.set(action, time * 1000);
+            }
+            if (!held && wasHeld)
+                releasedEdges.add(action);
+            previousHeld.set(action, held);
+        }
+        latestSnapshot = toSnapshot();
+        return latestSnapshot;
+    };
+    const target = options.target ?? (typeof window !== "undefined" ? window : undefined);
+    const onKeyDown = (event) => {
+        const keyboard = event;
+        if (keyboard.repeat)
+            return;
+        if (keyboard.code)
+            pressBinding(keyboard.code);
+        if (keyboard.key && keyboard.key !== keyboard.code)
+            pressBinding(keyboard.key);
+    };
+    const onKeyUp = (event) => {
+        const keyboard = event;
+        if (keyboard.code)
+            releaseBinding(keyboard.code);
+        if (keyboard.key && keyboard.key !== keyboard.code)
+            releaseBinding(keyboard.key);
+    };
+    if (options.autoListen !== false && target?.addEventListener) {
+        target.addEventListener("keydown", onKeyDown);
+        target.addEventListener("keyup", onKeyUp);
+    }
+    return {
+        kind: "aura-game-input-plan",
+        actions,
+        axes,
+        bufferMs,
+        update,
+        snapshot() {
+            return latestSnapshot;
+        },
+        pressed(action) {
+            return pressedEdges.has(action);
+        },
+        held(action) {
+            return currentHeld.get(action) ?? resolveHeld(action);
+        },
+        released(action) {
+            return releasedEdges.has(action);
+        },
+        buffered(action, windowMs = bufferMs) {
+            return pressedEdges.has(action) || time * 1000 - (lastPressedAt.get(action) ?? Number.NEGATIVE_INFINITY) <= windowMs;
+        },
+        axis(name, negativeAction, positiveAction) {
+            const binding = axes[name];
+            const negative = negativeAction ?? binding?.negative;
+            const positive = positiveAction ?? binding?.positive;
+            if (!negative && !positive)
+                return this.held(name) ? 1 : 0;
+            return (positive && this.held(positive) ? 1 : 0) - (negative && this.held(negative) ? 1 : 0);
+        },
+        press(binding) {
+            pressBinding(binding);
+        },
+        release(binding) {
+            releaseBinding(binding);
+        },
+        setAction(action, held) {
+            if (held) {
+                activeActionOverrides.add(action);
+                record("press", action);
+            }
+            else {
+                activeActionOverrides.delete(action);
+                record("release", action);
+            }
+        },
+        recorded() {
+            return [...replayEvents];
+        },
+        replay(events) {
+            activeBindings.clear();
+            activeActionOverrides.clear();
+            for (const event of events) {
+                if (event.type === "press")
+                    pressBinding(event.binding, false);
+                else
+                    releaseBinding(event.binding, false);
+            }
+            return update(0);
+        },
+        clearReplay() {
+            replayEvents.length = 0;
+        },
+        dispose() {
+            if (target?.removeEventListener) {
+                target.removeEventListener("keydown", onKeyDown);
+                target.removeEventListener("keyup", onKeyUp);
+            }
+            activeBindings.clear();
+            activeActionOverrides.clear();
+            previousHeld.clear();
+            currentHeld.clear();
+            pressedEdges.clear();
+            releasedEdges.clear();
+        }
+    };
+}
+export function createAuraGameRules(options = {}) {
+    return {
+        kind: "aura-game-rules",
+        gravity: options.gravity ?? 24,
+        roundSeconds: options.roundSeconds ?? 90,
+        maxHealth: options.maxHealth ?? 100,
+        maxGuard: options.maxGuard ?? 100,
+        maxMeter: options.maxMeter ?? 100,
+        stageBounds: options.stageBounds ?? {
+            minX: -4.5,
+            maxX: 4.5
+        }
+    };
+}
+export const gameRules = Object.assign(createAuraGameRules, {
+    fighting2D: createGameFighting2DRules
+});
+export function createAuraGameRuntime(options = {}) {
+    return {
+        kind: "aura-game-runtime",
+        loop: {
+            kind: "aura-game-loop-plan",
+            fixedDt: options.loop?.fixedDt ?? 1 / 60,
+            maxSubSteps: options.loop?.maxSubSteps ?? 5,
+            timeScale: options.loop?.timeScale ?? 1
+        },
+        rules: createAuraGameRules(options.rules),
+        input: options.input ? createGameInput(options.input) : undefined,
+        combat: createCombatWorld(),
+        camera: createGameCameraDirector({
+            stageBounds: {
+                minX: options.rules?.stageBounds?.minX ?? -4.5,
+                maxX: options.rules?.stageBounds?.maxX ?? 4.5
+            }
+        }),
+        effects: createGameEffects({ poolSize: options.effectPoolSize }),
+        bodies: []
+    };
+}
+export const game = {
+    createRuntime: createAuraGameRuntime,
+    rules: gameRules,
+    loop: (options = {}) => ({
+        kind: "aura-game-loop-plan",
+        fixedDt: options.fixedDt ?? 1 / 60,
+        maxSubSteps: options.maxSubSteps ?? 5,
+        timeScale: options.timeScale ?? 1
+    }),
+    frameLoop: createFrameLoop,
+    runtimeNode: createRuntimeNodeSpec,
+    input: createGameInput,
+    inputReplay: createGameInputReplay,
+    inputReplayDriver: createGameInputReplayDriver,
+    inputReplayEventsAt: gameInputReplayEventsAt,
+    touchControls: createGameTouchControlLayout,
+    kinematicBody: createGameKinematicBody,
+    jumpAssist: createGameJumpAssist,
+    collider: {
+        box: createGameBoxCollider,
+        sphere: createGameSphereCollider,
+        capsule: createGameCapsuleCollider,
+        rect: createGameRectCollider,
+        aabb: gameColliderAabb,
+        factories: gameColliders
+    },
+    hitbox: gameHitboxes,
+    hurtbox: gameHurtboxes,
+    guardbox: gameGuardboxes,
+    pushbox: gamePushboxes,
+    trigger: gameTriggerVolumes,
+    combatWorld: createCombatWorld,
+    combatEvents: applyGameCombatEventsToRuntime,
+    cameraDirector: createGameCameraDirector,
+    effects: createGameEffects,
+    effectPresets: gameEffectPresets,
+    debug: {
+        colliders: createGameColliderDebugGeometry,
+        hitboxes: createGameHitboxDebugGeometry,
+        combat: createGameCombatDebugGeometry,
+        overlay: createGameDebugOverlayData,
+        sceneNodes: createGameDebugSceneNodes
+    },
+    hud: {
+        health: createGameHudHealthBinding,
+        meter: createGameHudMeterBinding,
+        timer: createGameHudTimerBinding,
+        combo: createGameHudComboBinding,
+        round: createGameHudRoundBinding,
+        debugToggle: createGameHudDebugToggleBinding,
+        bindings: createGameHudBindings,
+        snapshot: createGameHudSnapshot
+    },
+    accessibility: {
+        label: createGameAccessibilityLabel,
+        focus: createGameAccessibilityFocus,
+        reducedMotion: createGameReducedMotionSource,
+        reducedFlash: createGameReducedFlashSource,
+        highContrast: createGameHighContrastSource,
+        pauseControls: createGamePauseControlsSource,
+        settings: createGameAccessibilityRuntimeSettings
+    },
+    fighting: createFightingGameKit,
+    evidence: collectGameRuntimeEvidence
+};
+export const cartoon = {
+    episodePlan: createPromptAnimationEpisodePlan,
+    storyBible: createPromptAnimationStoryBible,
+    storyboard: definePromptAnimationStoryboard,
+    shotTimeline: createShotTimeline,
+    shotPlaybackPlan: createShotPlaybackPlan,
+    sampleShotPlaybackPlan,
+    applyShotPlaybackFrame,
+    installShotPlayback,
+    captionsFromDialogue: deriveCaptionTrackFromDialogue,
+    captionCueAtTime,
+    captionTimingProof: createCaptionTimingProof,
+    visemeTrack: createAuraVoiceVisemeTrack,
+    primitiveMouthVisemes: createPrimitiveMouthVisemeCues,
+    glbBlendshapeViseme: createGlbBlendshapeVisemeCue,
+    sampleVisemeTrack,
+    auraVoiceBridgePackage: createAuraVoiceBridgePackage,
+    sampleAuraVoiceBridgeAtTime,
+    auraVoiceRerenderPlan: createAuraVoiceRerenderPlan,
+    auraVoiceDubRerenderProof: createAuraVoiceDubRerenderProof,
+    director: createCartoonDirectorPlan,
+    performance: createCartoonPerformance,
+    renderQueue: createCartoonRenderQueue,
+    renderOutputPackage: createCartoonRenderOutputPackageMetadata,
+    evidence: collectPromptAnimationEvidence
+};
+export const animationStudio = cartoon;
 function collectParticleBudgetDiagnostics(nodes) {
     const flattened = groups.flatten(nodes);
     const particleEffects = flattened.filter((node) => node.kind === "effect" && node.effect === "particles");
@@ -3499,6 +3857,7 @@ export const character = {
     lowPolyHumanoid: (options = {}) => createLowPolyHumanoid(options),
     authoredHumanoid: (options = {}) => createAuthoredLowPolyHumanoid(options),
     primitiveHumanoid: (options = {}) => createHierarchicalPrimitiveHumanoid(options),
+    performance: createCartoonPerformance,
     importedRigRuntime: async (options) => {
         markAuraLazySystemRequested("character-rig", "character.importedRigRuntime");
         const started = performanceNow();
@@ -3550,7 +3909,7 @@ function collectCityInstancingPlan(nodes) {
     ].filter(Boolean);
     return {
         kind: "aura-city-instancing-plan",
-        rendererPath: "createThreePrimitiveBatches",
+        rendererPath: "auraWebGL2PrimitiveBatches",
         windows,
         props,
         roadMarkings,
@@ -4277,17 +4636,46 @@ export const sceneKits = {
     humanoidWalk: (options = {}) => makeSceneKit("humanoidWalk", options),
     productViewer: (asset, options = {}) => makeSceneKit("productViewer", { ...options, asset })
 };
+export function promptSubjectIsResolved(s) {
+    return "asset" in s;
+}
+export async function resolvePromptPlanSubject(plan, resolver) {
+    if (promptSubjectIsResolved(plan.subject)) {
+        return plan;
+    }
+    const intent = plan.subject;
+    const result = await resolver.resolve({ text: intent.intent, constraints: intent.constraints });
+    if (!result) {
+        throw new Error(`No auto-pullable asset matched the prompt-plan intent "${intent.intent}". ` +
+            "Refine the intent or constraints (maxTriangles/license/animated), or provide a concrete typed asset " +
+            "(e.g. a file via `assets add` / a typed asset ref) before compiling.");
+    }
+    const resolvedSubject = {
+        asset: result.asset,
+        ...(intent.label !== undefined ? { label: intent.label } : {})
+    };
+    return { ...plan, subject: resolvedSubject };
+}
 export function definePromptPlan(plan) {
     return plan;
 }
+function requireResolvedPromptSubject(plan) {
+    if (!promptSubjectIsResolved(plan.subject)) {
+        throw new Error(`Cannot compile a prompt plan whose subject is still an unresolved intent ("${plan.subject.intent}"). ` +
+            "Resolve the prompt-plan subject first via resolvePromptPlanSubject(...) or the CLI `assets search`; " +
+            "compile needs a concrete typed asset.");
+    }
+    return plan.subject;
+}
 export function compilePromptPlan(plan) {
-    const sceneBuilder = promptRecipes[plan.sceneType](plan.subject.asset, plan);
+    const subject = requireResolvedPromptSubject(plan);
+    const sceneBuilder = promptRecipes[plan.sceneType](subject.asset, plan);
     return {
         scene: sceneBuilder,
         report: {
             schema: "aura3d-prompt-plan-report/1.0",
             sceneType: plan.sceneType,
-            subjectAssetId: plan.subject.asset.id,
+            subjectAssetId: subject.asset.id,
             recipe: plan.sceneType,
             cameraPreset: plan.camera?.preset ?? defaultCameraPreset(plan.sceneType),
             lightingPreset: plan.lighting?.preset ?? defaultLightingPreset(plan.sceneType),
@@ -4484,6 +4872,10 @@ function repairHintsForPromptPlan(plan) {
 function promptPlanWarnings(plan) {
     const warnings = [];
     const acceptanceCriteria = plan.acceptanceCriteria.map((item) => item.trim()).filter(Boolean);
+    if (!promptSubjectIsResolved(plan.subject)) {
+        warnings.push(`PromptPlan subject is still an unresolved intent ("${plan.subject.intent}"); resolve it via resolvePromptPlanSubject(...) ` +
+            "or the CLI `assets search` to a concrete typed asset before compiling.");
+    }
     if (!plan.subject.label?.trim()) {
         warnings.push("PromptPlan subject is missing a human-readable label; add one so reports and diagnostics describe the visible subject.");
     }
@@ -4521,6 +4913,217 @@ export class AuraRuntimeError extends Error {
         this.code = code;
     }
 }
+function createAuraRuntimeNodeRegistry(snapshot) {
+    let handles = new Map();
+    const registry = {
+        get(id) {
+            return handles.get(id);
+        },
+        require(id) {
+            const handle = handles.get(id);
+            if (!handle) {
+                throw new AuraRuntimeError("missing-asset", `Aura3D runtime node "${id}" was not found. Suggested fix: add .runtime({ id: "${id}" }) to the model, primitive, group, or label you want to mutate.`);
+            }
+            return handle;
+        },
+        has(id) {
+            return handles.has(id);
+        },
+        ids() {
+            return [...handles.keys()];
+        },
+        all() {
+            return [...handles.values()];
+        },
+        reset(nextSnapshot) {
+            handles = collectRuntimeNodeHandles(nextSnapshot);
+        }
+    };
+    registry.reset(snapshot);
+    return registry;
+}
+function collectRuntimeNodeHandles(snapshot) {
+    const next = new Map();
+    for (const node of snapshot.nodes) {
+        const runtime = "runtime" in node ? node.runtime : undefined;
+        if (!runtime?.id)
+            continue;
+        next.set(runtime.id, createRuntimeNodeHandle(node, runtime));
+    }
+    return next;
+}
+function createRuntimeNodeHandle(node, runtime) {
+    const tags = runtime.tags ?? [];
+    const attachedEffects = [];
+    const morphTargetWeights = new Map();
+    let animationBinding;
+    let animationPose;
+    let animationPoseBinding;
+    const getVisible = () => node.kind === "model" ? node.visible !== false : node.visible !== false;
+    const getBounds = () => calculateRuntimeNodeBounds({
+        position: node.position,
+        scale: node.scale,
+        size: "size" in node ? node.size : undefined
+    });
+    return {
+        id: runtime.id,
+        kind: node.kind,
+        name: "name" in node ? node.name : undefined,
+        tags,
+        get position() {
+            return node.position ?? [0, 0, 0];
+        },
+        set position(next) {
+            node.position = next;
+        },
+        get rotation() {
+            return node.rotation ?? [0, 0, 0];
+        },
+        set rotation(next) {
+            node.rotation = next;
+        },
+        get scale() {
+            return node.scale ?? 1;
+        },
+        set scale(next) {
+            node.scale = next;
+        },
+        get visible() {
+            return getVisible();
+        },
+        set visible(next) {
+            node.visible = next;
+        },
+        setPosition(x, y, z) {
+            node.position = [x, y, z];
+            return this;
+        },
+        translate(x, y, z) {
+            const current = node.position ?? [0, 0, 0];
+            node.position = [current[0] + x, current[1] + y, current[2] + z];
+            return this;
+        },
+        setRotation(x, y, z) {
+            node.rotation = [x, y, z];
+            return this;
+        },
+        setScale(scale) {
+            node.scale = scale;
+            return this;
+        },
+        setVisible(visible) {
+            node.visible = visible;
+            return this;
+        },
+        setMaterial(nextMaterial) {
+            node.material = nextMaterial;
+            return this;
+        },
+        play(clip, options = {}) {
+            node.animation = { ...options, clip };
+            return this;
+        },
+        setAnimation(animation) {
+            node.animation = animation;
+            return this;
+        },
+        setAnimationBinding(binding) {
+            animationBinding = binding;
+            return this;
+        },
+        setAnimationPose(pose, metadata) {
+            animationPose = pose ? cloneRuntimeAnimationPose(pose) : undefined;
+            animationPoseBinding = pose ? metadata : undefined;
+            if (pose?.morphTargets) {
+                for (const [name, weight] of Object.entries(pose.morphTargets)) {
+                    const normalizedName = name.trim();
+                    if (normalizedName) {
+                        morphTargetWeights.set(normalizedName, sanitizeRuntimeMorphWeight(weight));
+                    }
+                }
+            }
+            return this;
+        },
+        animationPose() {
+            return animationPose ? cloneRuntimeAnimationPose(animationPose) : undefined;
+        },
+        setMorphTarget(name, weight) {
+            const normalizedName = name.trim();
+            if (!normalizedName) {
+                throw new AuraRuntimeError("missing-asset", "Aura3D morph target name is required.");
+            }
+            morphTargetWeights.set(normalizedName, sanitizeRuntimeMorphWeight(weight));
+            return this;
+        },
+        setMorphTargets(weights) {
+            morphTargetWeights.clear();
+            for (const [name, weight] of Object.entries(weights)) {
+                const normalizedName = name.trim();
+                if (normalizedName) {
+                    morphTargetWeights.set(normalizedName, sanitizeRuntimeMorphWeight(weight));
+                }
+            }
+            return this;
+        },
+        morphTargets() {
+            return Object.fromEntries(morphTargetWeights.entries());
+        },
+        bounds() {
+            return getBounds();
+        },
+        attachEffect(effect) {
+            attachedEffects.push(effect);
+            return this;
+        },
+        effects() {
+            return [...attachedEffects];
+        },
+        snapshot() {
+            return {
+                id: runtime.id,
+                kind: node.kind,
+                name: "name" in node ? node.name : undefined,
+                tags,
+                position: node.position ?? [0, 0, 0],
+                rotation: node.rotation ?? [0, 0, 0],
+                scale: node.scale ?? 1,
+                visible: getVisible(),
+                animation: node.animation,
+                animationBinding,
+                animationPose: animationPose ? cloneRuntimeAnimationPose(animationPose) : undefined,
+                animationPoseBinding,
+                morphTargets: Object.fromEntries(morphTargetWeights.entries()),
+                bounds: getBounds(),
+                effects: [...attachedEffects]
+            };
+        }
+    };
+}
+function cloneRuntimeAnimationPose(pose) {
+    return {
+        bones: Object.fromEntries(Object.entries(pose.bones ?? {}).map(([bone, transform]) => [
+            bone,
+            {
+                position: transform.position ? { ...transform.position } : undefined,
+                rotation: transform.rotation ? { ...transform.rotation } : undefined,
+                scale: transform.scale ? { ...transform.scale } : undefined
+            }
+        ])),
+        morphTargets: pose.morphTargets ? { ...pose.morphTargets } : undefined,
+        rootMotion: pose.rootMotion
+            ? {
+                translation: pose.rootMotion.translation ? { ...pose.rootMotion.translation } : undefined,
+                rotation: pose.rootMotion.rotation ? { ...pose.rootMotion.rotation } : undefined
+            }
+            : undefined,
+        metadata: pose.metadata ? { ...pose.metadata } : undefined
+    };
+}
+function sanitizeRuntimeMorphWeight(weight) {
+    if (!Number.isFinite(weight))
+        return 0;
+    return Math.max(0, Math.min(1, weight));
+}
 export function createAuraApp(target, options) {
     let snapshot = normalizeSceneSnapshot(options.scene);
     let renderSnapshot = flattenSceneSnapshot(snapshot);
@@ -4536,6 +5139,32 @@ export function createAuraApp(target, options) {
     let lastTime = 0;
     let mountRevision = 0;
     let canvasRuntimePhysics;
+    const runtimeNodes = createAuraRuntimeNodeRegistry(renderSnapshot);
+    const frameCallbacks = new Set();
+    let runtimePaused = options.autoStart === false;
+    let runtimeFrame = 0;
+    let runtimeTime = 0;
+    const runtimeFixedDt = 1 / 60;
+    let runtimeAlpha = 0;
+    const ownedInputControllers = new Set();
+    const runRuntimeFrame = (dt, source) => {
+        runtimeFrame += 1;
+        runtimeTime += dt;
+        runtimeAlpha = runtimeFixedDt > 0 ? Math.max(0, Math.min(1, (dt % runtimeFixedDt) / runtimeFixedDt)) : 0;
+        const frame = {
+            dt,
+            fixedDt: runtimeFixedDt,
+            time: runtimeTime,
+            frame: runtimeFrame,
+            alpha: runtimeAlpha,
+            paused: runtimePaused,
+            source,
+            substep: 1,
+            substeps: 1
+        };
+        for (const callback of [...frameCallbacks])
+            callback(frame);
+    };
     const shouldUseProductionRendererForCurrentScene = () => Boolean(canvas && renderSnapshot.nodes.some(isWebGLRenderableNode) && typeof window !== "undefined");
     const resetDiagnosticsForCurrentScene = (backend) => {
         const fresh = createInitialDiagnostics(renderSnapshot);
@@ -4556,7 +5185,11 @@ export function createAuraApp(target, options) {
             return;
         const delta = lastTime > 0 ? Math.max(1, time - lastTime) : 16.67;
         lastTime = time;
-        canvasRuntimePhysics?.step(delta / 1000);
+        const dt = delta / 1000;
+        if (!runtimePaused) {
+            runRuntimeFrame(dt, "raf");
+            canvasRuntimePhysics?.step(dt);
+        }
         diagnosticsState.evidence = collectAuraSceneEvidence(renderSnapshot);
         diagnosticsState.fps = Math.round(1000 / delta);
         diagnosticsState.drawCalls = renderSceneToCanvas(canvas, renderSnapshot, time);
@@ -4583,7 +5216,7 @@ export function createAuraApp(target, options) {
         overlay?.update();
         const revision = ++mountRevision;
         if (shouldUseProductionRenderer && canvas) {
-            void startProductionRender(canvas, renderSnapshot, diagnosticsState, options, overlay)
+            void startProductionRender(canvas, renderSnapshot, diagnosticsState, options, overlay, runRuntimeFrame, () => runtimePaused)
                 .then((controller) => {
                 if (disposed || revision !== mountRevision) {
                     controller.dispose();
@@ -4617,11 +5250,71 @@ export function createAuraApp(target, options) {
         setScene(nextScene) {
             snapshot = normalizeSceneSnapshot(nextScene);
             renderSnapshot = flattenSceneSnapshot(snapshot);
+            runtimeNodes.reset(renderSnapshot);
             mountCurrentScene();
         },
+        nodes: runtimeNodes,
+        get runtime() {
+            return {
+                paused: runtimePaused,
+                frame: runtimeFrame,
+                time: runtimeTime,
+                fixedDt: runtimeFixedDt,
+                alpha: runtimeAlpha
+            };
+        },
+        onFrame(callback) {
+            frameCallbacks.add(callback);
+            return () => {
+                frameCallbacks.delete(callback);
+            };
+        },
+        offFrame(callback) {
+            frameCallbacks.delete(callback);
+        },
+        input(inputOptions) {
+            const controller = createGameInput(inputOptions);
+            ownedInputControllers.add(controller);
+            return controller;
+        },
+        pause() {
+            runtimePaused = true;
+        },
+        resume() {
+            runtimePaused = false;
+            if (!animationHandle && !productionController && options.autoStart !== false && typeof requestAnimationFrame !== "undefined") {
+                animationHandle = requestAnimationFrame(render);
+            }
+        },
+        step(dt = 1 / 60) {
+            const seconds = Math.max(0, dt);
+            runRuntimeFrame(seconds, "manual");
+            canvasRuntimePhysics?.step(seconds);
+            const previousPaused = runtimePaused;
+            runtimePaused = true;
+            if (productionController) {
+                productionController.render(performanceNow());
+            }
+            else {
+                render(performanceNow());
+            }
+            runtimePaused = previousPaused;
+        },
         diagnostics() {
             return snapshotDiagnostics(diagnosticsState);
         },
+        evidence(evidenceOptions = {}) {
+            return collectGameRuntimeEvidenceV105({
+                runtime: {
+                    paused: runtimePaused,
+                    frame: runtimeFrame,
+                    time: runtimeTime,
+                    fixedDt: runtimeFixedDt,
+                    alpha: runtimeAlpha
+                },
+                nodes: runtimeNodes
+            }, evidenceOptions);
+        },
         screenshot() {
             return captureAuraScreenshot(canvas);
         },
@@ -4629,6 +5322,9 @@ export function createAuraApp(target, options) {
             disposed = true;
             if (animationHandle && typeof cancelAnimationFrame !== "undefined")
                 cancelAnimationFrame(animationHandle);
+            for (const controller of ownedInputControllers)
+                controller.dispose();
+            ownedInputControllers.clear();
             productionController?.dispose();
             overlay?.dispose();
         }
@@ -4652,6 +5348,10 @@ export function collectAuraSceneEvidence(sceneValue) {
     const assetProvenance = snapshot.nodes
         .filter((node) => node.kind === "model")
         .map((node) => createAssetProvenance(node.asset));
+    const runtimeNodeIds = snapshot.nodes
+        .map((node) => "runtime" in node ? node.runtime?.id : undefined)
+        .filter((id) => Boolean(id));
+    const expectsGameRuntime = runtimeNodeIds.length > 0 || interactionNodes.some((node) => node.mode === "keyboard" || node.mode === "drag-vector" || node.mode === "click-impulse");
     return {
         physics: {
             worldAttached: Boolean(snapshot.physics),
@@ -4689,6 +5389,31 @@ export function collectAuraSceneEvidence(sceneValue) {
             collisionAvoidance: labelNodes.filter((node) => node.collisionAvoidance === true).length
         },
         performance: createPerformanceEvidence(snapshot),
+        gameRuntime: collectGameRuntimeEvidenceV105({
+            runtime: {
+                frame: 0,
+                time: 0,
+                paused: true
+            },
+            nodes: {
+                ids: () => runtimeNodeIds
+            }
+        }, {
+            animation: {
+                controllers: animatedNodes.length,
+                activeClips: clips,
+                eventCount: 0
+            },
+            assets: {
+                typedAssets: assetProvenance.filter((asset) => asset.source === "typed-aura-assets-manifest").length,
+                missingAssets: []
+            },
+            source: {
+                mode: "scene-source",
+                expectsGame: expectsGameRuntime,
+                label: "collectAuraSceneEvidence"
+            }
+        }),
         rendering: createRendererDiagnosticReport(snapshot),
         assets: assetProvenance
     };
@@ -4730,7 +5455,11 @@ function collectHelperPerformanceBudgets(nodes) {
     const helpers = new Set();
     if (hasName("visible rigid body cube") || hasName("physics collider debug line"))
         helpers.add("physicsPlayground");
-    if (hasName("particle collision ground plane") || hasName("gravity fountain plume"))
+    if (hasName("particle collision ground plane") ||
+        hasName("fountain collision ground plane") ||
+        hasName("particle emission nozzle") ||
+        hasName("fountain droplet plume") ||
+        hasName("gravity fountain plume"))
         helpers.add("particleFountain");
     if (hasName("smooth orbit ring") || hasName("readable planet label"))
         helpers.add("solarSystem");
@@ -4805,7 +5534,7 @@ function isRenderableModelNode(node) {
 function isWebGLRenderableNode(node) {
     return isRenderableModelNode(node) || node.kind === "primitive";
 }
-async function startProductionRender(canvas, snapshot, diagnosticsState, options, overlay) {
+async function startProductionRender(canvas, snapshot, diagnosticsState, options, overlay, beforeRender, isPaused = () => false) {
     const renderableNode = snapshot.nodes.find(isWebGLRenderableNode);
     if (!renderableNode) {
         throw new AuraRuntimeError("missing-asset", "Aura3D production rendering requires at least one typed model asset or primitive. Suggested fix: add model(assets.product), primitives.box(), primitives.sphere(), primitives.cylinder(), or primitives.plane().");
@@ -4815,9 +5544,14 @@ async function startProductionRender(canvas, snapshot, diagnosticsState, options
     const continuousRender = shouldContinuouslyRender(snapshot);
     let disposed = false;
     let animationHandle = 0;
+    let lastTime = 0;
     const renderFrame = (time = performanceNow()) => {
         if (disposed)
             return;
+        const delta = lastTime > 0 ? Math.max(1, time - lastTime) : 16.67;
+        lastTime = time;
+        if (!isPaused())
+            beforeRender?.(delta / 1000, "raf");
         const drawCalls = renderer.render(time);
         diagnosticsState.backend = "webgl2";
         diagnosticsState.fps = diagnosticsState.fps || 60;
@@ -4832,6 +5566,9 @@ async function startProductionRender(canvas, snapshot, diagnosticsState, options
     };
     renderFrame();
     return {
+        render(time = performanceNow()) {
+            renderFrame(time);
+        },
         dispose() {
             disposed = true;
             if (animationHandle && typeof cancelAnimationFrame !== "undefined")
@@ -4846,6 +5583,8 @@ function shouldContinuouslyRender(snapshot) {
     if (snapshot.camera.mode === "dolly" || snapshot.camera.mode === "follow" || snapshot.camera.mode === "path" || snapshot.camera.mode === "flythrough")
         return true;
     return snapshot.nodes.some((node) => {
+        if ("runtime" in node && node.runtime?.mutable !== false)
+            return true;
         if ((node.kind === "model" || node.kind === "primitive") && node.animation)
             return true;
         if (node.kind !== "effect")
@@ -4854,14 +5593,7 @@ function shouldContinuouslyRender(snapshot) {
     });
 }
 async function createProductionSceneRenderer(canvas, snapshot) {
-    try {
-        return await createThreeSceneRenderer(canvas, snapshot);
-    }
-    catch (error) {
-        if (typeof console !== "undefined")
-            console.warn("Aura3D Three.js renderer fallback:", error);
-        return await createWebGLSceneRenderer(canvas, snapshot);
-    }
+    return await createWebGLSceneRenderer(canvas, snapshot);
 }
 function colorToClearColor(color) {
     if (typeof color === "string" && /^#[0-9a-f]{6}$/i.test(color)) {
@@ -4870,672 +5602,10 @@ function colorToClearColor(color) {
     }
     return [0.02, 0.025, 0.035, 1];
 }
-function resolveThreeToneMappingExposure(snapshot) {
-    const names = groups.flatten(snapshot.nodes).map((node) => "name" in node ? node.name?.toLowerCase() ?? "" : "");
-    const category = resolveRendererSceneCategory(snapshot, names);
-    if (sceneExposurePresets[category])
-        return sceneExposurePresets[category].exposure;
-    const [r, g, b] = colorToClearColor(snapshot.background);
-    const luminance = r * 0.2126 + g * 0.7152 + b * 0.0722;
-    const hasProductOrMaterialLighting = snapshot.nodes.some((node) => node.kind === "environment" && (node.environment === "studio" || node.environment === "material-lab" || node.environment === "product-hero"));
-    const hasDarkCinematicCues = snapshot.nodes.some((node) => (node.kind === "effect" && (node.effect === "fog" || node.effect === "bloom")) ||
-        (node.kind === "primitive" && node.material?.emissive !== undefined));
-    if (hasProductOrMaterialLighting || luminance > 0.72)
-        return 0.92;
-    if (luminance < 0.08 && hasDarkCinematicCues)
-        return 1.34;
-    if (luminance < 0.16)
-        return 1.18;
-    return 1.05;
-}
 function colorWithAlpha(color, alpha) {
     const [r, g, b] = colorToClearColor(color);
     return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${Math.min(1, Math.max(0, alpha))})`;
 }
-async function createThreeSceneRenderer(canvas, snapshot) {
-    const THREE = await import("three");
-    const hasRenderableModels = groups.flatten(snapshot.nodes).some((node) => node.kind === "model" && isRenderableModelNode(node));
-    const GLTFLoader = hasRenderableModels
-        ? (await import("three/examples/jsm/loaders/GLTFLoader.js")).GLTFLoader
-        : undefined;
-    const renderer = new THREE.WebGLRenderer({
-        canvas,
-        antialias: true,
-        alpha: false,
-        preserveDrawingBuffer: true,
-        powerPreference: "high-performance"
-    });
-    renderer.setPixelRatio(Math.min(2, Math.max(1, window.devicePixelRatio || 1)));
-    renderer.setSize(canvas.width, canvas.height, false);
-    renderer.outputColorSpace = THREE.SRGBColorSpace;
-    renderer.toneMapping = THREE.ACESFilmicToneMapping;
-    renderer.toneMappingExposure = resolveThreeToneMappingExposure(snapshot);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
-    const threeScene = new THREE.Scene();
-    threeScene.background = new THREE.Color(snapshot.background);
-    const materialInspectionEnvironment = await createThreeMaterialInspectionEnvironment(THREE, renderer, snapshot);
-    if (materialInspectionEnvironment) {
-        threeScene.environment = materialInspectionEnvironment.texture;
-        if ("environmentIntensity" in threeScene) {
-            threeScene.environmentIntensity = materialInspectionEnvironment.intensity;
-        }
-    }
-    const fog = snapshot.nodes.find((node) => node.kind === "effect" && node.effect === "fog");
-    if (fog) {
-        threeScene.fog = new THREE.FogExp2(new THREE.Color(fog.color ?? "#9fb7d9"), Math.max(0.004, (fog.density ?? 0.1) * 0.045));
-    }
-    addThreeLights(THREE, threeScene, snapshot.nodes);
-    const loader = GLTFLoader ? new GLTFLoader() : undefined;
-    const disposables = materialInspectionEnvironment
-        ? [materialInspectionEnvironment.texture, materialInspectionEnvironment.generator]
-        : [];
-    const frameUpdaters = [];
-    const primitiveBatchNodes = [];
-    const namedObjects = new Map();
-    const hoverRuntimeNames = collectThreeHoverRuntimeObjectNames(snapshot);
-    const miniGolfRuntimeRequested = hasThreeMiniGolfRuntimeInteraction(snapshot);
-    const runtimePhysics = miniGolfRuntimeRequested ? undefined : createRuntimeScenePhysics(snapshot);
-    const effectNodes = collectThreeEffectNodes(snapshot);
-    for (const node of snapshot.nodes) {
-        if (node.kind === "label") {
-            // HUD labels are screen-space overlays, not world geometry. Rendering them as
-            // 3D sprites produced giant text clipping across the scene, so skip them here.
-            if (node.label === "hud")
-                continue;
-            const label = createThreeLabelNode(THREE, node);
-            threeScene.add(label);
-            registerThreeNamedObject(namedObjects, node, label);
-            registerThreeNodeAnimation(label, node, frameUpdaters);
-            disposables.push(label, label.material, label.material.map);
-            continue;
-        }
-        if (node.kind === "model" && isRenderableModelNode(node)) {
-            if (!loader) {
-                throw createAuraAssetLoadError(node.asset, "the GLB loader was not initialized for this scene");
-            }
-            const gltf = await loader.loadAsync(new URL(node.asset.url, document.baseURI).href);
-            const modelRoot = gltf.scene ?? gltf.scenes?.[0];
-            if (!modelRoot) {
-                throw createAuraAssetLoadError(node.asset, "the GLB loaded but did not contain a default scene");
-            }
-            modelRoot.traverse((child) => {
-                if (!child.isMesh)
-                    return;
-                child.castShadow = node.castShadow;
-                child.receiveShadow = node.receiveShadow;
-                if (node.material)
-                    child.material = createThreeMaterial(THREE, node.material);
-                else if (child.material)
-                    enhanceLoadedMaterial(child.material);
-                disposables.push(child.geometry, child.material);
-            });
-            const pivot = normalizeThreeModel(THREE, modelRoot, node);
-            threeScene.add(pivot);
-            registerThreeNamedObject(namedObjects, node, pivot);
-            runtimePhysics?.bindObject(node, pivot);
-            registerThreeModelClipAnimation(THREE, gltf, modelRoot, node, frameUpdaters, disposables);
-            registerThreeNodeAnimation(pivot, node, frameUpdaters);
-            disposables.push(modelRoot);
-            continue;
-        }
-        if (node.kind === "primitive") {
-            if (isThreeReadableTextLabel(node)) {
-                const label = createThreeReadableTextLabel(THREE, node);
-                threeScene.add(label);
-                registerThreeNamedObject(namedObjects, node, label);
-                disposables.push(label, label.material, label.material.map);
-                continue;
-            }
-            if (!node.animation && !node.physics && !isThreeMiniGolfRuntimePrimitive(node) && !hoverRuntimeNames.has(node.name ?? "")) {
-                primitiveBatchNodes.push(node);
-                continue;
-            }
-            const mesh = createThreePrimitive(THREE, node);
-            threeScene.add(mesh);
-            registerThreeNamedObject(namedObjects, node, mesh);
-            runtimePhysics?.bindObject(node, mesh);
-            registerThreeNodeAnimation(mesh, node, frameUpdaters);
-            disposables.push(mesh.geometry, mesh.material);
-            continue;
-        }
-    }
-    for (const batch of createThreePrimitiveBatches(THREE, primitiveBatchNodes)) {
-        threeScene.add(batch);
-        disposables.push(batch, batch.geometry, batch.material);
-    }
-    const contactOcclusionEffect = effectNodes.find((node) => node.effect === "contact-occlusion");
-    let contactReceiverAdded = false;
-    if (contactOcclusionEffect) {
-        const contactReceiver = createThreeContactShadowReceiver(THREE, snapshot, contactOcclusionEffect);
-        threeScene.add(contactReceiver);
-        disposables.push(contactReceiver, contactReceiver.geometry, contactReceiver.material);
-        contactReceiverAdded = true;
-    }
-    const bloomEffect = effectNodes.find((node) => node.effect === "bloom");
-    const rainEffect = effectNodes.find((node) => node.effect === "rain");
-    if (rainEffect) {
-        const rain = createThreeRain(THREE, rainEffect);
-        threeScene.add(rain);
-        disposables.push(rain, rain.userData.mistTexture);
-        if (typeof rain.userData.update === "function")
-            frameUpdaters.push(rain.userData.update);
-    }
-    const particleEffects = effectNodes.filter((node) => node.effect === "particles");
-    for (const particleEffect of particleEffects) {
-        const particles = createThreeParticles(THREE, particleEffect);
-        threeScene.add(particles);
-        disposables.push(particles, particles.geometry, particles.material);
-        if (typeof particles.userData.update === "function")
-            frameUpdaters.push(particles.userData.update);
-    }
-    const cameraObject = new THREE.PerspectiveCamera(snapshot.camera.fov ?? 45, canvas.width / Math.max(1, canvas.height), 0.05, 100);
-    const postProcess = hasThreePostProcessEffects(effectNodes)
-        ? await createThreePostProcessPipeline(THREE, renderer, threeScene, cameraObject, snapshot)
-        : null;
-    let fallbackBloomAdded = false;
-    if (bloomEffect && !postProcess) {
-        const bloom = createThreeBloom(THREE, snapshot, bloomEffect);
-        threeScene.add(bloom);
-        disposables.push(bloom, bloom.userData.texture);
-        if (typeof bloom.userData.update === "function")
-            frameUpdaters.push(bloom.userData.update);
-        fallbackBloomAdded = true;
-    }
-    const miniGolfRuntime = createThreeMiniGolfRuntime(canvas, snapshot, namedObjects);
-    if (miniGolfRuntime)
-        frameUpdaters.push((time) => miniGolfRuntime.update(time));
-    const hoverRuntime = createThreeHoverRuntime(THREE, canvas, cameraObject, snapshot, namedObjects);
-    const actualPasses = [
-        ...(postProcess?.passNames ?? []),
-        ...(contactReceiverAdded ? ["contact-shadow-receiver"] : [])
-    ];
-    const fallbackPasses = fallbackBloomAdded ? ["sprite-bloom-halo"] : [];
-    const runtimeRendererDiagnostics = createRendererDiagnosticReport(snapshot, {
-        mounted: true,
-        backend: "three-webgl",
-        postprocess: {
-            renderPass: postProcess?.passNames.includes("render") ?? false,
-            outputPass: postProcess?.passNames.includes("output") ?? false,
-            bloomPass: postProcess?.passNames.includes("bloom") ?? false,
-            ambientOcclusionPass: postProcess?.passNames.includes("ssao") ?? false,
-            contactOcclusionReceiver: contactReceiverAdded,
-            pixelBacked: actualPasses.length > 0,
-            actualPasses,
-            fallbackPasses
-        },
-        environment: {
-            enabled: Boolean(materialInspectionEnvironment),
-            preset: materialInspectionEnvironment?.preset,
-            intensity: materialInspectionEnvironment?.intensity,
-            evidence: materialInspectionEnvironment
-                ? `runtime PMREM environment initialized from ${materialInspectionEnvironment.preset}`
-                : "no runtime PMREM/IBL environment initialized"
-        },
-        warnings: postProcess?.warnings ?? []
-    });
-    let lastPhysicsTime = 0;
-    return {
-        diagnostics: runtimeRendererDiagnostics,
-        render(time) {
-            if (renderer.domElement.width !== canvas.width || renderer.domElement.height !== canvas.height) {
-                renderer.setSize(canvas.width, canvas.height, false);
-                postProcess?.setSize(canvas.width, canvas.height);
-            }
-            for (const update of frameUpdaters)
-                update(time);
-            const physicsDelta = lastPhysicsTime > 0 ? Math.max(0, (time - lastPhysicsTime) / 1000) : 1 / 60;
-            lastPhysicsTime = time;
-            runtimePhysics?.step(physicsDelta);
-            updateThreeCamera(THREE, cameraObject, snapshot, canvas, time);
-            if (postProcess)
-                postProcess.render();
-            else
-                renderer.render(threeScene, cameraObject);
-            return Math.max(1, renderer.info.render.calls);
-        },
-        dispose() {
-            miniGolfRuntime?.dispose();
-            hoverRuntime?.dispose();
-            for (const item of disposables)
-                disposeThreeResource(item);
-            postProcess?.dispose();
-            renderer.dispose();
-        }
-    };
-}
-function registerThreeNamedObject(registry, node, object) {
-    const name = "name" in node ? node.name : undefined;
-    if (name)
-        registry.set(name, object);
-}
-function collectThreeHoverRuntimeInteractions(snapshot) {
-    return groups.flatten(snapshot.nodes).filter((node) => node.kind === "interaction" &&
-        node.mode === "hover" &&
-        Boolean(node.target ?? node.selected));
-}
-function collectThreeHoverRuntimeObjectNames(snapshot) {
-    const names = new Set();
-    for (const interaction of collectThreeHoverRuntimeInteractions(snapshot)) {
-        if (interaction.target)
-            names.add(interaction.target);
-        if (interaction.selected)
-            names.add(interaction.selected);
-    }
-    return names;
-}
-function createThreeHoverRuntime(THREE, canvas, cameraObject, snapshot, objects) {
-    const interactions = collectThreeHoverRuntimeInteractions(snapshot);
-    if (interactions.length === 0)
-        return undefined;
-    const entries = interactions
-        .map((interaction) => {
-        const targetName = interaction.target ?? interaction.selected;
-        const selectedName = interaction.selected ?? interaction.target;
-        return {
-            targetName,
-            selectedName,
-            target: targetName ? objects.get(targetName) : undefined,
-            selected: selectedName ? objects.get(selectedName) : undefined
-        };
-    })
-        .filter((entry) => Boolean(entry.targetName && entry.selectedName && entry.target && entry.selected));
-    if (entries.length === 0)
-        return undefined;
-    const ownerWindow = canvas.ownerDocument?.defaultView;
-    const pointer = new THREE.Vector2();
-    const raycaster = new THREE.Raycaster();
-    const baseScales = new Map();
-    let activeEntry;
-    let pointerState = { x: 0, y: 0 };
-    const setHighlighted = (object, highlighted) => {
-        if (!object)
-            return;
-        if (!baseScales.has(object) && typeof object.scale?.clone === "function")
-            baseScales.set(object, object.scale.clone());
-        const baseScale = baseScales.get(object);
-        if (baseScale && object.scale) {
-            object.scale.copy(baseScale);
-            if (highlighted)
-                object.scale.multiplyScalar(1.1);
-        }
-        object.traverse?.((child) => {
-            const materials = Array.isArray(child.material) ? child.material : child.material ? [child.material] : [];
-            for (const materialValue of materials) {
-                if (!materialValue || typeof materialValue !== "object")
-                    continue;
-                if (materialValue.userData?.auraHoverBaseEmissiveIntensity === undefined) {
-                    materialValue.userData = materialValue.userData ?? {};
-                    materialValue.userData.auraHoverBaseEmissiveIntensity = materialValue.emissiveIntensity ?? 0;
-                }
-                if ("emissiveIntensity" in materialValue) {
-                    const base = Number(materialValue.userData.auraHoverBaseEmissiveIntensity ?? 0);
-                    materialValue.emissiveIntensity = highlighted ? Math.max(base, 0.9) : base;
-                }
-                materialValue.needsUpdate = true;
-            }
-        });
-    };
-    const publish = () => {
-        const state = {
-            kind: "aura-hover-browser-runtime",
-            mounted: true,
-            active: Boolean(activeEntry),
-            target: activeEntry?.targetName,
-            selected: activeEntry?.selectedName,
-            pointer: pointerState
-        };
-        canvas.dataset.auraHoverRuntime = "mounted";
-        canvas.dataset.auraHoverActive = String(state.active);
-        if (state.target)
-            canvas.dataset.auraHoverTarget = state.target;
-        else
-            delete canvas.dataset.auraHoverTarget;
-        if (state.selected)
-            canvas.dataset.auraHoverSelected = state.selected;
-        else
-            delete canvas.dataset.auraHoverSelected;
-        if (ownerWindow) {
-            ownerWindow.__AURA3D_HOVER__ = state;
-        }
-    };
-    const setActiveEntry = (next) => {
-        if (activeEntry?.selected === next?.selected) {
-            publish();
-            return;
-        }
-        if (activeEntry)
-            setHighlighted(activeEntry.selected, false);
-        activeEntry = next;
-        if (activeEntry)
-            setHighlighted(activeEntry.selected, true);
-        publish();
-    };
-    const resolveHitEntry = (hitObject) => entries.find((entry) => isThreeObjectOrDescendant(hitObject, entry.target));
-    const onPointerMove = (event) => {
-        const rect = canvas.getBoundingClientRect();
-        const width = Math.max(1, rect.width);
-        const height = Math.max(1, rect.height);
-        pointerState = { x: event.clientX - rect.left, y: event.clientY - rect.top };
-        pointer.x = (pointerState.x / width) * 2 - 1;
-        pointer.y = -(pointerState.y / height) * 2 + 1;
-        raycaster.setFromCamera(pointer, cameraObject);
-        const hits = raycaster.intersectObjects(entries.map((entry) => entry.target), true);
-        setActiveEntry(hits.length > 0 ? resolveHitEntry(hits[0]?.object) : undefined);
-    };
-    const onPointerLeave = () => setActiveEntry(undefined);
-    canvas.addEventListener("pointermove", onPointerMove);
-    canvas.addEventListener("pointerleave", onPointerLeave);
-    publish();
-    return {
-        dispose() {
-            canvas.removeEventListener("pointermove", onPointerMove);
-            canvas.removeEventListener("pointerleave", onPointerLeave);
-            setActiveEntry(undefined);
-            if (ownerWindow) {
-                const target = ownerWindow;
-                if (target.__AURA3D_HOVER__?.kind === "aura-hover-browser-runtime")
-                    delete target.__AURA3D_HOVER__;
-            }
-        }
-    };
-}
-function isThreeObjectOrDescendant(object, root) {
-    let current = object;
-    while (current) {
-        if (current === root)
-            return true;
-        current = current.parent;
-    }
-    return false;
-}
-function hasThreeMiniGolfRuntimeInteraction(snapshot) {
-    return snapshot.nodes.some((node) => node.kind === "interaction" &&
-        (node.mode === "drag-vector" || node.mode === "click-impulse") &&
-        node.target === "white physics golf ball");
-}
-function isThreeMiniGolfRuntimePrimitive(node) {
-    return [
-        "white physics golf ball",
-        "ball contact shadow on felt",
-        "ball aim selection ring",
-        "cyan aim direction line",
-        "shot power meter fill",
-        "follow camera target beacon above ball"
-    ].includes(node.name ?? "");
-}
-function createThreeMiniGolfRuntime(canvas, snapshot, objects) {
-    if (!hasThreeMiniGolfRuntimeInteraction(snapshot))
-        return undefined;
-    const state = createMiniGolfStateController();
-    const ownerWindow = canvas.ownerDocument?.defaultView;
-    let metrics = state.snapshot();
-    let pointerStart;
-    let inputMode = "idle";
-    let lastShot = { vector: metrics.aimVector, power: 0 };
-    let lastUpdateTime = 0;
-    const setObjectPosition = (name, position) => {
-        const object = objects.get(name);
-        object?.position?.set(position[0], position[1], position[2]);
-    };
-    const syncObjects = () => {
-        const ball = metrics.ballPosition;
-        setObjectPosition("white physics golf ball", ball);
-        setObjectPosition("ball contact shadow on felt", [ball[0], 0.018, ball[2]]);
-        setObjectPosition("ball aim selection ring", [ball[0], 0.035, ball[2]]);
-        setObjectPosition("follow camera target beacon above ball", [ball[0], ball[1] + 0.46, ball[2]]);
-        setObjectPosition("cyan aim direction line", [ball[0] + metrics.aimVector[0] * 0.54, 0.085, ball[2] + metrics.aimVector[2] * 0.54]);
-    };
-    const publish = () => {
-        const runtimeState = {
-            kind: "aura-mini-golf-browser-runtime",
-            mounted: true,
-            inputMode,
-            shotVector: lastShot.vector,
-            shotPower: lastShot.power,
-            ...metrics
-        };
-        canvas.dataset.auraMiniGolfRuntime = "mounted";
-        canvas.dataset.auraMiniGolfShots = String(metrics.shots);
-        canvas.dataset.auraMiniGolfScore = String(metrics.score);
-        canvas.dataset.auraMiniGolfCupTriggered = String(metrics.cupTriggered);
-        if (ownerWindow) {
-            ownerWindow.__AURA3D_MINI_GOLF__ = runtimeState;
-        }
-    };
-    const onPointerDown = (event) => {
-        pointerStart = { x: event.clientX, y: event.clientY };
-        inputMode = "aiming";
-        canvas.setPointerCapture?.(event.pointerId);
-        publish();
-    };
-    const onPointerMove = (event) => {
-        if (!pointerStart)
-            return;
-        lastShot = miniGolfPointerShotFromDrag(pointerStart, { x: event.clientX, y: event.clientY });
-        inputMode = "aiming";
-        publish();
-    };
-    const onPointerUp = (event) => {
-        const start = pointerStart ?? { x: event.clientX - 64, y: event.clientY + 36 };
-        pointerStart = undefined;
-        if (metrics.cupTriggered)
-            metrics = state.reset();
-        lastShot = miniGolfPointerShotFromDrag(start, { x: event.clientX, y: event.clientY });
-        metrics = state.shoot(lastShot);
-        inputMode = "shot";
-        syncObjects();
-        publish();
-        canvas.releasePointerCapture?.(event.pointerId);
-    };
-    canvas.addEventListener("pointerdown", onPointerDown);
-    canvas.addEventListener("pointermove", onPointerMove);
-    canvas.addEventListener("pointerup", onPointerUp);
-    canvas.addEventListener("pointercancel", onPointerUp);
-    syncObjects();
-    publish();
-    return {
-        update(time) {
-            const elapsed = lastUpdateTime > 0 ? Math.max(0, time - lastUpdateTime) : 16.67;
-            lastUpdateTime = time;
-            if (metrics.shots > 0 && !metrics.settled && !metrics.cupTriggered) {
-                const steps = Math.max(1, Math.min(10, Math.round(elapsed / 16.67)));
-                metrics = state.step(steps);
-                inputMode = metrics.settled ? "idle" : "shot";
-                syncObjects();
-                publish();
-            }
-        },
-        dispose() {
-            canvas.removeEventListener("pointerdown", onPointerDown);
-            canvas.removeEventListener("pointermove", onPointerMove);
-            canvas.removeEventListener("pointerup", onPointerUp);
-            canvas.removeEventListener("pointercancel", onPointerUp);
-            if (ownerWindow) {
-                const target = ownerWindow;
-                if (target.__AURA3D_MINI_GOLF__?.kind === "aura-mini-golf-browser-runtime")
-                    delete target.__AURA3D_MINI_GOLF__;
-            }
-        }
-    };
-}
-function addThreeLights(THREE, threeScene, nodes) {
-    const lightNodes = nodes.filter((node) => node.kind === "light");
-    if (lightNodes.length === 0) {
-        const emissivePostScene = nodes.some((node) => node.kind === "effect" && node.effect === "bloom") &&
-            nodes.some((node) => node.kind === "primitive" && Boolean(node.material?.emissive));
-        if (emissivePostScene) {
-            threeScene.add(new THREE.HemisphereLight("#9fc7ff", "#020617", 0.18));
-            return;
-        }
-        threeScene.add(new THREE.HemisphereLight("#dfefff", "#071019", 1.35));
-        const key = new THREE.DirectionalLight("#ffffff", 2.4);
-        key.position.set(3.8, 5.6, 4.2);
-        key.castShadow = true;
-        configureThreeShadowLight(key);
-        threeScene.add(key);
-        return;
-    }
-    for (const node of lightNodes) {
-        const color = new THREE.Color(node.color ?? "#ffffff");
-        if (node.light === "ambient") {
-            threeScene.add(new THREE.HemisphereLight(color, new THREE.Color("#05070b"), Math.max(0.05, node.intensity * 1.8)));
-            continue;
-        }
-        if (node.light === "point") {
-            const light = new THREE.PointLight(color, Math.max(0.1, node.intensity * 26), 16, 1.65);
-            const position = node.position ?? [2, 2.5, 1.5];
-            light.position.set(position[0], position[1], position[2]);
-            light.castShadow = true;
-            configureThreeShadowLight(light);
-            threeScene.add(light);
-            continue;
-        }
-        if (node.light === "rect" || node.light === "softbox") {
-            const light = new THREE.RectAreaLight(color, Math.max(0.1, node.intensity * 6), node.width ?? 2, node.height ?? 1);
-            const position = node.position ?? [0, 2.4, 2.2];
-            light.position.set(position[0], position[1], position[2]);
-            light.lookAt(0, 0.55, 0);
-            threeScene.add(light);
-            continue;
-        }
-        if (node.light === "studio") {
-            threeScene.add(new THREE.HemisphereLight(color, new THREE.Color("#111827"), Math.max(0.05, node.intensity * 1.3)));
-            const key = new THREE.DirectionalLight(color, Math.max(0.1, node.intensity * 2.4));
-            const position = node.position ?? [3, 4, 3];
-            key.position.set(position[0], position[1], position[2]);
-            key.castShadow = true;
-            configureThreeShadowLight(key);
-            threeScene.add(key);
-            continue;
-        }
-        const light = new THREE.DirectionalLight(color, Math.max(0.1, node.intensity * 2.1));
-        const position = node.position ?? [3, 4, 3];
-        light.position.set(position[0], position[1], position[2]);
-        light.castShadow = true;
-        configureThreeShadowLight(light);
-        threeScene.add(light);
-    }
-}
-function configureThreeShadowLight(light) {
-    if (!light.shadow)
-        return;
-    light.shadow.mapSize.width = 1024;
-    light.shadow.mapSize.height = 1024;
-    if (light.shadow.camera) {
-        light.shadow.camera.near = 0.1;
-        light.shadow.camera.far = Math.max(light.shadow.camera.far ?? 24, 24);
-        if ("left" in light.shadow.camera) {
-            light.shadow.camera.left = -6;
-            light.shadow.camera.right = 6;
-            light.shadow.camera.top = 6;
-            light.shadow.camera.bottom = -6;
-        }
-    }
-}
-function createThreePrimitiveBatches(THREE, nodes) {
-    const groups = new Map();
-    for (const node of nodes) {
-        const key = primitiveBatchKey(node);
-        const existing = groups.get(key);
-        if (existing)
-            existing.push(node);
-        else
-            groups.set(key, [node]);
-    }
-    const meshes = [];
-    for (const group of groups.values()) {
-        const first = group[0];
-        if (!first)
-            continue;
-        if (group.length === 1) {
-            meshes.push(createThreePrimitive(THREE, first));
-            continue;
-        }
-        const geometry = createThreePrimitiveGeometry(THREE, first.primitive);
-        const materialValue = createThreeMaterial(THREE, first.material ?? material.pbr());
-        const mesh = new THREE.InstancedMesh(geometry, materialValue, group.length);
-        mesh.name = `aura-instanced-${first.primitive}-${group.length}`;
-        mesh.castShadow = first.castShadow ?? (first.primitive !== "plane" && !first.material?.emissive);
-        mesh.receiveShadow = first.receiveShadow ?? true;
-        const dummy = new THREE.Object3D();
-        group.forEach((node, index) => {
-            applyThreeTransform(dummy, node, primitiveSize(node));
-            dummy.updateMatrix();
-            mesh.setMatrixAt(index, dummy.matrix);
-        });
-        mesh.instanceMatrix.needsUpdate = true;
-        meshes.push(mesh);
-    }
-    return meshes;
-}
-function primitiveBatchKey(node) {
-    return JSON.stringify({
-        primitive: node.primitive,
-        material: node.material ?? material.pbr(),
-        castShadow: node.castShadow ?? (node.primitive !== "plane" && !node.material?.emissive),
-        receiveShadow: node.receiveShadow ?? true
-    });
-}
-function createThreePrimitiveGeometry(THREE, primitiveName) {
-    return primitiveName === "sphere"
-        ? new THREE.SphereGeometry(0.5, 24, 12)
-        : primitiveName === "capsule"
-            ? new THREE.CapsuleGeometry(0.32, 0.68, 8, 16)
-            : primitiveName === "torus"
-                ? new THREE.TorusGeometry(0.5, 0.035, 12, 64)
-                : primitiveName === "box"
-                    ? new THREE.BoxGeometry(1, 1, 1)
-                    : primitiveName === "cylinder"
-                        ? new THREE.CylinderGeometry(0.5, 0.5, 1, 24, 1)
-                        : new THREE.PlaneGeometry(1, 1, 1, 1).rotateX(-Math.PI / 2);
-}
-function createThreePrimitive(THREE, node) {
-    const geometry = createThreePrimitiveGeometry(THREE, node.primitive);
-    const materialValue = createThreeMaterial(THREE, node.material ?? material.pbr());
-    const mesh = new THREE.Mesh(geometry, materialValue);
-    mesh.castShadow = node.castShadow ?? (node.primitive !== "plane" && !node.material?.emissive);
-    mesh.receiveShadow = node.receiveShadow ?? true;
-    applyThreeTransform(mesh, node, primitiveSize(node));
-    return mesh;
-}
-function isThreeReadableTextLabel(node) {
-    return node.primitive === "plane" && node.name?.endsWith("readable planet label") === true;
-}
-function createThreeReadableTextLabel(THREE, node) {
-    const label = (node.name ?? "label").replace(/\s*readable planet label$/, "");
-    const color = String(node.material?.emissive ?? node.material?.color ?? "#ffffff");
-    const texture = createThreeTextTexture(THREE, label, color);
-    const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
-        map: texture,
-        transparent: true,
-        depthWrite: false,
-        depthTest: false
-    }));
-    const position = node.position ?? [0, 0.4, 0];
-    const scale = typeof node.scale === "number" ? [node.scale, node.scale, node.scale] : node.scale ?? [0.8, 1, 0.24];
-    sprite.name = node.name ?? label;
-    sprite.position.set(position[0], position[1], position[2]);
-    sprite.scale.set(scale[0], scale[2] * 1.35, 1);
-    return sprite;
-}
-function createThreeLabelNode(THREE, node) {
-    const color = String(node.color ?? "#e0f2fe");
-    const texture = createThreeTextTexture(THREE, node.text, color, String(node.background ?? "#020617"));
-    const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
-        map: texture,
-        transparent: true,
-        depthWrite: false,
-        depthTest: node.occlusionAware === true
-    }));
-    const position = node.position ?? labelDefaultPosition(node);
-    const size = Math.max(0.16, node.size ?? 0.36);
-    const width = Math.max(0.56, Math.min(2.8, node.text.length * size * 0.22));
-    sprite.name = node.name ?? `${node.label} label`;
-    sprite.position.set(position[0], position[1], position[2]);
-    sprite.scale.set(width, size * 0.62, 1);
-    return sprite;
-}
 function labelDefaultPosition(node) {
     if (node.screenAnchor === "top-right")
         return [1.35, 1.85, -0.2];
@@ -5547,485 +5617,6 @@ function labelDefaultPosition(node) {
         return [-1.35, 1.85, -0.2];
     return [0, 1.28, 0];
 }
-function createThreeTextTexture(THREE, text, color, background = "#020617") {
-    const canvas = document.createElement("canvas");
-    canvas.width = 512;
-    canvas.height = 160;
-    const context = canvas.getContext("2d");
-    if (context) {
-        context.clearRect(0, 0, canvas.width, canvas.height);
-        context.fillStyle = colorWithAlpha(background, 0.86);
-        context.fillRect(8, 18, canvas.width - 16, canvas.height - 36);
-        context.strokeStyle = color;
-        context.lineWidth = 8;
-        context.strokeRect(12, 22, canvas.width - 24, canvas.height - 44);
-        context.fillStyle = color;
-        context.font = "700 64px system-ui, -apple-system, BlinkMacSystemFont, sans-serif";
-        context.textAlign = "center";
-        context.textBaseline = "middle";
-        context.fillText(text, canvas.width / 2, canvas.height / 2 + 2);
-    }
-    const texture = new THREE.CanvasTexture(canvas);
-    texture.colorSpace = THREE.SRGBColorSpace;
-    texture.needsUpdate = true;
-    return texture;
-}
-async function createThreeMaterialInspectionEnvironment(THREE, renderer, snapshot) {
-    const environmentNode = snapshot.nodes.find((node) => node.kind === "environment");
-    const needsInspectionEnvironment = Boolean(environmentNode) || snapshot.nodes.some((node) => node.kind === "environment" ||
-        (node.kind === "primitive" && (node.name === "mirror chrome metal swatch" ||
-            node.name === "transparent cyan glass swatch" ||
-            node.name === "red automotive clearcoat swatch")));
-    if (!needsInspectionEnvironment)
-        return undefined;
-    try {
-        const generator = new THREE.PMREMGenerator(renderer);
-        const profile = resolveThreeEnvironmentProfile(environmentNode);
-        const environment = createThreeProceduralIblScene(THREE, profile);
-        const texture = generator.fromScene(environment, profile.blur).texture;
-        disposeThreeResource(environment);
-        return { texture, generator, intensity: profile.intensity, preset: profile.preset };
-    }
-    catch {
-        try {
-            const { RoomEnvironment } = await import("three/examples/jsm/environments/RoomEnvironment.js");
-            const generator = new THREE.PMREMGenerator(renderer);
-            const environment = new RoomEnvironment(renderer);
-            const texture = generator.fromScene(environment, 0.04).texture;
-            disposeThreeResource(environment);
-            return { texture, generator, intensity: environmentNode?.intensity ?? 1, preset: environmentNode?.environment ?? "room-fallback" };
-        }
-        catch {
-            return undefined;
-        }
-    }
-}
-function resolveThreeEnvironmentProfile(node) {
-    const preset = node?.environment ?? "studio";
-    const fallback = environmentMapPresets.find((entry) => entry.id === preset);
-    const intensity = node?.intensity ?? fallback?.intensity ?? 1;
-    const roomColor = node?.color ?? fallback?.color ?? "#eef4ff";
-    const profiles = {
-        studio: [
-            { name: "left broad studio softbox", color: "#ffffff", position: [-3.4, 2.2, 1.8], rotation: [0, Math.PI * 0.38, 0], scale: [2.5, 1.15, 1] },
-            { name: "right cool studio fill", color: "#cfe9ff", position: [3.2, 1.75, 1.2], rotation: [0, -Math.PI * 0.36, 0], scale: [1.8, 0.95, 1] },
-            { name: "low dark reflection card", color: "#111827", position: [0, 0.55, -2.8], rotation: [0, 0, 0], scale: [3.8, 0.65, 1] }
-        ],
-        "material-lab": [
-            { name: "white material strip reflection", color: "#ffffff", position: [0, 2.7, -2.9], rotation: [0, 0, 0], scale: [4.6, 0.42, 1] },
-            { name: "black material contrast card", color: "#030712", position: [0, 1.65, -3.0], rotation: [0, 0, 0], scale: [4.1, 0.34, 1] },
-            { name: "cool cyan material card", color: "#67e8f9", position: [-3.1, 1.65, -0.8], rotation: [0, Math.PI * 0.42, 0], scale: [0.68, 2.1, 1] },
-            { name: "warm gold material card", color: "#fbbf24", position: [3.1, 1.65, -0.8], rotation: [0, -Math.PI * 0.42, 0], scale: [0.68, 2.1, 1] }
-        ],
-        "product-hero": [
-            { name: "large product key softbox", color: "#ffffff", position: [-2.4, 2.8, 2.4], rotation: [-0.25, Math.PI * 0.3, 0], scale: [2.7, 1.45, 1] },
-            { name: "thin product rim strip", color: "#dbeafe", position: [2.8, 1.55, -1.9], rotation: [0, -Math.PI * 0.34, 0], scale: [0.55, 2.0, 1] },
-            { name: "product floor dark bounce", color: "#172033", position: [0, 0.32, 2.8], rotation: [0, Math.PI, 0], scale: [3.4, 0.5, 1] }
-        ],
-        "night-cinematic": [
-            { name: "cyan night tunnel reflection", color: "#22d3ee", position: [-3.2, 1.55, 0.2], rotation: [0, Math.PI * 0.42, 0], scale: [0.44, 2.4, 1] },
-            { name: "magenta night tunnel reflection", color: "#ff42c8", position: [3.2, 1.1, -0.6], rotation: [0, -Math.PI * 0.42, 0], scale: [0.44, 1.9, 1] },
-            { name: "dim blue vanishing reflection", color: "#1d4ed8", position: [0, 0.95, -3.0], rotation: [0, 0, 0], scale: [2.2, 0.75, 1] }
-        ],
-        "metal-studio": [
-            { name: "hard white metal reflection bar", color: "#ffffff", position: [0, 2.3, -2.9], rotation: [0, 0, 0], scale: [5.2, 0.28, 1] },
-            { name: "deep black metal reflection bar", color: "#020617", position: [0, 1.65, -3.0], rotation: [0, 0, 0], scale: [4.6, 0.22, 1] },
-            { name: "blue metal side card", color: "#93c5fd", position: [-3.25, 1.35, -0.4], rotation: [0, Math.PI * 0.43, 0], scale: [0.42, 2.2, 1] },
-            { name: "amber metal side card", color: "#f59e0b", position: [3.25, 1.35, -0.4], rotation: [0, -Math.PI * 0.43, 0], scale: [0.42, 2.2, 1] }
-        ],
-        "glass-studio": [
-            { name: "glass white caustic strip", color: "#ffffff", position: [-1.1, 2.35, -2.7], rotation: [0, 0.08, 0], scale: [2.5, 0.32, 1] },
-            { name: "glass cyan refraction panel", color: "#99f6e4", position: [2.9, 1.55, -0.6], rotation: [0, -Math.PI * 0.4, 0], scale: [0.56, 2.0, 1] },
-            { name: "glass dark edge card", color: "#06111c", position: [-2.8, 1.18, 0.2], rotation: [0, Math.PI * 0.4, 0], scale: [0.5, 1.6, 1] }
-        ]
-    };
-    return {
-        preset,
-        intensity,
-        blur: preset === "night-cinematic" ? 0.02 : 0.04,
-        roomColor,
-        panels: profiles[preset] ?? profiles.studio
-    };
-}
-function createThreeProceduralIblScene(THREE, profile) {
-    const environment = new THREE.Scene();
-    const room = new THREE.Mesh(new THREE.BoxGeometry(18, 18, 18), new THREE.MeshBasicMaterial({ color: new THREE.Color(profile.roomColor), side: THREE.BackSide }));
-    environment.add(room);
-    for (const panel of profile.panels) {
-        const mesh = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), new THREE.MeshBasicMaterial({ color: new THREE.Color(panel.color), side: THREE.DoubleSide }));
-        mesh.name = panel.name;
-        mesh.position.set(panel.position[0], panel.position[1], panel.position[2]);
-        mesh.rotation.set(panel.rotation[0], panel.rotation[1], panel.rotation[2]);
-        mesh.scale.set(panel.scale[0], panel.scale[1], panel.scale[2]);
-        environment.add(mesh);
-    }
-    return environment;
-}
-function createThreeMaterial(THREE, spec) {
-    if (spec.shader === "solar-sun")
-        return createThreeSolarSunMaterial(THREE, spec);
-    if (spec.shader === "solar-corona")
-        return createThreeSolarCoronaMaterial(THREE, spec);
-    const color = new THREE.Color(spec.color ?? "#d7dee8");
-    const metalness = spec.metalness ?? spec.metallic ?? 0;
-    const usePhysical = spec.transmission !== undefined ||
-        spec.clearcoat !== undefined ||
-        spec.sheen !== undefined ||
-        spec.iridescence !== undefined ||
-        spec.anisotropy !== undefined;
-    const transparent = spec.opacity !== undefined && spec.opacity < 1;
-    const materialValue = usePhysical
-        ? new THREE.MeshPhysicalMaterial({
-            color,
-            roughness: spec.roughness ?? 0.54,
-            metalness,
-            transparent,
-            opacity: spec.opacity ?? 1,
-            transmission: spec.transmission ?? 0,
-            clearcoat: spec.clearcoat ?? 0,
-            clearcoatRoughness: spec.clearcoatRoughness ?? 0.18,
-            thickness: spec.thickness ?? 0,
-            ior: spec.ior ?? 1.5,
-            attenuationColor: new THREE.Color(spec.attenuationColor ?? spec.color ?? "#ffffff"),
-            attenuationDistance: spec.attenuationDistance ?? Infinity,
-            envMapIntensity: spec.envMapIntensity ?? 1,
-            depthWrite: !transparent,
-            side: transparent ? THREE.DoubleSide : THREE.FrontSide
-        })
-        : new THREE.MeshStandardMaterial({
-            color,
-            roughness: spec.roughness ?? 0.54,
-            metalness,
-            transparent,
-            opacity: spec.opacity ?? 1,
-            envMapIntensity: spec.envMapIntensity ?? 1,
-            depthWrite: !transparent,
-            side: transparent ? THREE.DoubleSide : THREE.FrontSide
-        });
-    if (spec.emissive) {
-        materialValue.emissive = new THREE.Color(spec.emissive);
-        materialValue.emissiveIntensity = spec.emissiveIntensity ?? 1.55;
-    }
-    if ("sheen" in materialValue && spec.sheen !== undefined)
-        materialValue.sheen = clampMaterialScalar(spec.sheen, 0);
-    if ("sheenRoughness" in materialValue && spec.sheenRoughness !== undefined)
-        materialValue.sheenRoughness = clampMaterialScalar(spec.sheenRoughness, 0.5);
-    if ("sheenColor" in materialValue && spec.sheenColor)
-        materialValue.sheenColor = new THREE.Color(spec.sheenColor);
-    if ("iridescence" in materialValue && spec.iridescence !== undefined)
-        materialValue.iridescence = clampMaterialScalar(spec.iridescence, 0);
-    if ("iridescenceIOR" in materialValue && spec.iridescenceIOR !== undefined)
-        materialValue.iridescenceIOR = spec.iridescenceIOR;
-    if ("iridescenceThicknessRange" in materialValue && spec.iridescenceThicknessRange)
-        materialValue.iridescenceThicknessRange = spec.iridescenceThicknessRange;
-    if ("anisotropy" in materialValue && spec.anisotropy !== undefined)
-        materialValue.anisotropy = clampMaterialScalar(spec.anisotropy, 0, -1, 1);
-    if ("anisotropyRotation" in materialValue && spec.anisotropyRotation !== undefined)
-        materialValue.anisotropyRotation = spec.anisotropyRotation;
-    const normalMap = createThreeTextureFromMaterialInput(THREE, spec.normal, "normal");
-    if (normalMap) {
-        materialValue.normalMap = normalMap;
-        materialValue.normalScale = new THREE.Vector2(spec.normalScale ?? 1, spec.normalScale ?? 1);
-    }
-    const roughnessMap = createThreeTextureFromMaterialInput(THREE, spec.roughnessMap, "roughness");
-    if (roughnessMap)
-        materialValue.roughnessMap = roughnessMap;
-    const metalnessMap = createThreeTextureFromMaterialInput(THREE, spec.metalnessMap, "metalness");
-    if (metalnessMap)
-        materialValue.metalnessMap = metalnessMap;
-    materialValue.needsUpdate = true;
-    return materialValue;
-}
-function createThreeSolarSunMaterial(THREE, spec) {
-    const materialValue = new THREE.ShaderMaterial({
-        transparent: false,
-        depthWrite: true,
-        uniforms: {
-            uColor: { value: new THREE.Color(spec.color ?? "#ffd166") },
-            uCoreColor: { value: new THREE.Color(spec.coreColor ?? "#fff7ad") },
-            uRimColor: { value: new THREE.Color(spec.rimColor ?? "#f97316") },
-            uIntensity: { value: spec.emissiveIntensity ?? 2.45 },
-            uNoiseStrength: { value: spec.noiseStrength ?? 0.18 }
-        },
-        vertexShader: `
-      varying vec3 vNormalW;
-      varying vec3 vPositionW;
-      void main() {
-        vec4 worldPosition = modelMatrix * vec4(position, 1.0);
-        vPositionW = worldPosition.xyz;
-        vNormalW = normalize(mat3(modelMatrix) * normal);
-        gl_Position = projectionMatrix * viewMatrix * worldPosition;
-      }
-    `,
-        fragmentShader: `
-      uniform vec3 uColor;
-      uniform vec3 uCoreColor;
-      uniform vec3 uRimColor;
-      uniform float uIntensity;
-      uniform float uNoiseStrength;
-      varying vec3 vNormalW;
-      varying vec3 vPositionW;
-      float auraHash(vec3 p) {
-        return fract(sin(dot(p, vec3(17.17, 43.31, 91.73))) * 43758.5453);
-      }
-      void main() {
-        vec3 n = normalize(vNormalW);
-        vec3 viewDir = normalize(cameraPosition - vPositionW);
-        float facing = clamp(dot(n, viewDir), 0.0, 1.0);
-        float rim = pow(1.0 - facing, 2.1);
-        float grain = auraHash(n * 3.7) * 0.55 + auraHash(n * 9.3 + 4.2) * 0.45;
-        vec3 hotCore = mix(uColor, uCoreColor, smoothstep(0.16, 0.92, facing));
-        vec3 color = mix(hotCore, uRimColor, rim * 0.82);
-        color *= uIntensity * (0.88 + grain * uNoiseStrength);
-        gl_FragColor = vec4(color, 1.0);
-      }
-    `
-    });
-    return materialValue;
-}
-function createThreeSolarCoronaMaterial(THREE, spec) {
-    const materialValue = new THREE.ShaderMaterial({
-        transparent: true,
-        depthWrite: false,
-        blending: THREE.AdditiveBlending,
-        side: THREE.BackSide,
-        uniforms: {
-            uColor: { value: new THREE.Color(spec.color ?? "#ff9f1c") },
-            uCoreColor: { value: new THREE.Color(spec.coreColor ?? "#ffd166") },
-            uRimColor: { value: new THREE.Color(spec.rimColor ?? "#f97316") },
-            uOpacity: { value: spec.opacity ?? 0.34 },
-            uIntensity: { value: spec.emissiveIntensity ?? 1.55 },
-            uFalloff: { value: spec.falloff ?? 2.7 },
-            uNoiseStrength: { value: spec.noiseStrength ?? 0.14 }
-        },
-        vertexShader: `
-      varying vec3 vNormalW;
-      varying vec3 vPositionW;
-      void main() {
-        vec4 worldPosition = modelMatrix * vec4(position, 1.0);
-        vPositionW = worldPosition.xyz;
-        vNormalW = normalize(mat3(modelMatrix) * normal);
-        gl_Position = projectionMatrix * viewMatrix * worldPosition;
-      }
-    `,
-        fragmentShader: `
-      uniform vec3 uColor;
-      uniform vec3 uCoreColor;
-      uniform vec3 uRimColor;
-      uniform float uOpacity;
-      uniform float uIntensity;
-      uniform float uFalloff;
-      uniform float uNoiseStrength;
-      varying vec3 vNormalW;
-      varying vec3 vPositionW;
-      float auraHash(vec3 p) {
-        return fract(sin(dot(p, vec3(23.11, 59.37, 101.19))) * 24634.6345);
-      }
-      void main() {
-        vec3 n = normalize(vNormalW);
-        vec3 viewDir = normalize(cameraPosition - vPositionW);
-        float facing = clamp(dot(n, viewDir), 0.0, 1.0);
-        float rim = pow(1.0 - facing, uFalloff);
-        float grain = auraHash(n * 5.0) * 0.6 + auraHash(n * 13.0 + 1.7) * 0.4;
-        float alpha = clamp((rim * 0.9 + grain * uNoiseStrength) * uOpacity, 0.0, 0.62);
-        vec3 color = mix(uCoreColor, mix(uColor, uRimColor, rim), 0.78) * uIntensity;
-        gl_FragColor = vec4(color, alpha);
-      }
-    `
-    });
-    return materialValue;
-}
-function createThreeTextureFromMaterialInput(THREE, input, usage) {
-    if (!input || !("kind" in input) || input.kind !== "aura-procedural-texture")
-        return undefined;
-    return createThreeProceduralMaterialTexture(THREE, input, usage);
-}
-function createThreeProceduralMaterialTexture(THREE, spec, usage) {
-    if (typeof document === "undefined")
-        return undefined;
-    const canvas = document.createElement("canvas");
-    canvas.width = 128;
-    canvas.height = 128;
-    const context = canvas.getContext("2d");
-    if (!context)
-        return undefined;
-    const image = context.createImageData(canvas.width, canvas.height);
-    const scale = Math.max(1, spec.scale);
-    const strength = Math.max(0, spec.strength);
-    const contrast = spec.contrast ?? 0.5;
-    for (let y = 0; y < canvas.height; y += 1) {
-        for (let x = 0; x < canvas.width; x += 1) {
-            const index = (y * canvas.width + x) * 4;
-            const u = x / canvas.width;
-            const v = y / canvas.height;
-            const grain = proceduralTextureNoise(u, v, scale, spec.texture);
-            const stripe = Math.sin((spec.texture === "brushed-metal-anisotropy" ? u : v) * scale * Math.PI * 2) * 0.5 + 0.5;
-            const micro = Math.max(0, Math.min(1, grain * (1 - contrast) + stripe * contrast));
-            if (usage === "normal") {
-                const nx = Math.round(128 + (micro - 0.5) * 96 * strength);
-                const ny = Math.round(128 + (grain - 0.5) * 74 * strength);
-                image.data[index] = nx;
-                image.data[index + 1] = spec.texture === "brushed-metal-anisotropy" ? 128 : ny;
-                image.data[index + 2] = 255;
-                image.data[index + 3] = 255;
-            }
-            else {
-                const value = Math.round(255 * Math.max(0, Math.min(1, 0.28 + micro * 0.62 * strength)));
-                image.data[index] = value;
-                image.data[index + 1] = value;
-                image.data[index + 2] = value;
-                image.data[index + 3] = 255;
-            }
-        }
-    }
-    context.putImageData(image, 0, 0);
-    const texture = new THREE.CanvasTexture(canvas);
-    texture.wrapS = THREE.RepeatWrapping;
-    texture.wrapT = THREE.RepeatWrapping;
-    texture.repeat.set(1, 1);
-    texture.needsUpdate = true;
-    return texture;
-}
-function proceduralTextureNoise(u, v, scale, kind) {
-    const salt = kind === "fabric-normal"
-        ? 19.17
-        : kind === "rubber-roughness"
-            ? 37.41
-            : kind === "brushed-metal-anisotropy"
-                ? 53.29
-                : 71.83;
-    const a = Math.sin((u * scale + salt) * 12.9898 + (v * scale - salt) * 78.233) * 43758.5453;
-    const b = Math.sin((u * scale * 0.37 - salt) * 93.989 + (v * scale * 0.61 + salt) * 67.345) * 24634.6345;
-    const value = (a - Math.floor(a)) * 0.58 + (b - Math.floor(b)) * 0.42;
-    if (kind === "fabric-normal") {
-        const weave = (Math.sin(u * scale * Math.PI * 2) + Math.sin(v * scale * Math.PI * 2)) * 0.25 + 0.5;
-        return value * 0.44 + weave * 0.56;
-    }
-    if (kind === "brushed-metal-anisotropy") {
-        const brush = Math.sin(u * scale * Math.PI * 4) * 0.18 + 0.5;
-        return value * 0.25 + brush * 0.75;
-    }
-    return value;
-}
-function enhanceLoadedMaterial(materialValue) {
-    const materials = Array.isArray(materialValue) ? materialValue : [materialValue];
-    for (const entry of materials) {
-        if (!entry || typeof entry !== "object")
-            continue;
-        if ("roughness" in entry && typeof entry.roughness === "number")
-            entry.roughness = Math.min(entry.roughness, 0.82);
-        if ("metalness" in entry && typeof entry.metalness === "number")
-            entry.metalness = Math.max(entry.metalness, 0.02);
-        entry.needsUpdate = true;
-    }
-}
-function normalizeThreeModel(THREE, modelRoot, node) {
-    const box = new THREE.Box3().setFromObject(modelRoot);
-    const size = box.getSize(new THREE.Vector3());
-    const center = box.getCenter(new THREE.Vector3());
-    const fitScale = 1.55 / Math.max(0.001, size.x, size.y, size.z);
-    modelRoot.position.sub(new THREE.Vector3(center.x, box.min.y, center.z));
-    const pivot = new THREE.Group();
-    pivot.add(modelRoot);
-    applyThreeTransform(pivot, node, [fitScale, fitScale, fitScale]);
-    return pivot;
-}
-function registerThreeModelClipAnimation(THREE, gltf, modelRoot, node, frameUpdaters, disposables) {
-    const clips = Array.isArray(gltf.animations) ? gltf.animations : [];
-    if (clips.length === 0)
-        return;
-    const requestedClip = String(node.animation?.clip ?? "").toLowerCase();
-    const clip = clips.find((entry) => String(entry.name ?? "").toLowerCase() === requestedClip) ??
-        clips.find((entry) => requestedClip && String(entry.name ?? "").toLowerCase().includes(requestedClip)) ??
-        clips[0];
-    if (!clip)
-        return;
-    const mixer = new THREE.AnimationMixer(modelRoot);
-    const action = mixer.clipAction(clip);
-    action.reset();
-    action.enabled = true;
-    action.play();
-    const speed = Math.max(0.05, node.animation?.speed ?? 1);
-    frameUpdaters.push((time) => {
-        const seconds = node.animation ? resolveAnimationSeconds(node.animation, time) : time * 0.001;
-        const duration = Math.max(0.001, clip.duration ?? 1);
-        mixer.setTime((seconds * speed) % duration);
-    });
-    disposables.push({ dispose: () => mixer.uncacheRoot(modelRoot) });
-}
-function applyThreeTransform(object, node, baseScale) {
-    const position = node.position ?? [0, 0, 0];
-    const rotation = node.rotation ?? [0, 0, 0];
-    const scaleValue = typeof node.scale === "number"
-        ? [node.scale, node.scale, node.scale]
-        : node.scale ?? [1, 1, 1];
-    object.position.set(position[0], position[1], position[2]);
-    object.rotation.set(rotation[0], rotation[1], rotation[2]);
-    object.scale.set(baseScale[0] * scaleValue[0], baseScale[1] * scaleValue[1], baseScale[2] * scaleValue[2]);
-    if (node.lookAt)
-        object.lookAt(node.lookAt[0], node.lookAt[1], node.lookAt[2]);
-}
-function registerThreeNodeAnimation(object, node, frameUpdaters) {
-    if (!node.animation)
-        return;
-    const basePosition = node.position ?? [0, 0, 0];
-    const baseRotation = node.rotation ?? [0, 0, 0];
-    const baseScale = typeof object.scale?.clone === "function" ? object.scale.clone() : undefined;
-    const speed = Math.max(0.05, node.animation.speed ?? 1);
-    frameUpdaters.push((time) => {
-        const seconds = resolveAnimationSeconds(node.animation, time);
-        if (node.animation?.clip === "orbit") {
-            const position = orbitAnimatedPosition(node.animation, basePosition, seconds, speed);
-            object.position.x = position[0];
-            object.position.y = position[1];
-            object.position.z = position[2];
-            if (object.rotation)
-                object.rotation.y = baseRotation[1] + orbitAnimatedAngle(seconds, speed);
-            return;
-        }
-        if (node.animation?.clip === "bar-height-grow") {
-            const duration = Math.max(0.05, node.animation.duration ?? 1.1);
-            const linear = Math.min(1, seconds / duration);
-            const eased = node.animation.easing === "linear" ? linear : 0.5 - Math.cos(linear * Math.PI) * 0.5;
-            if (baseScale && object.scale) {
-                object.scale.x = baseScale.x;
-                object.scale.y = Math.max(baseScale.y * eased, baseScale.y * 0.06);
-                object.scale.z = baseScale.z;
-            }
-            object.position.y = basePosition[1] * eased;
-            return;
-        }
-        if (node.animation?.clip === "walk") {
-            const phase = seconds * speed * Math.PI * 2;
-            const travel = Math.sin(seconds * speed * 0.72) * 0.24;
-            const bodyBob = Math.abs(Math.sin(phase)) * 0.028;
-            object.position.x = basePosition[0] + travel;
-            object.position.y = basePosition[1] + bodyBob;
-            object.position.z = basePosition[2];
-            object.rotation.x = baseRotation[0];
-            object.rotation.y = baseRotation[1];
-            object.rotation.z = baseRotation[2];
-            return;
-        }
-        if (node.animation?.clip === "float") {
-            object.position.y = (node.position?.[1] ?? 0) + Math.sin(seconds * speed) * 0.08;
-            object.rotation.y = baseRotation[1] + seconds * speed * 0.28;
-            return;
-        }
-        if (node.animation?.clip === "turntable") {
-            object.position.y = basePosition[1];
-            object.rotation.y = baseRotation[1] + seconds * speed * 0.72;
-            return;
-        }
-        if (node.animation?.clip === "pulse") {
-            const pulse = 1 + Math.sin(seconds * speed * 2) * 0.08;
-            object.scale.multiplyScalar(pulse / (object.userData.lastAuraPulse ?? 1));
-            object.userData.lastAuraPulse = pulse;
-            return;
-        }
-        object.rotation.y = baseRotation[1] + seconds * speed;
-    });
-}
 function resolveAnimationSeconds(animation, time) {
     if (!animation)
         return time / 1000;
@@ -6058,602 +5649,6 @@ function orbitAnimatedPosition(animation, basePosition, seconds, speed) {
         center[2] + Math.sin(angle) * radius
     ];
 }
-function collectThreeEffectNodes(snapshot) {
-    return groups.flatten(snapshot.nodes).filter((node) => node.kind === "effect");
-}
-function hasThreePostProcessEffects(effectNodes) {
-    return effectNodes.some((node) => node.effect === "bloom" || node.effect === "ambient-occlusion" || node.effect === "contact-occlusion");
-}
-async function createThreePostProcessPipeline(THREE, renderer, threeScene, cameraObject, snapshot) {
-    try {
-        const [{ EffectComposer }, { RenderPass }] = await Promise.all([
-            import("three/examples/jsm/postprocessing/EffectComposer.js"),
-            import("three/examples/jsm/postprocessing/RenderPass.js")
-        ]);
-        const effectNodes = collectThreeEffectNodes(snapshot);
-        const bloomEffect = effectNodes.find((node) => node.effect === "bloom");
-        const occlusionEffect = effectNodes.find((node) => node.effect === "ambient-occlusion" || node.effect === "contact-occlusion");
-        const composer = new EffectComposer(renderer);
-        const renderPass = new RenderPass(threeScene, cameraObject);
-        const width = renderer.domElement.width || 1;
-        const height = renderer.domElement.height || 1;
-        let bloomPass;
-        let ssaoPass;
-        let outputPass;
-        let effectPasses = 0;
-        const passNames = ["render"];
-        const warnings = [];
-        composer.setSize(width, height);
-        if (typeof composer.setPixelRatio === "function") {
-            composer.setPixelRatio(Math.min(2, Math.max(1, window.devicePixelRatio || 1)));
-        }
-        composer.addPass(renderPass);
-        if (occlusionEffect) {
-            try {
-                const { SSAOPass } = await import("three/examples/jsm/postprocessing/SSAOPass.js");
-                ssaoPass = new SSAOPass(threeScene, cameraObject, width, height);
-                ssaoPass.kernelRadius = Math.max(4, Math.min(24, Math.round((occlusionEffect.radius ?? 0.64) * 24)));
-                ssaoPass.minDistance = 0.001;
-                ssaoPass.maxDistance = Math.max(0.04, Math.min(0.28, (occlusionEffect.radius ?? 0.64) * 0.22));
-                composer.addPass(ssaoPass);
-                effectPasses += 1;
-                passNames.push("ssao");
-            }
-            catch (error) {
-                warnings.push("SSAO pass unavailable; contact receiver shadows remain active");
-                console.warn("Aura3D SSAO pass unavailable; contact receiver shadows remain active", error);
-            }
-        }
-        if (bloomEffect) {
-            try {
-                const { UnrealBloomPass } = await import("three/examples/jsm/postprocessing/UnrealBloomPass.js");
-                bloomPass = new UnrealBloomPass(new THREE.Vector2(width, height), Math.max(0, Math.min(bloomEffect.maxIntensity ?? 0.92, bloomEffect.intensity ?? 0.35)), Math.max(0.05, Math.min(1.2, bloomEffect.radius ?? 0.38)), Math.max(0, Math.min(1, bloomEffect.threshold ?? 0.7)));
-                composer.addPass(bloomPass);
-                effectPasses += 1;
-                passNames.push("bloom");
-            }
-            catch (error) {
-                warnings.push("UnrealBloomPass unavailable; emissive sprite fallback may be used instead of true bloom");
-                console.warn("Aura3D bloom pass unavailable; using direct-render fallback", error);
-            }
-        }
-        if (effectPasses === 0) {
-            if (typeof renderPass.dispose === "function")
-                renderPass.dispose();
-            if (typeof composer.dispose === "function")
-                composer.dispose();
-            return null;
-        }
-        try {
-            const { OutputPass } = await import("three/examples/jsm/postprocessing/OutputPass.js");
-            outputPass = new OutputPass();
-            composer.addPass(outputPass);
-            passNames.push("output");
-        }
-        catch {
-            warnings.push("OutputPass unavailable; renderer tone mapping remains configured without an explicit output pass");
-            // Older Three.js builds may not ship OutputPass; renderer tone mapping remains configured.
-        }
-        return {
-            passNames,
-            warnings,
-            render: () => composer.render(),
-            setSize: (nextWidth, nextHeight) => {
-                composer.setSize(nextWidth, nextHeight);
-                if (typeof bloomPass?.setSize === "function")
-                    bloomPass.setSize(nextWidth, nextHeight);
-                if (typeof ssaoPass?.setSize === "function")
-                    ssaoPass.setSize(nextWidth, nextHeight);
-            },
-            dispose: () => {
-                if (typeof bloomPass?.dispose === "function")
-                    bloomPass.dispose();
-                if (typeof ssaoPass?.dispose === "function")
-                    ssaoPass.dispose();
-                if (typeof outputPass?.dispose === "function")
-                    outputPass.dispose();
-                if (typeof renderPass.dispose === "function")
-                    renderPass.dispose();
-                if (typeof composer.dispose === "function")
-                    composer.dispose();
-            }
-        };
-    }
-    catch (error) {
-        console.warn("Aura3D postprocess composer unavailable; falling back to direct render", error);
-        return null;
-    }
-}
-function createThreeContactShadowReceiver(THREE, snapshot, effect) {
-    const footprint = estimateSceneFootprint(snapshot.nodes);
-    const geometry = new THREE.PlaneGeometry(footprint.width, footprint.depth).rotateX(-Math.PI / 2);
-    const shadowMaterial = new THREE.ShadowMaterial({
-        color: new THREE.Color(effect.color ?? "#020617"),
-        opacity: Math.max(0.08, Math.min(0.42, effect.intensity ?? 0.28)),
-        transparent: true,
-        depthWrite: false
-    });
-    const receiver = new THREE.Mesh(geometry, shadowMaterial);
-    receiver.name = "aura-pixel-contact-shadow-receiver";
-    receiver.position.set(footprint.centerX, estimateSceneFloorTop(snapshot.nodes) + 0.006, footprint.centerZ);
-    receiver.receiveShadow = true;
-    receiver.castShadow = false;
-    return receiver;
-}
-function estimateSceneFloorTop(nodes) {
-    let top = 0;
-    for (const node of groups.flatten(nodes)) {
-        if (node.kind !== "primitive")
-            continue;
-        const name = (node.name ?? "").toLowerCase();
-        const isFloorLike = name.includes("floor") || name.includes("ground") || name.includes("stage") || name.includes("course") || name.includes("court");
-        if (!isFloorLike)
-            continue;
-        const y = node.position?.[1] ?? 0;
-        if (node.primitive === "box") {
-            const scale = scaleToVec3(node.scale);
-            top = Math.max(top, y + scale[1] * 0.5);
-            continue;
-        }
-        if (node.primitive === "plane") {
-            top = Math.max(top, y);
-        }
-    }
-    return top;
-}
-function estimateSceneFootprint(nodes) {
-    let minX = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minZ = Number.POSITIVE_INFINITY;
-    let maxZ = Number.NEGATIVE_INFINITY;
-    for (const node of groups.flatten(nodes)) {
-        if (node.kind !== "primitive" && node.kind !== "model")
-            continue;
-        const name = String(node.name ?? "").toLowerCase();
-        if (node.kind === "primitive" && node.primitive === "plane")
-            continue;
-        if (name.includes("sky") || name.includes("backdrop") || name.includes("wall") || name.includes("ground plane"))
-            continue;
-        const position = node.position ?? [0, 0, 0];
-        const scaleValue = typeof node.scale === "number"
-            ? [node.scale, node.scale, node.scale]
-            : node.scale ?? [1, 1, 1];
-        const baseSize = node.kind === "primitive" ? primitiveSize(node) : node.asset.bounds ?? [1, 1, 1];
-        const width = Math.max(0.08, Math.abs(baseSize[0] * scaleValue[0]));
-        const depth = Math.max(0.08, Math.abs(baseSize[2] * scaleValue[2]));
-        minX = Math.min(minX, position[0] - width * 0.55);
-        maxX = Math.max(maxX, position[0] + width * 0.55);
-        minZ = Math.min(minZ, position[2] - depth * 0.55);
-        maxZ = Math.max(maxZ, position[2] + depth * 0.55);
-    }
-    if (!Number.isFinite(minX) || !Number.isFinite(minZ)) {
-        return { centerX: 0, centerZ: 0, width: 4, depth: 3 };
-    }
-    const width = Math.max(2, Math.min(8, maxX - minX + 0.9));
-    const depth = Math.max(1.8, Math.min(7, maxZ - minZ + 0.9));
-    return { centerX: (minX + maxX) * 0.5, centerZ: (minZ + maxZ) * 0.5, width, depth };
-}
-function createThreeBloom(THREE, snapshot, effect) {
-    const group = new THREE.Group();
-    const intensity = Math.max(0.05, Math.min(1.4, effect.intensity ?? 0.35));
-    const texture = createThreeRadialTexture(THREE, effect.color ?? "#ffffff");
-    group.userData.texture = texture;
-    const anchors = collectBloomAnchors(snapshot);
-    anchors.forEach((anchor, index) => {
-        const materialValue = new THREE.SpriteMaterial({
-            map: texture,
-            color: new THREE.Color(anchor.color ?? effect.color ?? "#ffffff"),
-            transparent: true,
-            opacity: Math.min(0.46, 0.12 + intensity * anchor.opacity),
-            depthWrite: false,
-            depthTest: false,
-            blending: THREE.AdditiveBlending
-        });
-        const sprite = new THREE.Sprite(materialValue);
-        sprite.name = `aura-bloom-halo-${index}`;
-        sprite.position.set(anchor.position[0], anchor.position[1], anchor.position[2]);
-        sprite.scale.setScalar(anchor.size * (0.85 + intensity * 1.4));
-        group.add(sprite);
-    });
-    group.userData.update = (time) => {
-        const pulse = 1 + Math.sin(time * 0.0012) * 0.035 * intensity;
-        group.children.forEach((child, index) => {
-            const base = anchors[index]?.size ?? 1;
-            child.scale.setScalar(base * (0.85 + intensity * 1.4) * pulse);
-        });
-    };
-    return group;
-}
-function collectBloomAnchors(snapshot) {
-    const anchors = [];
-    for (const node of snapshot.nodes) {
-        if (node.kind === "primitive" && node.material?.emissive) {
-            const size = primitiveSize(node);
-            const scaleValue = typeof node.scale === "number" ? [node.scale, node.scale, node.scale] : node.scale ?? [1, 1, 1];
-            anchors.push({
-                position: node.position ?? [0, 0.65, -0.6],
-                size: Math.max(0.34, Math.max(size[0] * scaleValue[0], size[1] * scaleValue[1], size[2] * scaleValue[2]) * 1.45),
-                opacity: 0.24,
-                color: node.material.emissive
-            });
-        }
-        if (node.kind === "light" && node.light === "point") {
-            anchors.push({
-                position: node.position ?? [0, 1.4, 0.6],
-                size: Math.max(0.55, 0.28 + node.intensity * 0.32),
-                opacity: 0.18,
-                color: node.color
-            });
-        }
-    }
-    const modelNode = snapshot.nodes.find((node) => node.kind === "model");
-    if (modelNode) {
-        const position = modelNode.position ?? [0, 0.42, -0.65];
-        anchors.push({
-            position: [position[0], position[1] + 0.42, position[2] + 0.08],
-            size: 1.2,
-            opacity: 0.12
-        });
-    }
-    return anchors.length > 0 ? anchors.slice(0, 10) : [{ position: [0, 0.75, -0.75], size: 1.6, opacity: 0.16 }];
-}
-function createThreeRadialTexture(THREE, color) {
-    const canvas = document.createElement("canvas");
-    canvas.width = 128;
-    canvas.height = 128;
-    const context = canvas.getContext("2d");
-    if (context) {
-        const gradient = context.createRadialGradient(64, 64, 0, 64, 64, 64);
-        gradient.addColorStop(0, toAlphaColor(String(color), 0.95));
-        gradient.addColorStop(0.18, toAlphaColor(String(color), 0.42));
-        gradient.addColorStop(0.52, toAlphaColor(String(color), 0.14));
-        gradient.addColorStop(1, toAlphaColor(String(color), 0));
-        context.fillStyle = gradient;
-        context.fillRect(0, 0, canvas.width, canvas.height);
-    }
-    const texture = new THREE.CanvasTexture(canvas);
-    texture.colorSpace = THREE.SRGBColorSpace;
-    return texture;
-}
-function createThreeRain(THREE, effect) {
-    const group = new THREE.Group();
-    const density = Math.max(0.2, Math.min(1.6, effect.density ?? effect.intensity ?? 0.72));
-    const intensity = Math.max(0.1, Math.min(1.4, effect.intensity ?? 0.4));
-    const color = effect.color ?? "#c9e8ff";
-    const wind = effect.wind ?? [-0.32, -5.4, -0.16];
-    const requestedCount = effect.particleCount ?? Math.round(520 * density);
-    const dummy = new THREE.Object3D();
-    const layers = [];
-    const makeLayer = (name, count, zMin, zMax, length, width, opacity, speed) => {
-        const geometry = new THREE.PlaneGeometry(width, length);
-        const materialValue = new THREE.MeshBasicMaterial({
-            color: new THREE.Color(color),
-            transparent: true,
-            opacity,
-            depthWrite: false,
-            side: THREE.DoubleSide,
-            blending: THREE.AdditiveBlending
-        });
-        const mesh = new THREE.InstancedMesh(geometry, materialValue, count);
-        mesh.name = name;
-        mesh.userData.entries = [];
-        for (let index = 0; index < count; index += 1) {
-            const entry = {
-                x: seededRange(index, 11, -4.2, 4.2),
-                y: seededRange(index, 23, 0.22, 3.25),
-                z: seededRange(index, 37, zMin, zMax),
-                scale: seededRange(index, 41, 0.72, 1.32),
-                phase: seededRange(index, 53, 0, 1)
-            };
-            mesh.userData.entries.push(entry);
-            applyRainInstance(dummy, mesh, index, entry, 0, length, wind, speed);
-        }
-        mesh.instanceMatrix.needsUpdate = true;
-        layers.push({ mesh, length, speed });
-        group.add(mesh);
-    };
-    makeLayer("aura-rain-background-volume", Math.round(requestedCount * 0.42), -3.8, -1.1, 0.36, 0.018, Math.min(0.34, intensity * 0.36), 0.6);
-    makeLayer("aura-rain-midground-volume", Math.round(requestedCount * 0.36), -1.3, 0.9, 0.58, 0.026, Math.min(0.48, intensity * 0.54), 0.92);
-    makeLayer("aura-rain-foreground-streaks", Math.round(requestedCount * 0.22), 0.75, 2.35, 0.82, 0.034, Math.min(0.66, intensity * 0.72), 1.22);
-    const splashMaterial = new THREE.MeshBasicMaterial({
-        color: new THREE.Color(color),
-        transparent: true,
-        opacity: effect.splashes === false ? 0 : 0.48,
-        depthWrite: false,
-        side: THREE.DoubleSide,
-        blending: THREE.AdditiveBlending
-    });
-    const splashGeometry = new THREE.RingGeometry(0.028, 0.046, 20);
-    const splashCount = effect.splashes === false ? 0 : Math.round(64 * density);
-    const splashes = new THREE.InstancedMesh(splashGeometry, splashMaterial, splashCount);
-    splashes.name = "aura-rain-floor-splash-ripples";
-    splashes.userData.entries = [];
-    for (let index = 0; index < splashCount; index += 1) {
-        const entry = {
-            x: seededRange(index, 71, -3.2, 3.2),
-            z: seededRange(index, 89, -1.95, 1.5),
-            scale: seededRange(index, 97, 0.58, 1.65),
-            phase: seededRange(index, 109, 0, 1)
-        };
-        splashes.userData.entries.push(entry);
-        applySplashInstance(dummy, splashes, index, entry, 0);
-    }
-    splashes.instanceMatrix.needsUpdate = true;
-    group.add(splashes);
-    if (effect.mist !== false) {
-        const mistTexture = createThreeRadialTexture(THREE, color);
-        group.userData.mistTexture = mistTexture;
-        const mistMaterial = new THREE.SpriteMaterial({
-            map: mistTexture,
-            color: new THREE.Color(color),
-            transparent: true,
-            opacity: Math.min(0.18, 0.08 + intensity * 0.08),
-            depthWrite: false,
-            depthTest: false,
-            blending: THREE.AdditiveBlending
-        });
-        for (let index = 0; index < 5; index += 1) {
-            const sprite = new THREE.Sprite(mistMaterial.clone());
-            sprite.name = `aura-rain-mist-bank-${index}`;
-            sprite.position.set(-2.4 + index * 1.2, 0.32 + (index % 2) * 0.12, -1.5 + (index % 3) * 0.48);
-            sprite.scale.set(1.4 + index * 0.18, 0.42, 1);
-            group.add(sprite);
-        }
-    }
-    group.userData.update = (time) => {
-        const seconds = time / 1000;
-        for (const layer of layers) {
-            const entries = layer.mesh.userData.entries;
-            entries.forEach((entry, index) => {
-                applyRainInstance(dummy, layer.mesh, index, entry, seconds, layer.length, wind, layer.speed * (effect.speed ?? 1));
-            });
-            layer.mesh.instanceMatrix.needsUpdate = true;
-        }
-        const splashEntries = splashes.userData.entries;
-        splashEntries.forEach((entry, index) => applySplashInstance(dummy, splashes, index, entry, seconds));
-        splashes.instanceMatrix.needsUpdate = true;
-    };
-    return group;
-}
-function createThreeParticles(THREE, effect) {
-    const isFountain = effect.emitter === "fountain";
-    const requestedCount = effect.particleCount ?? 900;
-    const count = isFountain ? Math.max(24, Math.min(900, requestedCount)) : Math.max(120, Math.min(6000, requestedCount));
-    const radius = Math.max(0.1, effect.radius ?? 1.15);
-    const height = Math.max(0.2, effect.height ?? 2.4);
-    const intensity = Math.max(0.1, Math.min(1.8, effect.intensity ?? 0.8));
-    const materialMode = effect.materialMode ?? "soft-alpha";
-    const turbulence = Math.max(0, Math.min(1, effect.turbulence ?? effect.noise ?? 0));
-    const fountainLayer = !isFountain
-        ? "plume"
-        : effect.materialMode === "soft-alpha" || effect.name?.includes("mist")
-            ? "mist"
-            : effect.name?.includes("splash") || effect.name?.includes("collision")
-                ? "splash"
-                : "plume";
-    const texturedBillboard = effect.texturedBillboard !== false && !isFountain;
-    const multicolor = effect.name?.includes("multicolor") || effect.emitter === "swirl";
-    const lifetimeColor = isFountain || effect.name?.includes("lifetime");
-    const geometry = new THREE.BufferGeometry();
-    const positions = new Float32Array(count * 3);
-    const colors = new Float32Array(count * 3);
-    const baseColor = new THREE.Color(effect.color ?? "#7dfcff");
-    const accentColor = new THREE.Color(isFountain ? "#bae6fd" : "#ffd166");
-    const defaultLifetimeRamp = isFountain
-        ? ["#fff7ad", "#fef08a", "#fb923c", "#60a5fa", "#38bdf8", "#fb7185"]
-        : ["#fff7ad", "#ffd166", baseColor.getStyle(), "#ff7ad9", "#60a5fa"];
-    const lifetimeRampSource = effect.lifetimeColorRamp?.length ? effect.lifetimeColorRamp : defaultLifetimeRamp;
-    const lifetimeRamp = lifetimeRampSource.map((value) => new THREE.Color(value));
-    const scratchColor = new THREE.Color();
-    const sizeCurve = effect.sizeOverLife ?? [0.35, 1, 0.58];
-    const alphaCurve = effect.alphaOverLife ?? [0, 0.92, materialMode === "smoke" || materialMode === "dust" ? 0.18 : 0];
-    const writeColor = (index, seconds) => {
-        if (lifetimeColor) {
-            const life = getParticleLife(index, seconds, effect.emitter ?? "swirl");
-            const maxIndex = Math.max(0, lifetimeRamp.length - 1);
-            if (isFountain) {
-                const rampIndex = Math.min(maxIndex, (index + Math.floor(seededRange(index, 283, 0, 1) * lifetimeRamp.length)) % lifetimeRamp.length);
-                const nextIndex = Math.min(maxIndex, (rampIndex + 1) % lifetimeRamp.length);
-                scratchColor.copy(lifetimeRamp[rampIndex]).lerp(lifetimeRamp[nextIndex], seededRange(index, 307, 0, 0.16));
-            }
-            else {
-                const colorLife = isFountain
-                    ? seededRange(index, 283, 0, 0.92) * 0.82 + life * 0.18
-                    : life;
-                const scaledLife = Math.min(maxIndex, Math.max(0, colorLife * maxIndex));
-                const rampIndex = Math.min(maxIndex, Math.floor(scaledLife));
-                const nextIndex = Math.min(maxIndex, rampIndex + 1);
-                scratchColor.copy(lifetimeRamp[rampIndex]).lerp(lifetimeRamp[nextIndex], scaledLife - rampIndex);
-            }
-        }
-        else if (multicolor) {
-            scratchColor.setHSL(seededRange(index, 173, 0, 1), 0.84, 0.64);
-        }
-        else {
-            scratchColor.copy(baseColor).lerp(accentColor, seededRange(index, 173, 0, 0.42));
-        }
-        colors[index * 3] = scratchColor.r;
-        colors[index * 3 + 1] = scratchColor.g;
-        colors[index * 3 + 2] = scratchColor.b;
-    };
-    for (let index = 0; index < count; index += 1) {
-        writeParticlePosition(positions, index, 0, effect.emitter ?? "swirl", radius, height, index, turbulence, effect.gravity ?? 0, effect.groundCollision ?? false, fountainLayer);
-        writeColor(index, 0);
-    }
-    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
-    geometry.setAttribute("color", new THREE.BufferAttribute(colors, 3));
-    const spriteTexture = texturedBillboard ? createParticleSpriteTexture(THREE, materialMode) : undefined;
-    const baseSize = isFountain ? 0.07 + intensity * 0.032 : (multicolor ? 0.042 : 0.028) + intensity * (multicolor ? 0.024 : 0.018);
-    const opacity = isFountain
-        ? Math.min(0.94, Math.max(0.48, alphaCurve[1] ?? (0.58 + intensity * 0.24)))
-        : Math.min(0.98, Math.max(0.12, alphaCurve[1] ?? ((multicolor ? 0.62 : 0.48) + intensity * 0.22)));
-    const blending = isFountain || materialMode === "soft-alpha" || materialMode === "smoke" || materialMode === "dust" ? THREE.NormalBlending : THREE.AdditiveBlending;
-    if (spriteTexture) {
-        const plane = new THREE.PlaneGeometry(1, 1);
-        const materialValue = new THREE.MeshBasicMaterial({
-            map: spriteTexture,
-            vertexColors: true,
-            transparent: true,
-            opacity,
-            depthWrite: false,
-            alphaTest: 0.02,
-            blending,
-            side: THREE.DoubleSide
-        });
-        const mesh = new THREE.InstancedMesh(plane, materialValue, count);
-        const dummy = new THREE.Object3D();
-        const instanceColor = new THREE.Color();
-        const writeInstance = (index, seconds) => {
-            const offset = index * 3;
-            const life = getParticleLife(index, seconds, effect.emitter ?? "swirl");
-            const sizeLife = life < 0.5
-                ? (sizeCurve[0] ?? 0.35) + ((sizeCurve[1] ?? 1) - (sizeCurve[0] ?? 0.35)) * (life / 0.5)
-                : (sizeCurve[1] ?? 1) + ((sizeCurve[2] ?? 0.58) - (sizeCurve[1] ?? 1)) * ((life - 0.5) / 0.5);
-            const size = baseSize * 3.2 * Math.max(0.22, sizeLife);
-            dummy.position.set(positions[offset], positions[offset + 1], positions[offset + 2]);
-            dummy.rotation.set(0, 0, seededRange(index, 911, -Math.PI, Math.PI) + seconds * 0.18);
-            const elongatedWater = isFountain && materialMode !== "soft-alpha";
-            dummy.scale.set(size * (elongatedWater ? 1.05 : 1), size * (elongatedWater ? 1.18 : 1), size);
-            dummy.updateMatrix();
-            mesh.setMatrixAt(index, dummy.matrix);
-            instanceColor.setRGB(colors[offset], colors[offset + 1], colors[offset + 2]);
-            mesh.setColorAt(index, instanceColor);
-        };
-        for (let index = 0; index < count; index += 1)
-            writeInstance(index, 0);
-        mesh.name = effect.name ?? "aura-instanced-textured-particle-system";
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor)
-            mesh.instanceColor.needsUpdate = true;
-        mesh.userData.update = (time) => {
-            const seconds = time / 1000 * (effect.speed ?? 1);
-            for (let index = 0; index < count; index += 1) {
-                writeParticlePosition(positions, index, seconds, effect.emitter ?? "swirl", radius, height, index, turbulence, effect.gravity ?? 0, effect.groundCollision ?? false, fountainLayer);
-                if (lifetimeColor)
-                    writeColor(index, seconds);
-                writeInstance(index, seconds);
-            }
-            mesh.instanceMatrix.needsUpdate = true;
-            if (mesh.instanceColor)
-                mesh.instanceColor.needsUpdate = true;
-        };
-        return mesh;
-    }
-    if (isFountain && effect.texturedBillboard === false) {
-        const sphere = new THREE.IcosahedronGeometry(1, 1);
-        const sphereVertexColors = new Float32Array(sphere.getAttribute("position").count * 3);
-        sphereVertexColors.fill(1);
-        sphere.setAttribute("color", new THREE.BufferAttribute(sphereVertexColors, 3));
-        const materialValue = new THREE.MeshBasicMaterial({
-            color: "#ffffff",
-            vertexColors: true,
-            transparent: fountainLayer === "mist",
-            opacity: fountainLayer === "mist" ? 0.2 : 1,
-            depthWrite: fountainLayer !== "mist",
-            depthTest: true
-        });
-        materialValue.toneMapped = false;
-        const mesh = new THREE.InstancedMesh(sphere, materialValue, count);
-        mesh.frustumCulled = false;
-        const dummy = new THREE.Object3D();
-        const instanceColor = new THREE.Color();
-        const writeInstance = (index, seconds) => {
-            const offset = index * 3;
-            const life = getParticleLife(index, seconds, effect.emitter ?? "swirl");
-            const sizeLife = life < 0.5
-                ? (sizeCurve[0] ?? 0.35) + ((sizeCurve[1] ?? 1) - (sizeCurve[0] ?? 0.35)) * (life / 0.5)
-                : (sizeCurve[1] ?? 1) + ((sizeCurve[2] ?? 0.58) - (sizeCurve[1] ?? 1)) * ((life - 0.5) / 0.5);
-            const layerScale = fountainLayer === "mist" ? 0.22 : fountainLayer === "splash" ? 0.38 : 0.44;
-            const size = baseSize * layerScale * Math.max(0.24, sizeLife);
-            dummy.position.set(positions[offset], positions[offset + 1], positions[offset + 2]);
-            dummy.rotation.set(0, seededRange(index, 911, -Math.PI, Math.PI), seededRange(index, 917, -Math.PI, Math.PI));
-            dummy.scale.set(size, size, size);
-            dummy.updateMatrix();
-            mesh.setMatrixAt(index, dummy.matrix);
-            instanceColor.setRGB(colors[offset], colors[offset + 1], colors[offset + 2]);
-            mesh.setColorAt(index, instanceColor);
-        };
-        for (let index = 0; index < count; index += 1)
-            writeInstance(index, 0);
-        mesh.name = effect.name ?? "aura-instanced-fountain-particle-system";
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor)
-            mesh.instanceColor.needsUpdate = true;
-        mesh.userData.update = (time) => {
-            const seconds = time / 1000 * (effect.speed ?? 1);
-            for (let index = 0; index < count; index += 1) {
-                writeParticlePosition(positions, index, seconds, effect.emitter ?? "swirl", radius, height, index, turbulence, effect.gravity ?? 0, effect.groundCollision ?? false, fountainLayer);
-                if (lifetimeColor)
-                    writeColor(index, seconds);
-                writeInstance(index, seconds);
-            }
-            mesh.instanceMatrix.needsUpdate = true;
-            if (mesh.instanceColor)
-                mesh.instanceColor.needsUpdate = true;
-        };
-        return mesh;
-    }
-    const pointsTexture = isFountain ? createParticleSpriteTexture(THREE, materialMode) : undefined;
-    const materialValue = new THREE.PointsMaterial({
-        map: pointsTexture,
-        size: isFountain ? baseSize * (fountainLayer === "mist" ? 0.44 : fountainLayer === "splash" ? 0.82 : 1.08) * Math.max(0.52, sizeCurve[1] ?? 1) : baseSize * Math.max(0.25, sizeCurve[1] ?? 1),
-        vertexColors: true,
-        transparent: true,
-        opacity: isFountain ? Math.min(fountainLayer === "mist" ? 0.2 : fountainLayer === "splash" ? 0.78 : 0.9, opacity) : opacity,
-        depthWrite: false,
-        depthTest: true,
-        alphaTest: isFountain ? 0.035 : 0,
-        blending
-    });
-    const points = new THREE.Points(geometry, materialValue);
-    points.name = effect.name ?? "aura-particle-system";
-    points.userData.update = (time) => {
-        const seconds = time / 1000 * (effect.speed ?? 1);
-        const attribute = geometry.getAttribute("position");
-        const values = attribute.array;
-        const colorAttribute = geometry.getAttribute("color");
-        for (let index = 0; index < count; index += 1) {
-            writeParticlePosition(values, index, seconds, effect.emitter ?? "swirl", radius, height, index, turbulence, effect.gravity ?? 0, effect.groundCollision ?? false, fountainLayer);
-            if (lifetimeColor)
-                writeColor(index, seconds);
-        }
-        attribute.needsUpdate = true;
-        if (lifetimeColor)
-            colorAttribute.needsUpdate = true;
-    };
-    return points;
-}
-function createParticleSpriteTexture(THREE, mode) {
-    if (typeof document === "undefined")
-        return undefined;
-    const canvas = document.createElement("canvas");
-    canvas.width = 32;
-    canvas.height = 32;
-    const context = canvas.getContext("2d");
-    if (!context)
-        return undefined;
-    const gradient = context.createRadialGradient(16, 16, mode === "star" || mode === "spark" ? 1.5 : 0, 16, 16, 15.5);
-    const core = mode === "smoke" || mode === "dust" ? "rgba(220,230,240,0.68)" : "rgba(255,255,255,1)";
-    const mid = mode === "splash" ? "rgba(125,211,252,0.72)" : mode === "smoke" ? "rgba(148,163,184,0.32)" : "rgba(255,230,150,0.5)";
-    gradient.addColorStop(0, core);
-    gradient.addColorStop(0.42, mid);
-    gradient.addColorStop(1, "rgba(255,255,255,0)");
-    context.fillStyle = gradient;
-    context.fillRect(0, 0, 32, 32);
-    if (mode === "star" || mode === "spark") {
-        context.strokeStyle = "rgba(255,255,255,0.82)";
-        context.lineWidth = 1.2;
-        context.beginPath();
-        context.moveTo(16, 3);
-        context.lineTo(16, 29);
-        context.moveTo(3, 16);
-        context.lineTo(29, 16);
-        context.stroke();
-    }
-    const texture = new THREE.CanvasTexture(canvas);
-    texture.needsUpdate = true;
-    return texture;
-}
 function getParticleLife(seedIndex, seconds, emitter) {
     if (emitter !== "fountain")
         return (seededRange(seedIndex, 181, 0, 1) + seconds * 0.18) % 1;
@@ -6714,23 +5709,6 @@ function writeParticlePosition(positions, index, seconds, emitter, radius, heigh
     positions[index * 3 + 1] = y;
     positions[index * 3 + 2] = z;
 }
-function applyRainInstance(dummy, mesh, index, entry, seconds, length, wind, speed) {
-    const fall = ((seconds * speed + entry.phase) % 1) * 3.6;
-    const y = 3.15 - ((3.15 - entry.y + fall) % 3.4);
-    dummy.position.set(entry.x + wind[0] * fall * 0.06, y, entry.z + wind[2] * fall * 0.08);
-    dummy.rotation.set(0, 0, -0.17 + wind[0] * 0.055);
-    dummy.scale.set(entry.scale, entry.scale, entry.scale);
-    dummy.updateMatrix();
-    mesh.setMatrixAt(index, dummy.matrix);
-}
-function applySplashInstance(dummy, mesh, index, entry, seconds) {
-    const ripple = 0.35 + (((seconds * 1.8 + entry.phase) % 1) * 1.25);
-    dummy.position.set(entry.x, 0.022, entry.z);
-    dummy.rotation.set(-Math.PI / 2, 0, seededRange(index, 131, 0, Math.PI));
-    dummy.scale.set(entry.scale * ripple, entry.scale * ripple, entry.scale * ripple);
-    dummy.updateMatrix();
-    mesh.setMatrixAt(index, dummy.matrix);
-}
 function seededRange(index, salt, min, max) {
     const value = Math.sin((index + 1) * 12.9898 + salt * 78.233) * 43758.5453;
     const normalized = value - Math.floor(value);
@@ -6775,32 +5753,11 @@ function resolveCameraEye(snapshot, cameraSpec, time) {
     }
     return eye;
 }
-function updateThreeCamera(THREE, cameraObject, snapshot, canvas, time) {
-    const cameraSpec = snapshot.camera;
-    const target = resolveCameraTarget(snapshot, cameraSpec);
-    const eye = resolveCameraEye(snapshot, cameraSpec, time);
-    cameraObject.aspect = canvas.width / Math.max(1, canvas.height);
-    cameraObject.fov = cameraSpec.fov ?? 45;
-    cameraObject.position.set(eye[0], eye[1], eye[2]);
-    cameraObject.lookAt(new THREE.Vector3(target[0], target[1], target[2]));
-    cameraObject.updateProjectionMatrix();
-}
-function disposeThreeResource(item) {
-    if (!item)
-        return;
-    if (Array.isArray(item)) {
-        for (const entry of item)
-            disposeThreeResource(entry);
-        return;
-    }
-    if (typeof item.traverse === "function") {
-        item.traverse((child) => {
-            disposeThreeResource(child.geometry);
-            disposeThreeResource(child.material);
-        });
-    }
-    if (typeof item.dispose === "function")
-        item.dispose();
+function collectRuntimeEffectNodes(snapshot) {
+    return groups.flatten(snapshot.nodes).filter((node) => node.kind === "effect");
+}
+function hasRuntimePostProcessEffects(effectNodes) {
+    return effectNodes.some((node) => node.effect === "bloom" || node.effect === "ambient-occlusion" || node.effect === "contact-occlusion");
 }
 async function createWebGLSceneRenderer(canvas, snapshot) {
     const gl = canvas.getContext("webgl2", { antialias: true, preserveDrawingBuffer: true });
@@ -6824,10 +5781,10 @@ async function createWebGLSceneRenderer(canvas, snapshot) {
     const background = colorToClearColor(snapshot.background);
     gl.enable(gl.DEPTH_TEST);
     gl.disable(gl.CULL_FACE);
-    const requestedEffectNodes = collectThreeEffectNodes(snapshot);
+    const requestedEffectNodes = collectRuntimeEffectNodes(snapshot);
     const runtimeRendererDiagnostics = createRendererDiagnosticReport(snapshot, {
         mounted: true,
-        backend: "webgl2-fallback",
+        backend: "webgl2-agent-runtime",
         postprocess: {
             renderPass: false,
             outputPass: false,
@@ -6836,9 +5793,9 @@ async function createWebGLSceneRenderer(canvas, snapshot) {
             contactOcclusionReceiver: false,
             pixelBacked: false,
             actualPasses: [],
-            fallbackPasses: hasThreePostProcessEffects(requestedEffectNodes) ? ["minimal-webgl-direct-render"] : []
+            fallbackPasses: hasRuntimePostProcessEffects(requestedEffectNodes) ? ["webgl2-direct-render"] : []
         },
-        warnings: ["Minimal WebGL fallback does not run the Three.js composer, PMREM environment, shadow maps, or GLB animation mixers."]
+        warnings: ["Aura3D WebGL2 agent runtime renders typed models, primitives, and basic effects; advanced postprocess, environment prefiltering, shadow maps, and GLB animation mixers are reported as unsupported until the production renderer adapter covers them."]
     });
     return {
         diagnostics: runtimeRendererDiagnostics,
@@ -7956,7 +6913,7 @@ function normalizeSceneSnapshot(value) {
 }
 function resolveCanvas(target) {
     if (!target) {
-        throw new AuraRuntimeError("missing-canvas", "Aura3D could not mount because the app target was null or undefined. Suggested fix: pass a selector like createAuraApp(\"#app\", ...) or check document.querySelector before mounting.");
+        return undefined;
     }
     if (typeof target === "string") {
         if (typeof document === "undefined") {