@aura3d/engine 2.0.4 → 3.0.1

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

@@ -1,3 +1,4 @@
+import { applyRootParticleQuality, composeModelInstanceMatrices, createCameraProjection, DeferredFrameResources, getRootPerformanceBaseSize, getRootPerformanceQuality, getRootRenderSource, hasRootRenderableContent, includeRootSourceMetadata, initializeRootPerformanceQuality, readRootDiagnosticSnapshot, resolveCameraClipping, resolveRootRenderTime, setRootPerformanceQuality, supportsRootParticleQuality, validateRootPerformanceQuality } from "./RootRuntimeSupport.js";
 /*
  * WS-2.2 — module-scope physics values come from the SOLVERLESS entry.
  *
@@ -22,10 +23,11 @@ import { PhysicsDebugDraw, PhysicsStepper, ScenePhysicsBridge, Shape as PhysicsS
  * of which arrived just to reach one class.
  */
 import { PhysicsWorld } from "../../physics/world.js";
-import { createExternalParityEnvironmentLighting, Geometry, IndexBuffer, InstancedPBRMaterial, PBRMaterial, ProductionRuntimeRenderer, srgbToLinearChannel, VertexBuffer, VertexFormat } from "../../rendering/index.js";
+import { createBeamDescriptor, createDayNightSky, createDualProbeEnvironmentLightingResources, createExternalParityEnvironmentLighting, createProductionEnvironmentLightingResources, createProductionPbrHdrPipelineFromRadiance, createSdfFontAtlas, createSdfTextQuadMesh, createSpotShadowProjection, createWaterSurface, createWeatherState, describeSdfTextPixelBacking, describeWetMaterial, layoutSdfText, rasterizeSdfTextLabelImage, resolveFlipbookUv, resolveSdfTextFrameOpacity, resolveVolumetricFog, selectSpotShadowAtlasTier, sampleOceanFixture, Geometry, IndexBuffer, InstancedPBRMaterial, PBRMaterial, ProductionRuntimeRenderer, resolveSamplerAnisotropy, Sampler, srgbToLinearChannel, Texture, TexturedPBRMaterial, VertexBuffer, VertexFormat } from "../../rendering/index.js";
 import { DirectionalLight, PointLight, SpotLight } from "../../scene/index.js";
-import { lookAtMat4, multiplyMat4, orthographicMat4, perspectiveMat4 } from "../../scene/MathTypes.js";
+import { identityMat4, lookAtMat4, multiplyMat4 } from "../../scene/MathTypes.js";
 import { AURA_NORMALIZED_MODEL_MAX_DIMENSION, boundsFromAsset, boundsHeight, boundsMaxDimension, boundsSize } from "./SceneGroundingUtils.js";
+import { collectLabelTelemetry, labelTelemetryRoleFor, summarizeTextBuckets } from "./LabelTelemetry.js";
 import { createWorldLabelLayer } from "./WorldLabelRenderer.js";
 import { createAuraText3DGeometry, defineAuraCustomGeometry, selectAuraRootLodLevel } from "./RootGeometry.js";
 export * from "./RootGeometry.js";
@@ -49,8 +51,18 @@ export * from "./PhysicsRuntime.js";
  */
 export { buildMeshBVH, createMeshSurfaceQuery, raycastMesh } from "../../physics/solverless.js";
 import { createPhysicsRuntime } from "./PhysicsRuntime.js";
+import { gameCameraRigs } from "./GameCameraRigs.js";
+import { gameFeelBuilders } from "./GameFeel.js";
 export * from "./FocusSelection.js";
 export * from "./WorldLabelRenderer.js";
+export * from "./GameCameraRigs.js";
+export * from "./GameFeel.js";
+export * from "./LabelTelemetry.js";
+export * from "./NavigationCrowds.js";
+export * from "./FootPlanting.js";
+export * from "./Decals.js";
+export * from "./Scatter.js";
+export * from "./AssetDecoders.js";
 export * from "./VehicleChassis.js";
 export * from "./VehicleDriverAi.js";
 /**
@@ -83,7 +95,16 @@ export * from "./WebCodecsFrameEncoder.js";
  */
 export { GameInspector, createGameInspector } from "./GameInspector.js";
 import { createGameInspector } from "./GameInspector.js";
+import { createPhysicalMaterialSpec } from "../material-physical/PhysicalMaterialSpec.js";
+import { createInstancedModelNode } from "../instances-model/InstancedModel.js";
+import { resolveWrinkleMapStrength, warnOnInstancingFallback } from "../../rendering/index.js";
 export { createGameAudio } from "../game/GameAudio.js";
+export { PositionalEmitter, FootstepPlayer, createGameMixer, attachFocusPolicy, computeDistanceAttenuation, computeDopplerShift, resolveOcclusion } from "../../audio/index.js";
+export { ComboDetector, createTouchLayoutPreset, probeHaptics, playHaptic } from "../../input/index.js";
+export { attachVisualScriptingGraph, createVisualScriptingGraph, listVisualScriptingNodeCatalog } from "../../scripting/index.js";
+export { createRootEditorSurface } from "../../editor-runtime/index.js";
+import { attachVisualScriptingGraph as attachVisualScriptingGraphFn, createVisualScriptingGraph as createVisualScriptingGraphFn, listVisualScriptingNodeCatalog as listVisualScriptingNodeCatalogFn } from "../../scripting/index.js";
+import { createRootEditorSurface as createRootEditorSurfaceFn } from "../../editor-runtime/index.js";
 export * from "./RenderProgressTracker.js";
 export * from "./AudioVisemeAnalyzer.js";
 export * from "./ExternalPhonemeAnalyzer.js";
@@ -114,6 +135,7 @@ export * from "./EpisodeTemplates.js";
 export * from "./AnimationMotionQuality.js";
 export * from "./AnimationRouteProof.js";
 export * from "./AnimationEpisodePackage.js";
+import { evaluateDistancePrioritizedMipResidency } from "../../assets/browser-index.js";
 import { createFrameLoop } from "./FrameLoop.js";
 import { createCombatWorld, createGameCameraDirector, createGameEffects, applyGameCombatEventsToRuntime, createGameAccessibilityFocus, createGameAccessibilityLabel, createGameAccessibilityRuntimeSettings, createGameEventLog, createGameHighContrastSource, createGameHudBindings, createGameHudComboBinding, createGameHudCheckpointBinding, createGameHudDebugToggleBinding, createGameHudEventLogBinding, createGameHudHealthBinding, createGameHudLivesBinding, createGameHudMeterBinding, createGameHudObjectiveBinding, createGameHudRoundBinding, createGameHudScoreBinding, createGameHudSnapshot, createGameHudTimerBinding, createGameHudValueBinding, createGameBoxCollider, createGameCapsuleCollider, createGameColliderDebugGeometry, createGameCombatDebugGeometry, createGameCollisionWorld, createGamePlanarCollisionWorld, createGameDebugOverlayData, createGameDebugSceneNodes, createGameHitboxDebugGeometry, createGameSimulation, exportGameInputReplay, createGameFighting2DRules, createGameInput, createGameInputReplay, createGameInputReplayDriver, importGameInputReplay, createGameJumpAssist, createGameKinematicBody, createGamePauseControlsSource, createGameRectCollider, createGameReducedFlashSource, createGameReducedMotionSource, createGameSphereCollider, createGameTouchControlLayout, gameColliderAabb, gameColliders, gameEffectPresets, gameGuardboxes, gameHitboxes, gameHurtboxes, gameInputReplayEventsAt, gamePushboxes, runGameSimulation, gameTriggerVolumes } from "./GameRuntime.js";
 import { collectGameRuntimeEvidence as collectGameRuntimeEvidenceV105 } from "./GameEvidence.js";
@@ -153,6 +175,8 @@ export * from "./GameAssetValidation.js";
 export * from "./CharacterAssembly.js";
 export * from "./AssetEvidence.js";
 export * from "./AnimationController.js";
+export * from "./AnimationMixerBuilders.js";
+export * from "./AnimationDebugOverlay.js";
 export { gameAssetValidation, quaterniusGameReadyFighterValidationContract, validateQuaterniusGameReadyFighterAsset } from "./GameAssetValidation.js";
 export { createAnimationController } from "./AnimationController.js";
 export * from "./PromptAnimationContract.js";
@@ -244,7 +268,8 @@ export function model(asset, options = {}) {
         targetMaxDimension: options.targetMaxDimension,
         targetLength: options.targetLength,
         physics: options.physics,
-        hiddenNodeNames: options.hiddenNodeNames
+        hiddenNodeNames: options.hiddenNodeNames,
+        wrinkle: options.wrinkle
     });
 }
 export function unsafeModelUrl(url, options = {}) {
@@ -337,15 +362,102 @@ export const instances = {
     cylinder: (options) => instancedPrimitive("cylinder", options),
     capsule: (options) => instancedPrimitive("capsule", options),
     torus: (options) => instancedPrimitive("torus", options),
-    custom: (spec, options) => instancedPrimitive("custom", { ...options, geometry: defineAuraCustomGeometry(spec) })
+    custom: (spec, options) => instancedPrimitive("custom", { ...options, geometry: defineAuraCustomGeometry(spec) }),
+    /**
+     * P2 instanced GLB models (muse3jsparity-PRD): one draw class for repeated
+     * static models. Skinned actors fall back with a D1 warning at mount (E1
+     * owns rigs); explicitly unaware materials warn at build.
+     */
+    model: (asset, options) => {
+        const built = createInstancedModelNode({
+            asset,
+            ...(options.name !== undefined ? { name: options.name } : {}),
+            transforms: options.transforms.map((transform) => ({
+                ...(transform.position !== undefined ? { position: [...transform.position] } : {}),
+                ...(transform.rotation !== undefined ? { rotation: [...transform.rotation] } : {}),
+                ...(transform.scale !== undefined
+                    ? { scale: typeof transform.scale === "number" ? transform.scale : [...transform.scale] }
+                    : {})
+            })),
+            ...(options.colors ? { colors: [...options.colors] } : {}),
+            ...(options.lod ? { lod: options.lod } : {}),
+            materialInstancingAware: options.instancingAware ?? true,
+            ...(options.maxInstancesPerDraw !== undefined ? { maxInstancesPerDraw: options.maxInstancesPerDraw } : {}),
+            ...(options.material?.name !== undefined ? { materialName: options.material.name } : {})
+        });
+        const base = model(asset, options).toJSON();
+        return new AuraNodeBuilder({
+            ...base,
+            instances: built.node.instances.map((transform) => ({
+                ...(transform.position ? { position: [...transform.position] } : {}),
+                ...(transform.rotation ? { rotation: [...transform.rotation] } : {}),
+                ...(transform.scale !== undefined ? { scale: transform.scale } : {})
+            })),
+            // Safe: the builder only accepts AuraColor strings above, so no RGB tuples reach the node.
+            ...(built.node.instanceColors ? { instanceColors: [...built.node.instanceColors] } : {}),
+            ...(built.node.instanceLod ? { instanceLod: built.node.instanceLod } : {}),
+            instanceCulling: {
+                instanceCount: built.node.instanceCulling.instanceCount,
+                centroid: [...built.node.instanceCulling.centroid],
+                boundingRadius: built.node.instanceCulling.boundingRadius,
+                cullable: true
+            },
+            ...(built.diagnostics.fallbackWarning ? { instancedModelWarning: built.diagnostics.fallbackWarning.diagnostic } : {})
+        });
+    }
+};
+export const visualScripting = {
+    graph: createVisualScriptingGraphFn,
+    attach: attachVisualScriptingGraphFn,
+    catalog: listVisualScriptingNodeCatalogFn
+};
+const rootEditorSurface = createRootEditorSurfaceFn();
+export const editor = {
+    undo: rootEditorSurface.undo,
+    redo: rootEditorSurface.redo,
+    gizmo: rootEditorSurface.attachGizmo,
+    playMode: { enter: rootEditorSurface.enterPlayMode, exit: rootEditorSurface.exitPlayMode },
+    outliner: rootEditorSurface.describeOutliner,
+    capabilityLabel: "editor"
 };
 export const geometry = {
     define: defineAuraCustomGeometry,
     custom: (spec, options = {}) => primitive("custom", { ...options, geometry: defineAuraCustomGeometry(spec) })
 };
+let cachedSdfFontAtlas;
+function rootSdfFontAtlas() {
+    // Baked once per session (~500ms default res); the caller never bakes per frame.
+    cachedSdfFontAtlas ??= createSdfFontAtlas();
+    return cachedSdfFontAtlas;
+}
 export function text3D(text, options = {}) {
     const built = createAuraText3DGeometry(text, options);
-    return primitive("custom", { ...options, geometry: built.geometry, text3D: { text: built.text, glyphCount: built.glyphCount, unsupportedCharacters: built.unsupportedCharacters, method: built.method } });
+    if ((options.backend ?? "extruded-mesh") === "extruded-mesh") {
+        return primitive("custom", { ...options, geometry: built.geometry, text3D: { text: built.text, glyphCount: built.glyphCount, unsupportedCharacters: built.unsupportedCharacters, method: built.method } });
+    }
+    // G1 SDF backend (muse3jsparity-PRD): the layout validates fail-loud and is
+    // recorded on the descriptor with the full author intent (size, spacing,
+    // style, occlusion policy) so the production bridge can replay the sampler
+    // at mount. The extruded mesh stays as the diagnosed fallback geometry.
+    const layout = layoutSdfText(text, rootSdfFontAtlas(), { size: options.size ?? 1, letterSpacing: options.letterSpacing, style: options.sdfStyle });
+    return primitive("custom", {
+        ...options,
+        geometry: built.geometry,
+        text3D: {
+            text: built.text,
+            glyphCount: built.glyphCount,
+            unsupportedCharacters: [...new Set([...built.unsupportedCharacters, ...layout.unsupportedCharacters])],
+            method: "sdf-atlas-quad",
+            backend: "sdf",
+            sdfQuadCount: layout.quads.length,
+            sdfWidthWorld: layout.widthWorld,
+            sdfHeightWorld: layout.heightWorld,
+            sdfSize: options.size ?? 1,
+            ...(options.letterSpacing === undefined ? {} : { sdfLetterSpacing: options.letterSpacing }),
+            ...(options.sdfStyle === undefined ? {} : { sdfStyle: options.sdfStyle }),
+            sdfOcclusion: options.sdfOcclusion ?? "dim"
+        }
+    });
 }
 export function distanceLod(options) {
     if (options.levels.length === 0)
@@ -397,6 +509,13 @@ function proceduralTexture(texture, options = {}) {
         colorB: options.colorB
     };
 }
+const PHYSICAL_SPEC_KEYS = [
+    "color", "roughness", "metallic", "metalness", "clearcoat", "clearcoatRoughness",
+    "sheen", "sheenColor", "sheenRoughness", "iridescence", "iridescenceIOR",
+    "iridescenceThicknessRange", "anisotropy", "anisotropyRotation", "transmission",
+    "thickness", "attenuationColor", "attenuationDistance", "ior", "specularIntensity",
+    "specularColor"
+];
 export const material = {
     pbr: (options = {}) => ({
         color: "#d7dee8",
@@ -405,7 +524,29 @@ export const material = {
         metalness: options.metalness ?? options.metallic ?? 0,
         ...options
     }),
-    physical: (options = {}) => material.pbr(options),
+    physical: (options = {}) => {
+        // P3 (muse3jsparity-PRD): the sync factory stays scalar (C1 decision —
+        // no renderer change); extension params validate through the physical
+        // matrix and every non-supported request rides the spec as a warning.
+        const defined = PHYSICAL_SPEC_KEYS.reduce((picked, key) => {
+            const value = options[key];
+            if (value !== undefined)
+                picked[key] = value;
+            return picked;
+        }, {});
+        const result = createPhysicalMaterialSpec(defined);
+        const normalized = PHYSICAL_SPEC_KEYS.reduce((picked, key) => {
+            const value = result.spec[key];
+            if (value !== undefined && options[key] !== undefined)
+                picked[key] = value;
+            return picked;
+        }, {});
+        return {
+            ...material.pbr(options),
+            ...normalized,
+            ...(result.boundedWarnings.length > 0 ? { physicalWarnings: [...result.boundedWarnings] } : {})
+        };
+    },
     emissive: (options = {}) => ({
         color: options.color ?? "#111827",
         emissive: options.emissive ?? options.color ?? "#38d6ff",
@@ -699,33 +840,41 @@ const materialCapabilityCatalog = [
     {
         id: "base-color-texture",
         label: "Base-color texture",
-        rootSafeApi: "partial",
+        rootSafeApi: "supported",
         productionRuntime: "supported",
-        evidence: "Imported GLB baseColorTexture is sampled by the root WebGL path, but the root material contract currently keeps texture support partial until controlled texture on/off pixels are retained.",
+        evidence: "Root textured-PBR upgrade resolves AuraAssetRef texture urls to sRGB baseColor textures with controlled texture on/off pixel deltas (tests/browser/root-textured-c1.spec.ts, tests/reports/root-textured-c1/c1-probe.json).",
         claimRule: "Can describe typed texture metadata and rendered textured assets; do not claim full texture-material parity without controlled root pixels."
     },
     {
         id: "metallic-roughness",
         label: "Metallic/roughness",
-        rootSafeApi: "partial",
+        rootSafeApi: "supported",
         productionRuntime: "supported",
-        evidence: "Root material specs expose values, but production-style material response needs route-specific pixel proof.",
+        evidence: "Root textured-PBR upgrade composites roughnessMap/metalnessMap to the glTF metallic-roughness convention with scalar fallbacks and controlled browser pixel proof (tests/browser/root-textured-c1.spec.ts).",
         claimRule: "Do not claim full PBR parity without browser evidence."
     },
     {
         id: "normal-map",
         label: "Normal maps",
-        rootSafeApi: "partial",
+        rootSafeApi: "supported",
         productionRuntime: "supported",
-        evidence: "Root specs carry normal/procedural-normal intent; production shader parity is not guaranteed.",
+        evidence: "Root textured-PBR upgrade binds linear normal maps with tangent-space sampling over authored TBN and controlled browser pixel proof (tests/browser/root-textured-c1.spec.ts).",
+        claimRule: "Claim only with material-specific screenshot evidence."
+    },
+    {
+        id: "occlusion-map",
+        label: "Occlusion maps",
+        rootSafeApi: "supported",
+        productionRuntime: "supported",
+        evidence: "Root textured-PBR upgrade binds linear occlusionMap textures (R channel) with occlusionStrength and controlled browser pixel proof (tests/browser/root-textured-c1.spec.ts).",
         claimRule: "Claim only with material-specific screenshot evidence."
     },
     {
         id: "emissive",
         label: "Emissive",
-        rootSafeApi: "partial",
+        rootSafeApi: "supported",
         productionRuntime: "supported",
-        evidence: "Root specs and effects expose emissive color; pixel-backed bloom is reported separately.",
+        evidence: "Root textured-PBR upgrade binds sRGB emissiveMap textures multiplied by the emissive factor with controlled browser pixel proof (tests/browser/root-textured-c1.spec.ts); pixel-backed bloom is reported separately.",
         claimRule: "Distinguish emissive material from postprocess bloom."
     },
     {
@@ -779,9 +928,9 @@ const materialCapabilityCatalog = [
     {
         id: "hdr-ibl",
         label: "HDR/IBL",
-        rootSafeApi: "partial",
+        rootSafeApi: "supported",
         productionRuntime: "supported",
-        evidence: "Root environment nodes request lighting intent; environment prefiltering is not proven in the root path.",
+        evidence: "Root environments.hdri resolves authored Radiance HDR through the HDR-to-cubemap-to-GGX-to-BRDF-LUT chain with iblPixelBacked diagnostics and controlled browser pixel deltas (tests/browser/root-ibl-b3.spec.ts, tests/reports/root-ibl-b3/b3-probe.json).",
         claimRule: "Root HDR/IBL claims require diagnostics and browser pixels."
     },
     {
@@ -805,7 +954,9 @@ function createMaterialCapabilityDiagnostics(input) {
             requested.add("metallic-roughness");
         if (spec.normal)
             requested.add("normal-map");
-        if (spec.emissive || spec.emissiveIntensity !== undefined)
+        if (spec.occlusionMap || spec.occlusionStrength !== undefined)
+            requested.add("occlusion-map");
+        if (spec.emissive || spec.emissiveIntensity !== undefined || spec.emissiveMap)
             requested.add("emissive");
         if (spec.opacity !== undefined && spec.opacity < 1)
             requested.add("alpha");
@@ -829,6 +980,11 @@ function createMaterialCapabilityDiagnostics(input) {
     if (partialRequestedFeatures.length > 0) {
         warnings.push(`Partial root material features requested: ${partialRequestedFeatures.join(", ")}. Capture route pixels before claiming production material quality.`);
     }
+    for (const spec of specs) {
+        for (const physicalWarning of spec.physicalWarnings ?? []) {
+            warnings.push(`Physical material extension bounded: ${physicalWarning}`);
+        }
+    }
     if (unsupportedRequestedFeatures.length > 0) {
         warnings.push(`Metadata/internal material features requested: ${unsupportedRequestedFeatures.join(", ")}. Do not claim rendered support from root createAuraApp alone.`);
     }
@@ -1038,7 +1194,8 @@ export const lights = {
         name: options.name,
         position: options.position ?? [3, 4, 3],
         intensity: options.intensity ?? 1.5,
-        color: options.color ?? "#ffffff"
+        color: options.color ?? "#ffffff",
+        shadow: options.shadow
     }),
     point: (options = {}) => new AuraNodeBuilder({
         kind: "light",
@@ -1048,6 +1205,20 @@ export const lights = {
         intensity: options.intensity ?? 2,
         color: options.color ?? "#ffffff"
     }),
+    spot: (options = {}) => new AuraNodeBuilder({
+        kind: "light",
+        light: "spot",
+        name: options.name ?? "spot light",
+        position: options.position ?? [0, 4, 0],
+        target: options.target,
+        angle: options.angle ?? Math.PI / 6,
+        penumbra: options.penumbra ?? 0.4,
+        distance: options.distance ?? 12,
+        decay: options.decay,
+        intensity: options.intensity ?? 8,
+        color: options.color ?? "#ffffff",
+        shadow: options.shadow
+    }),
     studio: (options = {}) => new AuraNodeBuilder({
         kind: "light",
         light: "studio",
@@ -1100,6 +1271,7 @@ export const lights = {
 export const camera = {
     perspective: (options = {}) => ({
         mode: "perspective",
+        ...resolveCameraClipping(options),
         position: options.position ?? [0, 1.4, 4],
         target: options.target ?? [0, 0.8, 0],
         fov: options.fov ?? 45
@@ -1109,6 +1281,7 @@ export const camera = {
         const target = options.target ?? [0, 0.8, 0];
         return {
             mode: "orbit",
+            ...resolveCameraClipping(options),
             distance,
             target,
             position: options.position ?? [
@@ -1121,6 +1294,7 @@ export const camera = {
     },
     dolly: (options) => ({
         mode: "dolly",
+        ...resolveCameraClipping(options),
         from: options.from,
         to: options.to,
         target: options.target ?? [0, 0.8, 0],
@@ -1130,6 +1304,7 @@ export const camera = {
     }),
     follow: (options) => ({
         mode: "follow",
+        ...resolveCameraClipping(options),
         targetNode: options.targetNode,
         distance: options.distance ?? 5,
         position: options.position,
@@ -1145,6 +1320,7 @@ export const camera = {
     }),
     path: (options) => ({
         mode: "path",
+        ...resolveCameraClipping(options),
         from: options.from,
         to: options.to,
         target: options.target ?? [0, 0.8, 0],
@@ -1155,6 +1331,7 @@ export const camera = {
     }),
     flythrough: (options = {}) => ({
         mode: "flythrough",
+        ...resolveCameraClipping(options),
         from: options.from ?? [0, 0.36, 1.6],
         to: options.to ?? [0, 0.36, -4.4],
         target: options.target ?? [0, 0.28, -5.8],
@@ -1175,6 +1352,7 @@ export const camera = {
      */
     orthographic: (options = {}) => ({
         mode: "orthographic",
+        ...resolveCameraClipping(options),
         position: options.position ?? [0, 1.4, 4],
         target: options.target ?? [0, 0.8, 0],
         orthographicSize: options.orthographicSize ?? 1.4
@@ -1197,6 +1375,7 @@ export const camera = {
         const horizontal = Math.cos(elevation) * distance;
         return {
             mode: "isometric",
+            ...resolveCameraClipping(options),
             target,
             distance,
             orthographicSize: options.orthographicSize ?? 6,
@@ -1257,8 +1436,10 @@ export const camera = {
     solar: () => camera.orbit({ target: [0, 0, 0], distance: 7.2, fov: 46 }),
     humanoid: () => camera.perspective({ position: [1.2, 1.12, 3.45], target: [0, 0.78, -0.55], fov: 36 }),
     miniGolf: () => camera.follow({ targetNode: "white physics golf ball", distance: 4.2, fov: 48 }),
-    neon: () => camera.flythrough({ from: [0, 0.36, 1.6], to: [0, 0.36, -5.8], target: [0, 0.26, -6.8], fov: 54, captureTime: 0.16 })
+    neon: () => camera.flythrough({ from: [0, 0.36, 1.6], to: [0, 0.36, -5.8], target: [0, 0.26, -6.8], fov: 54, captureTime: 0.16 }),
+    ...gameCameraRigs
 };
+export const gameFeel = { create: gameFeelBuilders.create, hitStopDefaults: gameFeelBuilders.hitStopDefaults };
 function resolveFrameAssetRenderScale(bounds, options) {
     const size = boundsSize(bounds);
     const height = Math.max(0.001, boundsHeight(bounds));
@@ -1314,7 +1495,10 @@ export const effects = {
             radius: options.radius ?? 0.38,
             threshold: options.threshold ?? 0.7,
             antiBlowout,
-            maxIntensity
+            maxIntensity,
+            ...(options.quality !== undefined ? { quality: options.quality } : {}),
+            ...(options.softKnee !== undefined ? { softKnee: options.softKnee } : {}),
+            ...(options.shoulder !== undefined ? { shoulder: options.shoulder } : {})
         });
     },
     cinematicBloom: (options = {}) => effects.bloom({
@@ -1323,7 +1507,10 @@ export const effects = {
         radius: options.radius ?? 0.42,
         threshold: options.threshold ?? 0.72,
         antiBlowout: options.antiBlowout ?? true,
-        maxIntensity: options.maxIntensity ?? 0.92
+        maxIntensity: options.maxIntensity ?? 0.92,
+        ...(options.quality !== undefined ? { quality: options.quality } : {}),
+        ...(options.softKnee !== undefined ? { softKnee: options.softKnee } : {}),
+        ...(options.shoulder !== undefined ? { shoulder: options.shoulder } : {})
     }),
     neonBloom: (options = {}) => effects.bloom({
         intensity: options.intensity ?? 0.72,
@@ -1331,12 +1518,27 @@ export const effects = {
         radius: options.radius ?? 0.48,
         threshold: options.threshold ?? 0.68,
         antiBlowout: options.antiBlowout ?? true,
-        maxIntensity: options.maxIntensity ?? 0.92
+        maxIntensity: options.maxIntensity ?? 0.92,
+        ...(options.quality !== undefined ? { quality: options.quality } : {}),
+        ...(options.softKnee !== undefined ? { softKnee: options.softKnee } : {}),
+        ...(options.shoulder !== undefined ? { shoulder: options.shoulder } : {})
     }),
-    volumetricFog: (options = {}) => effects.fog({
+    /**
+     * A5 volumetric fog (muse3jsparity-PRD): builds a DISTINCT "volumetric-fog"
+     * node (never plain fog) that submits the depth-aware inscatter pass plus
+     * forward GPU height-fog terms. quality "off" keeps forward exp2 fog only.
+     */
+    volumetricFog: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "volumetric-fog",
+        name: options.name ?? "volumetric fog inscatter",
         density: options.density ?? 0.18,
         color: options.color ?? "#6f84b9",
-        intensity: options.intensity ?? 0.7
+        intensity: options.intensity ?? 0.7,
+        ...(options.volumetricQuality ? { volumetricQuality: options.volumetricQuality } : {}),
+        ...(options.lightPosition ? { lightPosition: options.lightPosition } : {}),
+        ...(options.heightFalloff !== undefined ? { heightFalloff: options.heightFalloff } : {}),
+        ...(options.heightReference !== undefined ? { heightReference: options.heightReference } : {})
     }),
     depthFog: (options = {}) => effects.fog({
         density: options.density ?? 0.14,
@@ -1361,6 +1563,82 @@ export const effects = {
         density: options.density ?? 0.7,
         color: options.color ?? "#020617"
     }),
+    /**
+     * Root color-grade node (muse3jsparity-PRD A3). contrast/saturation execute
+     * natively; exposure/shadows/highlights/lut are recorded on the node and
+     * warned (no native grade target yet — never silently accepted).
+     */
+    colorGrade: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "color-grade",
+        name: options.name ?? "color grade",
+        intensity: options.intensity ?? 1,
+        exposure: options.exposure ?? 1,
+        contrast: options.contrast ?? 1,
+        saturation: options.saturation ?? 1,
+        ...(options.shadows !== undefined ? { shadows: options.shadows } : {}),
+        ...(options.highlights !== undefined ? { highlights: options.highlights } : {}),
+        ...(options.lut !== undefined ? { lut: options.lut } : {})
+    }),
+    /**
+     * Root anti-alias node (muse3jsparity-PRD A3). `fxaa` executes natively;
+     * `off` submits nothing; `taa` uses renderer-owned velocity/history for opaque
+     * rigid triangles. Unsupported deforming/transparent geometry emits a named warning.
+     */
+    antiAlias: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "anti-alias",
+        name: options.name ?? "anti alias",
+        mode: options.mode ?? "fxaa",
+        intensity: options.intensity ?? 1
+    }),
+    /**
+     * Root outline node (muse3jsparity-PRD A3): native outline pass, width in
+     * pixels clamped to the device range 1-6 by the bridge.
+     */
+    outline: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "outline",
+        name: options.name ?? "outline",
+        color: options.color ?? "#ff9822",
+        width: options.width ?? 3,
+        threshold: options.threshold ?? 0.12,
+        intensity: options.intensity ?? 0.9
+    }),
+    /**
+     * Root screen-space reflections node (muse3jsparity-PRD A3): submits the
+     * native SSR pass against renderer-owned depth where available.
+     */
+    screenSpaceReflections: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "screen-space-reflections",
+        name: options.name ?? "screen space reflections",
+        intensity: options.intensity ?? 0.9
+    }),
+    /**
+     * Root depth-of-field node (muse3jsparity-PRD A3). focus is a
+     * linear-distance fraction (0 = near plane, 1 = far plane); aperture widens
+     * the focus transition band (game-tuned control, not a physical f-stop).
+     */
+    depthOfField: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "depth-of-field",
+        name: options.name ?? "depth of field",
+        focus: options.focus ?? 0.02,
+        aperture: options.aperture ?? 0.35,
+        maxBlur: options.maxBlur ?? 4,
+        intensity: options.intensity ?? 1
+    }),
+    /**
+     * Root motion-blur node: renderer-owned GPU velocity for opaque rigid geometry.
+     * Unsupported deforming/transparent/instanced geometry emits a named warning.
+     */
+    motionBlur: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "motion-blur",
+        name: options.name ?? "motion blur",
+        intensity: options.intensity ?? 0.5
+    }),
     rain: (options = {}) => new AuraNodeBuilder({
         kind: "effect",
         effect: "rain",
@@ -1373,6 +1651,62 @@ export const effects = {
         splashes: options.splashes ?? true,
         mist: options.mist ?? true
     }),
+    snow: (options = {}) => new AuraNodeBuilder({
+        kind: "effect",
+        effect: "snow",
+        intensity: options.intensity ?? 0.4,
+        density: options.density ?? 0.68,
+        color: options.color ?? "#e8f1ff",
+        speed: options.speed ?? 1,
+        wind: options.wind ?? [-0.85, -1.1, -0.22],
+        particleCount: options.particleCount,
+        splashes: options.splashes ?? false,
+        mist: options.mist ?? true
+    }),
+    /**
+     * Flipbook explosion/muzzle-flash sprite sheet (muse3jsparity-PRD D4):
+     * recorded with validated sheet geometry, but withheld — root has no
+     * native sprite-sheet sampler yet, so no pass is submitted.
+     */
+    flipbook: (options = {}) => {
+        const columns = options.spriteColumns ?? 4;
+        const rows = options.spriteRows ?? 4;
+        resolveFlipbookUv(0, columns, rows);
+        return new AuraNodeBuilder({
+            kind: "effect",
+            effect: "flipbook-sprite",
+            name: options.name ?? "flipbook explosion sprite",
+            intensity: options.intensity ?? 1,
+            color: options.color ?? "#ffb347",
+            spriteColumns: columns,
+            spriteRows: rows,
+            frameRate: options.frameRate ?? 24
+        });
+    },
+    /**
+     * Additive thick light beam / fence strip (muse3jsparity-PRD D4): recorded
+     * with a validated quad-strip descriptor, but withheld — root has no native
+     * beam target yet, so no pass is submitted.
+     */
+    beam: (options = {}) => {
+        const descriptor = createBeamDescriptor({
+            from: options.from ?? [0, 1, 0],
+            to: options.to ?? [0, 1, -4],
+            ...(options.widthWorld !== undefined ? { widthWorld: options.widthWorld } : {}),
+            ...(options.segmentCount !== undefined ? { segmentCount: options.segmentCount } : {})
+        });
+        return new AuraNodeBuilder({
+            kind: "effect",
+            effect: "light-beam",
+            name: options.name ?? "additive light beam",
+            intensity: options.intensity ?? 0.9,
+            color: options.color ?? "#9fd8ff",
+            from: [...descriptor.from],
+            to: [...descriptor.to],
+            widthWorld: descriptor.widthWorld,
+            segmentCount: descriptor.segmentCount
+        });
+    },
     particles: (options = {}) => new AuraNodeBuilder({
         kind: "effect",
         effect: "particles",
@@ -1398,6 +1732,161 @@ export const effects = {
         noise: options.noise ?? 0.22
     })
 };
+/**
+ * D3 atmosphere builders (PRD D3 boxes 1-2). ADDITIVE root surface over the
+ * pure descriptors in `@aura3d/rendering` (`DayNightSky.ts`,
+ * `AtmosphereWetness.ts`, `Weather.ts`).
+ *
+ * Every builder below composes pre-existing node kinds only (primitive,
+ * light, effect); no existing builder is modified. Precipitation pixels in
+ * the default production path come from weather-state-driven primitive
+ * streaks/flakes, because the production bridge does not pixel-back `rain`,
+ * `snow`, or `particles` effect passes (they render only in the safe-basic
+ * fallback and the Canvas2D diagnostic path). The matching effect node is
+ * still declared so diagnostics report the request.
+ */
+export const sky = {
+    /** Time-of-day sky: background key, sun/moon discs, stars, 2D-noise clouds, key light. */
+    dayNight: (options = {}) => {
+        const state = createDayNightSky(options);
+        const nodes = [];
+        const sunUp = state.sun.elevationRadians > -0.05;
+        const moonUp = state.moon.elevationRadians > -0.05;
+        if (sunUp) {
+            nodes.push(primitives.sphere({ name: "d3 sun disc", material: material.emissive({ color: state.sun.color, emissive: state.sun.color, emissiveIntensity: 2.2, roughness: 0.8 }) })
+                .position(-6 * Math.cos(state.sun.azimuthRadians), 1 + 5 * Math.sin(state.sun.azimuthRadians), -7).scale(0.85).toJSON());
+        }
+        if (moonUp) {
+            nodes.push(primitives.sphere({ name: "d3 moon disc", material: material.emissive({ color: state.moon.color, emissive: state.moon.color, emissiveIntensity: 1.4, roughness: 0.8 }) })
+                .position(-6 * Math.cos(state.moon.azimuthRadians), 1 + 5 * Math.sin(state.moon.azimuthRadians), -7).scale(0.6).toJSON());
+        }
+        const starLimit = Math.max(0, Math.min(120, options.starLimit ?? 48));
+        const visibleStars = state.stars.filter((star) => star.brightness > 0.05 && star.y > 0).slice(0, starLimit);
+        for (const [index, star] of visibleStars.entries()) {
+            nodes.push(primitives.sphere({ name: `d3 night star ${index}`, material: material.emissive({ color: "#dbeafe", emissive: "#bfdbfe", emissiveIntensity: 1.8, roughness: 0.9 }) })
+                .position(star.x * 7, star.y * 4 + 0.6, -6.5).scale(0.028 + star.size * 2).toJSON());
+        }
+        const cloudLimit = Math.max(0, Math.min(48, options.cloudLimit ?? 12));
+        const cloudTint = state.dayFactor > 0.5 ? "#f1f5f9" : state.dayFactor > 0.2 ? "#b6a6a6" : "#1e293b";
+        for (const [index, cell] of state.clouds.slice(0, cloudLimit).entries()) {
+            nodes.push(primitives.sphere({ name: `d3 noise cloud ${index}`, material: material.pbr({ color: cloudTint, roughness: 1, metallic: 0 }) })
+                .position(cell.x * 6, cell.y * 3 + 1.4, -5.5).scale([cell.radius * 1.7, cell.radius * 0.5, cell.radius * 0.8]).toJSON());
+        }
+        nodes.push(lights.directional({
+            name: sunUp ? "d3 sun key light" : "d3 moon key light",
+            position: sunUp ? [-4, 5, 2] : [3, 4, -1],
+            color: sunUp ? state.sun.color : state.moon.color,
+            intensity: sunUp ? 0.6 + state.dayFactor * 1.2 : 0.35
+        }).toJSON());
+        return { nodes, background: state.dayFactor > 0.5 ? state.horizonColor : state.nightFactor > 0.6 ? "#020617" : state.horizonColor, dayFactor: state.dayFactor, visibleStarCount: visibleStars.length };
+    }
+};
+export const weather = {
+    /** Rain/snow declaration + weather-state-driven primitive streaks/flakes for production-path pixels. */
+    precipitation: (options) => {
+        const state = createWeatherState({
+            type: options.type,
+            seed: options.seed ?? 0xd3e7,
+            elapsedSeconds: options.elapsedSeconds ?? 1.2,
+            maxVisualDrops: 400
+        });
+        const snowing = options.type === "snow";
+        const intensity = snowing ? Math.max(0.2, state.snowIntensity) : Math.max(0.2, state.rainIntensity);
+        const nodes = [
+            (snowing ? effects.snow({ intensity, color: "#e8f1ff" }) : effects.rain({ intensity, color: "#bcd7ff" })).toJSON()
+        ];
+        const limit = Math.max(0, Math.min(160, options.streakLimit ?? (snowing ? 70 : 90)));
+        const drops = state.visualDrops.slice(0, limit);
+        drops.forEach((drop, index) => {
+            const x = Math.max(-3.4, Math.min(3.4, drop.x * 2.4));
+            const y = Math.max(0.15, Math.min(3.4, drop.y + 1.6));
+            const z = Math.max(-4.5, Math.min(2.5, drop.z * 2.4));
+            if (snowing) {
+                nodes.push(primitives.sphere({ name: `d3 snow flake ${index}`, material: material.pbr({ color: "#eef4ff", roughness: 0.85, metallic: 0 }) })
+                    .position(x, y, z).scale(0.035).toJSON());
+            }
+            else {
+                nodes.push(primitives.box({ name: `d3 rain streak ${index}`, material: material.pbr({ color: "#bcd7ff", roughness: 0.35, metallic: 0 }) })
+                    .position(x, y, z).scale([0.014, Math.max(0.08, drop.length * 2.4), 0.014]).toJSON());
+            }
+        });
+        return { nodes, dropCount: drops.length, wetness: state.wetness };
+    },
+    /** Ground slab with wetness darkening + puddle discs mapped from WeatherPuddlePatch. */
+    wetGround: (options = {}) => {
+        const probe = describeWetMaterial({
+            type: options.type ?? "rain",
+            dryColor: options.dryColor ?? "#5b6b4f",
+            dryRoughness: options.dryRoughness ?? 0.9,
+            seed: options.seed ?? 0xd3e7
+        });
+        const size = Math.max(2, Math.min(14, options.size ?? 8));
+        const nodes = [
+            primitives.box({ name: "d3 weather ground slab", material: material.pbr({ color: probe.response.albedoColor, roughness: probe.response.roughness, metallic: 0 }) })
+                .position(0, -0.02, 0).scale([size, 0.04, size]).toJSON()
+        ];
+        probe.weather.puddlePatches.forEach((patch, index) => {
+            nodes.push(primitives.cylinder({ name: `d3 puddle disc ${index}`, material: material.pbr({ color: "#16283a", roughness: 0.05, metallic: 0.1 }) })
+                .position(patch.x * 2.4, 0.005, patch.z * 2.4).scale([Math.max(0.06, patch.radius * 3), 0.006, Math.max(0.06, patch.radius * 3)]).toJSON());
+        });
+        return {
+            nodes,
+            wetness: probe.response.wetness,
+            albedoColor: probe.response.albedoColor,
+            roughness: probe.response.roughness,
+            puddleCount: probe.weather.puddlePatches.length
+        };
+    },
+    /** Lightning-flash light hook: intensity is 0 unless type is thunderstorm. */
+    lightning: (options = { type: "thunderstorm" }) => {
+        const probe = describeWetMaterial({ type: options.type, elapsedSeconds: options.elapsedSeconds ?? 0.4, seed: options.seed ?? 0xd3e7 });
+        return {
+            nodes: probe.flash.intensity > 0
+                ? [lights.directional({ name: "d3 lightning flash", color: "#dbeafe", intensity: 1 + probe.flash.intensity * 4, position: [2, 6, -3] }).toJSON()]
+                : [],
+            intensity: probe.flash.intensity
+        };
+    }
+};
+/**
+ * D3 water surface builder (PRD D3 box 3). ADDITIVE root surface over
+ * `createWaterSurface` in `@aura3d/rendering`.
+ *
+ * Rendered material = layered opaque depth-tinted bands (bounded refraction
+ * look) + fresnel-baked sky tint + white shore-foam discs mapped from
+ * `OceanFoamPatch` + boat + fading wake trail. Buoyancy queries stay on the
+ * fixture (`sampleOceanFixture().buoyancy`); this builder creates no planar
+ * reflection/refraction targets (B4 dependency, see
+ * WATER_SURFACE_PLANAR_DEPENDENCY).
+ */
+export const water = {
+    surface: (options = {}) => {
+        const state = createWaterSurface({ preset: options.preset, seed: options.seed, boat: options.boat });
+        const nodes = [];
+        const bandSpan = 4 / state.bands.length;
+        state.bands.forEach((band, index) => {
+            nodes.push(primitives.box({ name: `d3 water depth band ${index}`, material: material.pbr({ color: band.color, roughness: 0.12, metallic: 0.05 }) })
+                .position(0, 0.02 + index * 0.0012, -4.5 + bandSpan * (index + 0.5)).scale([9, 0.024, bandSpan + 0.01]).toJSON());
+        });
+        nodes.push(primitives.box({ name: "d3 shoreline sand", material: material.pbr({ color: "#cbb37f", roughness: 0.95, metallic: 0 }) })
+            .position(0, 0, 0.9).scale([9, 0.03, 2.6]).toJSON());
+        for (const [index, patch] of state.foam.entries()) {
+            nodes.push(primitives.sphere({ name: `d3 shore foam ${index}`, material: material.pbr({ color: "#f4fafd", roughness: 0.55, metallic: 0 }) })
+                .position(Math.max(-4.2, Math.min(4.2, patch.x * 3)), 0.045, -0.42 + (index % 3) * 0.12).scale([Math.max(0.08, patch.radius * 6), 0.02, Math.max(0.05, patch.radius * 3)]).toJSON());
+        }
+        if (options.withBoatHull !== false && options.boat) {
+            nodes.push(primitives.box({ name: "d3 wake boat hull", material: material.pbr({ color: "#7c3f21", roughness: 0.7, metallic: 0 }) })
+                .position(options.boat.x ?? 0, 0.12, options.boat.z ?? -2).scale([0.34, 0.16, 0.9]).toJSON());
+        }
+        state.wake.forEach((segment, index) => {
+            nodes.push(primitives.box({ name: `d3 boat wake ${index}`, material: material.pbr({ color: "#cfeaf7", roughness: 0.3, metallic: 0 }) })
+                .position(segment.x * 2, 0.038, segment.z - 1.2).scale([segment.width, 0.012, 0.3]).toJSON());
+        });
+        return { nodes, bandCount: state.bands.length, foamCount: state.foam.length, wakeActive: state.wakeActive, wakeSegmentCount: state.wake.length };
+    },
+    /** Fixture-side buoyancy telemetry passthrough (no physics implemented here). */
+    buoyancy: (options = {}) => sampleOceanFixture({ preset: options.preset ?? "moderate", seed: options.seed ?? 0xaa7e5 }).buoyancy
+};
 export const interactions = {
     orbit: (options = {}) => new AuraNodeBuilder({
         kind: "interaction",
@@ -1648,7 +2137,24 @@ export const environments = {
         if (materialClass === "product")
             return environments.productHero();
         return environments.studio();
-    }
+    },
+    /**
+     * B3 root HDRI environment (muse3jsparity-PRD). The `.hdr` asset resolves
+     * post-mount: first frames render the honest studio procedural fallback,
+     * then the HDR→cubemap→GGX-prefilter→BRDF-LUT chain swaps in and
+     * `iblPixelBacked` flips true in diagnostics. Fetch/parse failures keep the
+     * fallback and warn — never a black scene, never a silent swap.
+     */
+    hdri: (options) => new AuraNodeBuilder({
+        kind: "environment",
+        environment: "hdri",
+        name: options.name ?? "hdri ibl environment",
+        intensity: options.intensity ?? 1,
+        texture: options.texture,
+        ...(options.reflectionTexture ? { reflectionTexture: options.reflectionTexture } : {}),
+        ...(options.color ? { color: options.color } : {}),
+        ...(options.rotation !== undefined ? { rotation: options.rotation } : {})
+    })
 };
 const rendererColorManagementPreset = {
     kind: "aura-renderer-color-management",
@@ -1774,6 +2280,7 @@ function normalizeCreateAppRendererOptions(options) {
         mode,
         fallback: options?.fallback ?? "safe-basic",
         qualityProfile: profile.id,
+        textureBudgetBytes: normalizeTextureBudgetBytes(options?.textureBudgetBytes),
         profile
     };
 }
@@ -1817,17 +2324,42 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
     const sceneCategory = resolveRendererSceneCategory(snapshot, names);
     const exposure = sceneExposurePresets[sceneCategory];
     const bloom = flattened.find((node) => node.kind === "effect" && node.effect === "bloom");
-    const fog = flattened.find((node) => node.kind === "effect" && node.effect === "fog");
+    const fog = flattened.find((node) => node.kind === "effect" && (node.effect === "fog" || node.effect === "volumetric-fog"));
     const environment = flattened.find((node) => node.kind === "environment");
     const contactShadows = names.filter((name) => name.includes("contact shadow") || name.includes("footprint") || name.includes("glow pool")).length;
     const ambientOcclusion = flattened.some((node) => node.kind === "effect" && node.effect === "ambient-occlusion");
     const contactOcclusion = flattened.some((node) => node.kind === "effect" && node.effect === "contact-occlusion") || contactShadows > 0;
+    // Authored temporal intent is separate from device-observed execution.
+    // Missing submissions remain visible without claiming an unmounted scene rendered.
+    const colorGradeNode = flattened.find((node) => node.kind === "effect" && node.effect === "color-grade");
+    const antiAliasNode = flattened.find((node) => node.kind === "effect" && node.effect === "anti-alias");
+    const outlineNode = flattened.find((node) => node.kind === "effect" && node.effect === "outline");
+    const ssrNode = flattened.find((node) => node.kind === "effect" && node.effect === "screen-space-reflections");
+    const dofNode = flattened.find((node) => node.kind === "effect" && node.effect === "depth-of-field");
+    const motionBlurNode = flattened.find((node) => node.kind === "effect" && node.effect === "motion-blur");
+    const flipbookNode = flattened.find((node) => node.kind === "effect" && node.effect === "flipbook-sprite");
+    const beamNode = flattened.find((node) => node.kind === "effect" && node.effect === "light-beam");
+    const sdfTextRequested = flattened.some((node) => node.kind === "primitive" && node.text3D?.backend === "sdf");
+    const fxaaRequested = (antiAliasNode?.mode ?? "fxaa") === "fxaa" && Boolean(antiAliasNode);
+    const taaRequested = (antiAliasNode?.mode ?? "fxaa") === "taa";
+    const taaWithheld = taaRequested && Boolean(runtime?.mounted) && !(runtime?.postprocess?.actualPasses ?? []).includes("taa");
+    const motionBlurWithheld = Boolean(motionBlurNode) && Boolean(runtime?.mounted) && !(runtime?.postprocess?.actualPasses ?? []).includes("motion-blur");
     const runtimePostprocess = runtime?.postprocess;
     const runtimePasses = runtimePostprocess?.actualPasses ?? [];
-    const postprocessRequested = Boolean(bloom) || ambientOcclusion || contactOcclusion || runtimePasses.length > 0;
+    const postprocessRequested = Boolean(bloom) || ambientOcclusion || contactOcclusion
+        || Boolean(colorGradeNode) || Boolean(antiAliasNode) || Boolean(outlineNode)
+        || Boolean(ssrNode) || Boolean(dofNode) || Boolean(motionBlurNode) || runtimePasses.length > 0;
     const requestedPasses = runtimePasses.length > 0
         ? runtimePasses
-        : requestedRendererPostProcessPasses(Boolean(bloom), ambientOcclusion, contactOcclusion);
+        : requestedRendererPostProcessPasses(Boolean(bloom), ambientOcclusion, contactOcclusion, {
+            colorGrade: Boolean(colorGradeNode),
+            fxaa: fxaaRequested,
+            outline: Boolean(outlineNode),
+            ssr: Boolean(ssrNode),
+            depthOfField: Boolean(dofNode),
+            motionBlurWithheld: Boolean(motionBlurNode),
+            taaWithheld: taaRequested
+        });
     const runtimeStatus = !postprocessRequested
         ? "disabled"
         : runtime?.mounted
@@ -1842,6 +2374,28 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
         warnings.push("scene has no contact shadow or contact-occlusion grounding cue");
     if (bloom && (bloom.intensity ?? 0) > 0.95 && bloom.antiBlowout !== true)
         warnings.push("bloom is high without anti-blowout safeguards");
+    if (motionBlurWithheld)
+        warnings.push("TEMPORAL_INPUTS_UNAVAILABLE: motion-blur has no native submission");
+    if (flipbookNode)
+        warnings.push("flipbook-sprite is recorded but withheld: root has no native sprite-sheet sampler yet, so no flipbook pass is submitted");
+    if (beamNode)
+        warnings.push("light-beam is recorded but withheld: root has no native beam target yet, so no beam pass is submitted");
+    // G1: the baked-SDF sampler mounts synchronously on the production bridge.
+    // Warn only when the SDF request cannot be pixel-backed (non-production
+    // mount, or the sampler fell back to the extruded mesh at runtime).
+    if (sdfTextRequested && (!runtime?.mounted || !(runtime.text?.textPixelBacked ?? false))) {
+        warnings.push(runtime?.mounted
+            ? `text3D sdf backend fell back to the extruded mesh (${runtime.text?.reason ?? "sampler failed"}); textPixelBacked stays false`
+            : "text3D sdf backend is recorded but unmounted: the production bridge samples the SDF atlas at mount, so textPixelBacked stays false until render");
+    }
+    if (taaWithheld)
+        warnings.push("TEMPORAL_INPUTS_UNAVAILABLE: taa has no native submission");
+    if (colorGradeNode && (colorGradeNode.exposure ?? 1) !== 1)
+        warnings.push("color-grade exposure is recorded but has no native grade target yet; contrast/saturation execute");
+    if (colorGradeNode && (colorGradeNode.shadows !== undefined || colorGradeNode.highlights !== undefined))
+        warnings.push("color-grade shadows/highlights are recorded but have no native grade target yet; contrast/saturation execute");
+    if (colorGradeNode?.lut !== undefined)
+        warnings.push("color-grade lut is recorded but LUT samplers are not bound yet; the lut is ignored");
     if (postprocessRequested && !runtime?.mounted)
         warnings.push("renderer diagnostics are a scene plan only; call createAuraApp(...).diagnostics() after the first render for pixel-backed pass status");
     if (postprocessRequested && runtime?.mounted && !runtimePostprocess?.pixelBacked)
@@ -1891,7 +2445,8 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             intensity: bloom?.intensity ?? 0,
             threshold: bloom?.threshold ?? 0,
             radius: bloom?.radius ?? 0,
-            antiBlowout: bloom?.antiBlowout ?? true
+            antiBlowout: bloom?.antiBlowout ?? true,
+            ...(bloom?.quality !== undefined ? { quality: bloom.quality } : {})
         },
         shadows: {
             // Never a source-authored `true`. When the runtime is mounted this is the
@@ -1905,8 +2460,10 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             label: runtime?.shadow?.label,
             nativeShadowMapBindings: runtime?.shadow?.nativeShadowMapBindings ?? 0,
             shadowRenderTargetsAllocated: runtime?.shadow?.shadowRenderTargetsAllocated ?? 0,
+            observed: runtime?.mounted ? runtime.shadow?.observed ?? null : null,
             contactShadows,
-            mapType: "pcf-soft"
+            mapType: "pcf-soft",
+            ...(runtime?.shadow?.spot === undefined ? {} : { spot: runtime.shadow.spot })
         },
         occlusion: {
             enabled: ambientOcclusion || contactOcclusion,
@@ -1921,7 +2478,9 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
         fog: {
             enabled: Boolean(fog),
             density: fog?.density ?? 0,
-            preset: fog ? ((fog.intensity ?? 0) > 0.65 ? "volumetric" : "depth") : "none"
+            // A5: a volumetric-fog node labels "volumetric" because it submits the
+            // distinct inscatter pass; plain fog keeps the legacy intensity label.
+            preset: fog ? (fog.effect === "volumetric-fog" || (fog.intensity ?? 0) > 0.65 ? "volumetric" : "depth") : "none"
         },
         postprocess: {
             enabled: runtimePostprocess?.pixelBacked ?? false,
@@ -1937,6 +2496,7 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             actualPasses: runtimePostprocess?.actualPasses ?? [],
             fallbackPasses: runtimePostprocess?.fallbackPasses ?? [],
             targetFormat: runtimePostprocess?.targetFormat,
+            executionMode: runtimePostprocess?.executionMode ?? "unknown",
             evidence: postprocessEvidence
         },
         runtime: {
@@ -1946,17 +2506,45 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             passNames: runtimePostprocess?.actualPasses ?? [],
             warnings: runtime?.warnings ?? [],
             nativeInstancedSubmissions: runtime?.deviceDiagnostics?.nativeInstancedSubmissions ?? 0,
+            nativeTemporalPasses: runtime?.deviceDiagnostics?.nativeTemporalPasses ?? 0,
+            nativeTemporalBindings: runtime?.deviceDiagnostics?.nativeTemporalBindings ?? 0,
             submittedObjects: runtime?.deviceDiagnostics?.submittedObjects ?? 0,
             visibleObjects: runtime?.deviceDiagnostics?.visibleObjects ?? 0,
             culledObjects: runtime?.deviceDiagnostics?.culledObjects ?? 0,
             frustumTestedObjects: runtime?.deviceDiagnostics?.frustumTestedObjects ?? 0,
-            lodSelections: runtime?.lodSelections ?? []
+            bloom: runtime?.deviceDiagnostics?.bloom ?? null,
+            samplerAnisotropyUploads: runtime?.deviceDiagnostics?.samplerAnisotropyUploads ?? 0,
+            maxTextureAnisotropy: runtime?.deviceDiagnostics?.maxTextureAnisotropy ?? 1,
+            lodSelections: runtime?.lodSelections ?? [],
+            texturedMaterials: runtime?.texturedMaterials ?? []
         },
         environment: {
             enabled: environmentStatus.enabled,
             preset: environmentStatus.preset,
             intensity: environmentStatus.intensity,
-            evidence: environmentStatus.evidence
+            evidence: environmentStatus.evidence,
+            // B3: pass through the HDRI upgrade observation; the unmounted default
+            // reports not-pixel-backed so static diagnostics never claim HDRI proof.
+            iblPixelBacked: environmentStatus.iblPixelBacked ?? false,
+            hdriStatus: environmentStatus.hdriStatus ?? "none",
+            ...(environmentStatus.dualProbe === undefined ? {} : { dualProbe: environmentStatus.dualProbe }),
+            ...(environmentStatus.hdriRotation === undefined ? {} : { hdriRotation: environmentStatus.hdriRotation })
+        },
+        text: runtime?.text ?? {
+            sdfTexts: flattened.filter((node) => node.kind === "primitive" && node.text3D?.backend === "sdf").length,
+            textPixelBacked: false,
+            quadCount: 0,
+            lastOpacity: 1,
+            reason: "SDF text requested in the scene graph but no runtime has mounted yet"
+        },
+        textures: runtime?.textures ?? {
+            budgetBytes: normalizeTextureBudgetBytes(rendererOptions?.textureBudgetBytes),
+            usedBytes: 0,
+            requestedBytes: 0,
+            overBudget: false,
+            overBudgetBytes: 0,
+            residentEntries: 0,
+            evictedEntries: []
         },
         antialiasing: rendererQualityPresets.screenshot.antialiasing,
         screenshotQuality: rendererQualityPresets.screenshot,
@@ -1964,14 +2552,31 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
         warnings
     };
 }
-function requestedRendererPostProcessPasses(hasBloom, ambientOcclusion, contactOcclusion) {
-    if (!hasBloom && !ambientOcclusion && !contactOcclusion)
+function requestedRendererPostProcessPasses(hasBloom, ambientOcclusion, contactOcclusion, extra = {}) {
+    if (!hasBloom && !ambientOcclusion && !contactOcclusion && !extra.colorGrade && !extra.fxaa
+        && !extra.outline && !extra.ssr && !extra.depthOfField && !extra.motionBlurWithheld && !extra.taaWithheld)
         return [];
     const passes = ["render"];
     if (ambientOcclusion || contactOcclusion)
         passes.push("ssao");
     if (hasBloom)
         passes.push("bloom");
+    if (extra.colorGrade)
+        passes.push("color-grade");
+    if (extra.ssr)
+        passes.push("ssr");
+    if (extra.depthOfField)
+        passes.push("depth-of-field");
+    if (extra.outline)
+        passes.push("outline");
+    if (extra.fxaa)
+        passes.push("fxaa");
+    // Withheld intents stay visible in the request list with an explicit suffix
+    // so requested-vs-actual never silently agrees on an unexecuted pass.
+    if (extra.motionBlurWithheld)
+        passes.push("motion-blur");
+    if (extra.taaWithheld)
+        passes.push("taa");
     passes.push("output");
     return passes;
 }
@@ -2032,6 +2637,7 @@ export class AuraSceneBuilder {
         return this;
     }
     camera(next) {
+        resolveCameraClipping(next);
         this.cameraSpec = next;
         return this;
     }
@@ -6384,6 +6990,16 @@ export function createRuntimeNodeImportedAssetEvidence(input) {
         renderItemCount: input.renderItemCount ?? 0,
         skinnedRenderItemCount: input.skinnedRenderItemCount ?? 0,
         morphRenderItemCount: input.morphRenderItemCount ?? 0,
+        ...(input.lastMaterialTracksApplied !== undefined ? { lastMaterialTracksApplied: input.lastMaterialTracksApplied } : {}),
+        ...(input.lastLightTracksApplied !== undefined ? { lastLightTracksApplied: input.lastLightTracksApplied } : {}),
+        ...(input.lastFootPlantingGroundedFeet !== undefined ? { lastFootPlantingGroundedFeet: input.lastFootPlantingGroundedFeet } : {}),
+        ...(input.lastFootPlantingTargetError !== undefined ? { lastFootPlantingTargetError: input.lastFootPlantingTargetError } : {}),
+        ...(input.lastFootPlantingHipOffset !== undefined ? { lastFootPlantingHipOffset: input.lastFootPlantingHipOffset } : {}),
+        ...(input.lastFootPlantingMissingLegs !== undefined ? { lastFootPlantingMissingLegs: [...input.lastFootPlantingMissingLegs] } : {}),
+        ...(input.lastFootPlantingDeformation !== undefined ? { lastFootPlantingDeformation: input.lastFootPlantingDeformation.map(leg => ({ ...leg })) } : {}),
+        ...(input.lastFootPlantingSurfaces !== undefined ? { lastFootPlantingSurfaces: input.lastFootPlantingSurfaces.map(point => ({ ...point, worldPosition: [...point.worldPosition] })) } : {}),
+        ...(input.lastFootPlantingFeet !== undefined ? { lastFootPlantingFeet: input.lastFootPlantingFeet.map(foot => ({ ...foot, worldPosition: [...foot.worldPosition] })) } : {}),
+        ...(input.footPlantingConfigured !== undefined ? { footPlantingConfigured: input.footPlantingConfigured } : {}),
         diagnostics
     };
 }
@@ -6660,11 +7276,26 @@ export function createAuraApp(target, options) {
     const canvas = resolveCanvas(target);
     if (canvas) {
         configureCanvas(canvas, options.pixelRatio ?? rendererSelection.profile.pixelRatio ?? devicePixelRatioSafe(), options.resize ?? true);
+        initializeRootPerformanceQuality(canvas);
+        // Apply a caller's device/capture budget before the production controller
+        // derives its first backing size, LODs, particle pool and shadow target.
+        // Runtime mutations remain guarded by app.setPerformanceQuality().
+        if (options.performanceQuality)
+            setRootPerformanceQuality(canvas, options.performanceQuality);
     }
     const overlay = canvas && shouldRenderOverlay(options.diagnostics, snapshot) ? createDiagnosticsOverlay(canvas, diagnosticsState) : undefined;
     let disposed = false;
     let animationHandle = 0;
     let productionController;
+    let pendingAsyncSteps = 0;
+    let asyncSteps = Promise.resolve();
+    const assertMutableFrame = () => {
+        if (disposed)
+            throw new Error("Aura3D app is disposed.");
+        if (pendingAsyncSteps > 0 || productionController?.busy?.()) {
+            throw new Error("Aura3D frame submission is pending; await stepAsync() before synchronous mutation.");
+        }
+    };
     /** WS-2.9: true from the moment a WebGL mount starts until the controller arrives or fails. */
     let productionMountPending = false;
     /**
@@ -6685,6 +7316,7 @@ export function createAuraApp(target, options) {
      * any time and on any scene.
      */
     let productionMountSettled = Promise.resolve();
+    let productionMountTask = Promise.resolve();
     /** Lets `dispose()` settle an in-flight mount; see the note there. */
     let settleMountForDispose = () => undefined;
     /*
@@ -6749,7 +7381,9 @@ export function createAuraApp(target, options) {
         appPhysicsWorldInstance ??= new PhysicsWorld({
             gravity: options.physics?.gravity ? [...options.physics.gravity] : [0, -9.81, 0],
             fixedDelta: 1 / 60,
-            enableSleeping: true
+            enableSleeping: true,
+            ...(options.physics?.seed === undefined ? {} : { seed: options.physics.seed }),
+            ...(options.physics?.continuousCollision ? { continuousCollision: options.physics.continuousCollision } : {})
         });
         return appPhysicsWorldInstance;
     };
@@ -6804,6 +7438,8 @@ export function createAuraApp(target, options) {
     let runtimeAlpha = 0;
     const ownedInputControllers = new Set();
     const runRuntimeFrame = (dt, source) => {
+        if (disposed)
+            return;
         runtimeFrame += 1;
         runtimeTime += dt;
         runtimeAlpha = runtimeFixedDt > 0 ? Math.max(0, Math.min(1, (dt % runtimeFixedDt) / runtimeFixedDt)) : 0;
@@ -6821,7 +7457,7 @@ export function createAuraApp(target, options) {
         for (const callback of [...frameCallbacks])
             callback(frame);
     };
-    const shouldUseProductionRendererForCurrentScene = () => Boolean(canvas && renderSnapshot.nodes.some(isWebGLRenderableNode) && typeof window !== "undefined");
+    const shouldUseProductionRendererForCurrentScene = () => Boolean(canvas && hasRootRenderableContent(canvas, renderSnapshot.nodes.some(isWebGLRenderableNode)) && typeof window !== "undefined");
     const resetDiagnosticsForCurrentScene = (backend) => {
         const fresh = createInitialDiagnostics(renderSnapshot, options.renderer);
         diagnosticsState.backend = backend;
@@ -6886,7 +7522,7 @@ export function createAuraApp(target, options) {
          * So the two cases are separated. A renderable scene with no usable canvas now raises a diagnosable
          * error naming the cause, instead of drawing something plausible.
          */
-        const declaresRenderableContent = renderSnapshot.nodes.some(isWebGLRenderableNode);
+        const declaresRenderableContent = hasRootRenderableContent(canvas, renderSnapshot.nodes.some(isWebGLRenderableNode));
         /*
          * Scoped to the case that is actually a lie: a canvas WAS supplied, so the caller is looking at
          * pixels, and the scene has renderable content — but WebGL declined it, so those pixels would be a
@@ -6925,7 +7561,7 @@ export function createAuraApp(target, options) {
             : Promise.resolve();
         settleMountForDispose = settleMount;
         if (shouldUseProductionRenderer && canvas) {
-            void startProductionRender(canvas, renderSnapshot, diagnosticsState, options, overlay, runRuntimeFrame, () => runtimePaused, runtimeNodes, 
+            productionMountTask = startProductionRender(canvas, renderSnapshot, diagnosticsState, options, overlay, runRuntimeFrame, () => runtimePaused, runtimeNodes, 
             // A route that registered a frame callback, or that has bodies to simulate, needs
             // frames regardless of what the scene declares.
             /*
@@ -6939,7 +7575,6 @@ export function createAuraApp(target, options) {
             () => runtimeTime * 1000)
                 .then((controller) => {
                 if (disposed || revision !== mountRevision) {
-                    productionMountPending = false;
                     settleMount();
                     controller.dispose();
                     return;
@@ -6951,6 +7586,7 @@ export function createAuraApp(target, options) {
                 markRouteReady(snapshot, diagnosticsState);
             })
                 .catch((error) => {
+                settleMount();
                 if (disposed || revision !== mountRevision)
                     return;
                 productionMountPending = false;
@@ -6975,7 +7611,18 @@ export function createAuraApp(target, options) {
         get backend() {
             return diagnosticsState.backend;
         },
+        setPerformanceQuality(settings) {
+            assertMutableFrame();
+            const quality = validateRootPerformanceQuality(settings);
+            if (!canvas || !productionController?.setPerformanceQuality)
+                throw new Error("PERFORMANCE_QUALITY_UNSUPPORTED: await a production renderer mount before changing quality.");
+            if (quality.particleScale !== 1 && !supportsRootParticleQuality(canvas))
+                throw new Error("PERFORMANCE_PARTICLE_OWNER_UNAVAILABLE: this root workload has no adaptive native particle owner.");
+            applyRootParticleQuality(canvas, quality.particleScale);
+            productionController.setPerformanceQuality(quality);
+        },
         setScene(nextScene) {
+            assertMutableFrame();
             snapshot = normalizeSceneSnapshot(nextScene);
             renderSnapshot = flattenSceneSnapshot(snapshot);
             runtimeNodes.reset(renderSnapshot);
@@ -7022,6 +7669,10 @@ export function createAuraApp(target, options) {
         },
         pause() {
             runtimePaused = true;
+            // Stop the production requestAnimationFrame owner as well as simulation.
+            // Holding the clock alone still submitted the same expensive frame forever.
+            productionController?.pause?.();
+            productionController?.resetTemporalHistory?.("pause");
         },
         resetRuntimeClock() {
             /*
@@ -7044,6 +7695,8 @@ export function createAuraApp(target, options) {
         },
         resume() {
             runtimePaused = false;
+            productionController?.resetTemporalHistory?.("resume");
+            productionController?.resume?.();
             if (!animationHandle && !productionController && options.autoStart !== false && typeof requestAnimationFrame !== "undefined") {
                 animationHandle = requestAnimationFrame(render);
             }
@@ -7072,11 +7725,17 @@ export function createAuraApp(target, options) {
             return productionController?.deviceLost?.() ?? false;
         },
         advance(dt = 1 / 60) {
+            assertMutableFrame();
             const seconds = Math.max(0, dt);
             runRuntimeFrame(seconds, "manual");
             canvasRuntimePhysics?.step(seconds);
+            // Imported GLB animation, consumed root motion and foot planting live in the
+            // production actor bridge. They are simulation state, so `advance()` must
+            // update them even when no GPU frame is presented.
+            productionController?.update?.(runtimeTime * 1000);
         },
         step(dt = 1 / 60) {
+            assertMutableFrame();
             const seconds = Math.max(0, dt);
             app.advance(seconds);
             const previousPaused = runtimePaused;
@@ -7136,7 +7795,38 @@ export function createAuraApp(target, options) {
             }
             runtimePaused = previousPaused;
         },
+        stepAsync(dt = 1 / 60) {
+            if (!Number.isFinite(dt) || dt < 0)
+                return Promise.reject(new Error("Aura3D stepAsync requires a finite non-negative delta."));
+            if (disposed)
+                return Promise.reject(new Error("Aura3D app is disposed."));
+            pendingAsyncSteps += 1;
+            const next = asyncSteps.then(async () => {
+                await productionMountSettled;
+                if (disposed)
+                    throw new Error("Aura3D app is disposed.");
+                const controller = productionController;
+                if (productionMountFailed || !controller?.renderAsync) {
+                    throw new Error(`Aura3D asynchronous submission unavailable: ${diagnosticsState.errors.join("; ") || "a production renderer is required"}`);
+                }
+                await controller.renderAsync(() => {
+                    runRuntimeFrame(dt, "manual");
+                    canvasRuntimePhysics?.step(dt);
+                    return runtimeTime * 1000;
+                });
+            }).finally(() => { pendingAsyncSteps -= 1; });
+            asyncSteps = next.catch(() => undefined);
+            return next;
+        },
+        async disposeAsync() {
+            const controller = productionController;
+            app.dispose();
+            await asyncSteps;
+            await productionMountTask;
+            await controller?.whenIdle?.();
+        },
         diagnostics() {
+            diagnosticsState.renderer = readRootDiagnosticSnapshot(diagnosticsState.renderer, productionController?.diagnostics, disposed, pendingAsyncSteps > 0 || Boolean(productionController?.busy?.()));
             return snapshotDiagnostics(diagnosticsState);
         },
         evidence(evidenceOptions = {}) {
@@ -7476,6 +8166,7 @@ function worldLabelsFromSnapshot(snapshot, runtimeNodes) {
             return {
                 id: node.name ?? `${node.label}-${index + 1}`,
                 text: node.text,
+                role: labelTelemetryRoleFor(node.label),
                 anchor: [0, 0, 0],
                 offscreenPolicy: "hide"
             };
@@ -7489,6 +8180,7 @@ function worldLabelsFromSnapshot(snapshot, runtimeNodes) {
         return {
             id: node.name ?? `${node.label}-${index + 1}`,
             text: node.text,
+            role: labelTelemetryRoleFor(node.label),
             anchor: [position[0], position[1], position[2]],
             leaderAnchor: [anchor[0], anchor[1], anchor[2]],
             screenOffset: separated ? [0, 0] : [0, -26],
@@ -7642,8 +8334,10 @@ requiresFrames = () => false,
  * wall-clock time. Without it, `pause()` froze the simulation but not time-driven rendering.
  */
 pausedRenderTime = () => 0) {
-    const renderableNode = snapshot.nodes.find(isWebGLRenderableNode);
-    if (!renderableNode) {
+    // Use the same ownership rule as initial mount and setScene. A compatibility
+    // source continues supplying arena/fighter geometry when public nodes are
+    // temporarily absent (for example the crowd-hidden negative control).
+    if (!hasRootRenderableContent(canvas, snapshot.nodes.some(isWebGLRenderableNode))) {
         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().");
     }
     const renderer = await createProductionSceneRenderer(canvas, snapshot, options.renderer, runtimeNodes);
@@ -7652,14 +8346,34 @@ pausedRenderTime = () => 0) {
     const labelLayer = createSceneLabelLayer(canvas, snapshot);
     const rendererSelection = normalizeCreateAppRendererOptions(options.renderer);
     const pixelRatio = options.pixelRatio ?? rendererSelection.profile.pixelRatio ?? devicePixelRatioSafe();
+    let disposed = false;
+    let animationHandle = 0;
+    let lastTime = 0;
+    let pendingFrames = 0;
+    let frameTail = Promise.resolve();
+    const baseBackingSize = getRootPerformanceBaseSize(canvas);
+    let resourcesReleased = false;
+    const releaseResources = () => {
+        if (resourcesReleased)
+            return;
+        resourcesReleased = true;
+        labelLayer?.dispose();
+        renderer.dispose();
+    };
     const resizeRenderer = () => {
+        if (disposed)
+            return;
+        if (pendingFrames > 0) {
+            resourceOwner.requestResize();
+            return;
+        }
         if (options.resize === false)
             return;
         const parentRect = canvas.parentElement?.getBoundingClientRect();
         const cssWidth = parentRect?.width || canvas.clientWidth || (typeof window !== "undefined" ? window.innerWidth : 960) || 960;
         const cssHeight = parentRect?.height || canvas.clientHeight || (typeof window !== "undefined" ? window.innerHeight : 540) || 540;
-        const width = Math.max(320, Math.round(cssWidth * pixelRatio));
-        const height = Math.max(220, Math.round(cssHeight * pixelRatio));
+        const width = Math.max(1, Math.round(Math.max(320, cssWidth * pixelRatio) * (getRootPerformanceQuality(canvas)?.resolutionScale ?? 1)));
+        const height = Math.max(1, Math.round(Math.max(220, cssHeight * pixelRatio) * (getRootPerformanceQuality(canvas)?.resolutionScale ?? 1)));
         if (canvas.width === width && canvas.height === height)
             return;
         canvas.style.width = `${cssWidth}px`;
@@ -7668,21 +8382,19 @@ pausedRenderTime = () => 0) {
         canvas.height = height;
         renderer.resize?.(width, height);
     };
+    const resourceOwner = new DeferredFrameResources(releaseResources, resizeRenderer);
     const resizeObserver = options.resize !== false && typeof ResizeObserver !== "undefined" && canvas.parentElement
         ? new ResizeObserver(resizeRenderer)
         : undefined;
     resizeObserver?.observe(canvas.parentElement);
     if (options.resize !== false && typeof window !== "undefined")
         window.addEventListener("resize", resizeRenderer);
-    let disposed = false;
-    let animationHandle = 0;
-    let lastTime = 0;
-    const renderFrame = (time = performanceNow()) => {
+    const renderFrame = (time = performanceNow(), submittedDrawCalls, explicit = false) => {
         if (disposed)
             return;
         const delta = lastTime > 0 ? Math.max(1, time - lastTime) : 16.67;
         lastTime = time;
-        if (!isPaused())
+        if (!explicit && !isPaused())
             beforeRender?.(delta / 1000, "raf");
         /*
          * A paused app must not keep advancing time-driven rendering.
@@ -7697,8 +8409,8 @@ pausedRenderTime = () => 0) {
          * `runtimeTime` and renders explicitly, so stepping still produces new frames — what stops is
          * time passing on its own.
          */
-        const renderTime = isPaused() ? pausedRenderTime() : time;
-        const drawCalls = renderer.render(renderTime);
+        const renderTime = resolveRootRenderTime(time, explicit, isPaused, pausedRenderTime);
+        const drawCalls = submittedDrawCalls ?? renderer.render(renderTime);
         diagnosticsState.backend = renderer.backend;
         diagnosticsState.fps = diagnosticsState.fps || 60;
         diagnosticsState.drawCalls = drawCalls;
@@ -7717,14 +8429,100 @@ pausedRenderTime = () => 0) {
             labelLayer.setOcclusionTest(createSceneLabelOcclusionTest(snapshot, resolveCameraFrame(snapshot, snapshot.camera, renderTime, runtimeNodes).eye, runtimeNodes));
             labelLayer.update(renderer.viewProjection(renderTime));
             diagnosticsState.labels = labelLayer.snapshot();
+            const labelNodes = groups.flatten(snapshot.nodes).filter((node) => node.kind === "label");
+            diagnosticsState.labelTelemetry = collectLabelTelemetry(labelNodes, diagnosticsState.labels);
+            diagnosticsState.textBuckets = summarizeTextBuckets({
+                accessibleDom: labelNodes.filter((node) => node.label === "hud").length,
+                worldAnchoredPlaced: diagnosticsState.labels.filter((label) => label.visible).length,
+                sdfTexts: groups.flatten(snapshot.nodes).filter((node) => node.kind === "primitive" && node.text3D?.backend === "sdf").length
+            });
         }
         overlay?.update();
-        if ((sceneWantsFrames || requiresFrames()) && options.autoStart !== false && typeof requestAnimationFrame !== "undefined") {
-            animationHandle = requestAnimationFrame(renderFrame);
+        if (!explicit && !isPaused() && (sceneWantsFrames || requiresFrames()) && options.autoStart !== false && typeof requestAnimationFrame !== "undefined") {
+            animationHandle = requestAnimationFrame(scheduleFrame);
         }
     };
-    renderFrame();
+    const submitAsync = (clock, automatic = false) => {
+        if (disposed)
+            return Promise.reject(new Error("Aura3D renderer is disposed."));
+        if (!renderer.renderAsync)
+            return Promise.reject(new Error("Aura3D asynchronous submission requires the production renderer."));
+        pendingFrames += 1;
+        const submitted = resourceOwner.run(() => frameTail.then(async () => {
+            if (disposed)
+                throw new Error("Aura3D renderer is disposed.");
+            const time = clock();
+            if (automatic) {
+                const delta = lastTime > 0 ? Math.max(1, time - lastTime) : 16.67;
+                lastTime = time;
+                if (!isPaused())
+                    beforeRender?.(delta / 1000, "raf");
+            }
+            // User frame callbacks can dispose the app. Do not submit a new frame after
+            // that callback; pending ownership still defers cleanup until this settles.
+            if (disposed)
+                throw new Error("Aura3D renderer is disposed.");
+            const renderTime = resolveRootRenderTime(time, !automatic, isPaused, pausedRenderTime);
+            const drawCalls = await renderer.renderAsync(renderTime);
+            if (!disposed) {
+                const previousLastTime = lastTime;
+                renderFrame(renderTime, drawCalls, true);
+                lastTime = previousLastTime;
+            }
+        }).finally(() => { pendingFrames -= 1; }));
+        frameTail = submitted.catch(() => undefined);
+        return submitted;
+    };
+    const scheduleFrame = (time) => {
+        animationHandle = 0;
+        if (disposed)
+            return;
+        if (options.frameMode === "async") {
+            void submitAsync(() => time, true).then(() => {
+                if (!disposed && !isPaused() && (sceneWantsFrames || requiresFrames()) && options.autoStart !== false && typeof requestAnimationFrame !== "undefined") {
+                    animationHandle = requestAnimationFrame(scheduleFrame);
+                }
+            }).catch((error) => {
+                diagnosticsState.errors.push(productionRenderErrorMessage(error));
+                overlay?.update();
+            });
+        }
+        else if (pendingFrames > 0) {
+            // A manual async frame owns the resources. Retry without advancing simulation.
+            // A pause cancels automatic retries; the explicit owner completes independently.
+            if (!isPaused())
+                animationHandle = requestAnimationFrame(scheduleFrame);
+        }
+        else
+            renderFrame(time);
+    };
+    try {
+        if (options.frameMode === "async") {
+            await submitAsync(() => performanceNow(), true);
+            if (!isPaused() && (sceneWantsFrames || requiresFrames()) && options.autoStart !== false && typeof requestAnimationFrame !== "undefined") {
+                animationHandle = requestAnimationFrame(scheduleFrame);
+            }
+        }
+        else
+            renderFrame();
+    }
+    catch (error) {
+        // A failed first submission has no returned controller to dispose its resources.
+        disposed = true;
+        resizeObserver?.disconnect();
+        if (typeof window !== "undefined")
+            window.removeEventListener("resize", resizeRenderer);
+        releaseResources();
+        throw error;
+    }
     return {
+        update(time) {
+            if (disposed)
+                throw new Error("Aura3D renderer is disposed.");
+            if (pendingFrames > 0)
+                throw new Error("Aura3D async frame is pending; await it before advancing renderer state.");
+            renderer.update?.(time);
+        },
         render(time = performanceNow()) {
             /*
              * Preserve `lastTime` across an explicit render.
@@ -7735,10 +8533,50 @@ pausedRenderTime = () => 0) {
              * different clock — a visible jump. Same defect the canvas2d path had; fixed identically so
              * the two render paths cannot disagree about what `step` does.
              */
+            if (pendingFrames > 0)
+                throw new Error("Aura3D async frame is pending; await it before synchronous rendering.");
             const previousLastTime = lastTime;
-            renderFrame(time);
+            renderFrame(time, undefined, true);
             lastTime = previousLastTime;
         },
+        setPerformanceQuality(settings) {
+            if (disposed || pendingFrames > 0)
+                throw new Error("PERFORMANCE_QUALITY_BUSY: await the active frame before changing quality.");
+            setRootPerformanceQuality(canvas, settings);
+            if (options.resize !== false)
+                resizeRenderer();
+            else {
+                const width = Math.max(1, Math.round(baseBackingSize.width * settings.resolutionScale));
+                const height = Math.max(1, Math.round(baseBackingSize.height * settings.resolutionScale));
+                canvas.width = width;
+                canvas.height = height;
+                renderer.resize?.(width, height);
+            }
+            renderer.resetTemporalHistory?.("performance-quality");
+        },
+        diagnostics: () => disposed || pendingFrames > 0 ? undefined : renderer.diagnostics,
+        renderAsync: (clock) => submitAsync(clock),
+        busy: () => pendingFrames > 0,
+        whenIdle: () => frameTail,
+        resetTemporalHistory(reason) {
+            // Reset after the active submission, before the next one can consume history.
+            if (pendingFrames > 0)
+                frameTail = frameTail.then(() => { if (!disposed)
+                    renderer.resetTemporalHistory?.(reason); });
+            else
+                renderer.resetTemporalHistory?.(reason);
+        },
+        pause() {
+            if (animationHandle && typeof cancelAnimationFrame !== "undefined")
+                cancelAnimationFrame(animationHandle);
+            animationHandle = 0;
+        },
+        resume() {
+            if (disposed || animationHandle || options.autoStart === false || typeof requestAnimationFrame === "undefined")
+                return;
+            if (sceneWantsFrames || requiresFrames())
+                animationHandle = requestAnimationFrame(scheduleFrame);
+        },
         // WS-2.6 — forward device-loss subscription from whichever renderer backs this controller.
         onDeviceLost: renderer.onDeviceLost ? (listener) => renderer.onDeviceLost(listener) : undefined,
         onDeviceRestored: renderer.onDeviceRestored ? (listener) => renderer.onDeviceRestored(listener) : undefined,
@@ -7750,8 +8588,7 @@ pausedRenderTime = () => 0) {
             resizeObserver?.disconnect();
             if (typeof window !== "undefined")
                 window.removeEventListener("resize", resizeRenderer);
-            labelLayer?.dispose();
-            renderer.dispose();
+            resourceOwner.dispose();
         }
     };
 }
@@ -7814,16 +8651,37 @@ function createProductionRuntimeEnvironment(snapshot) {
             "product-hero": "softbox",
             "night-cinematic": "evening",
             "metal-studio": "exhibit",
-            "glass-studio": "softbox"
+            "glass-studio": "softbox",
+            // B3: HDRI first frames render the honest studio procedural fallback;
+            // the post-mount upgrade swaps in the HDR chain (hdriUrl below).
+            "hdri": "studio"
         };
         const preset = presetByEnvironment[authoredEnvironment.environment];
         const bundle = createExternalParityEnvironmentLighting(preset);
         const intensity = nonNegativeFinite(authoredEnvironment.intensity);
         const proceduralMap = bundle.lighting.proceduralMap;
+        const hdriUrl = authoredEnvironment.environment === "hdri"
+            && typeof authoredEnvironment.texture === "object"
+            && authoredEnvironment.texture.kind === "aura-asset-ref"
+            ? authoredEnvironment.texture.url ?? undefined
+            : undefined;
+        const hdriReflectionUrl = authoredEnvironment.environment === "hdri"
+            && typeof authoredEnvironment.reflectionTexture === "object"
+            && authoredEnvironment.reflectionTexture.kind === "aura-asset-ref"
+            ? authoredEnvironment.reflectionTexture.url ?? undefined
+            : undefined;
+        const hdriRotation = authoredEnvironment.environment === "hdri" && authoredEnvironment.rotation !== undefined
+            ? authoredEnvironment.rotation
+            : undefined;
         return {
             preset: authoredEnvironment.environment,
             intensity,
-            evidence: `production bridge submitted the authored ${authoredEnvironment.environment} environment through generated HDR ${preset} lighting`,
+            evidence: hdriUrl
+                ? `production bridge renders the studio procedural fallback until the authored HDRI ${hdriUrl}${hdriReflectionUrl ? ` (reflection ${hdriReflectionUrl})` : ""} resolves through the HDR chain`
+                : `production bridge submitted the authored ${authoredEnvironment.environment} environment through generated HDR ${preset} lighting`,
+            ...(hdriUrl ? { hdriUrl } : {}),
+            ...(hdriReflectionUrl ? { hdriReflectionUrl } : {}),
+            ...(hdriRotation !== undefined ? { hdriRotation } : {}),
             lighting: {
                 ...bundle.lighting,
                 color: authoredEnvironment.color ? colorToLinearRgb(authoredEnvironment.color) : bundle.lighting.color,
@@ -7878,14 +8736,16 @@ function createProductionRuntimeEnvironment(snapshot) {
  * changed exactly zero pixels through `createAuraApp`. Returning `false` when no
  * fog node is authored keeps the unfogged path unchanged.
  */
-function createProductionRuntimeEnvironmentFog(snapshot) {
-    const fog = groups.flatten(snapshot.nodes).find((node) => node.kind === "effect" && node.effect === "fog");
+function createProductionRuntimeEnvironmentFog(snapshot, lights = [], renderWidth = 1280, renderHeight = 720) {
+    const nodes = groups.flatten(snapshot.nodes);
+    const volumetric = nodes.find((node) => node.kind === "effect" && node.effect === "volumetric-fog");
+    const fog = volumetric ?? nodes.find((node) => node.kind === "effect" && node.effect === "fog");
     if (!fog)
         return false;
     const density = clampNumber(fog.density ?? 0.12, 0, 1);
     const intensity = clampNumber(fog.intensity ?? 0.5, 0, 1);
     const color = colorToLinearRgb(fog.color ?? "#9fb7d9");
-    return {
+    const base = {
         // Exponential-squared reads as depth haze rather than a hard linear band, which
         // matches what the public helper documents.
         mode: "exponential-squared",
@@ -7895,10 +8755,53 @@ function createProductionRuntimeEnvironmentFog(snapshot) {
         density,
         maxOpacity: clampNumber(0.25 + intensity * 0.55, 0, 0.92)
     };
-}
-function createProductionRuntimePostprocess(snapshot) {
+    if (!volumetric)
+        return base;
+    // A5: the volumetric-fog node drives the GPU forward inscatter terms from
+    // the dominant collected light; quality "off" zeroes the forward term and
+    // keeps this exp2 base exactly.
+    const resolved = resolveVolumetricFog({
+        density: volumetric.density,
+        intensity: volumetric.intensity,
+        ...(volumetric.lightPosition ? { lightPosition: volumetric.lightPosition } : {}),
+        ...(volumetric.heightFalloff !== undefined ? { heightFalloff: volumetric.heightFalloff } : {}),
+        ...(volumetric.heightReference !== undefined ? { heightReference: volumetric.heightReference } : {}),
+        ...(volumetric.volumetricQuality ? { quality: volumetric.volumetricQuality } : {})
+    }, lights, renderWidth, renderHeight);
+    return {
+        ...base,
+        density: clampNumber(volumetric.density ?? 0.18, 0, 1),
+        volumetricIntensity: resolved.forward.volumetricIntensity,
+        ...(resolved.forward.volumetricLightDirection ? { volumetricLightDirection: resolved.forward.volumetricLightDirection } : {}),
+        volumetricLightColor: resolved.forward.volumetricLightColor,
+        ...(resolved.forward.heightFalloff !== undefined ? { heightFalloff: resolved.forward.heightFalloff } : {}),
+        ...(resolved.forward.heightReference !== undefined ? { heightReference: resolved.forward.heightReference } : {})
+    };
+}
+const productionTemporalSceneKeys = new WeakMap();
+let productionTemporalSceneSequence = 0;
+export function resolveNativeBloomRadius(authoredRadius) {
+    const radius = authoredRadius ?? 0.38;
+    const normalizedKernel = radius <= 1 ? Math.round(radius * 8) : Math.round(radius);
+    return Math.max(1, Math.min(4, normalizedKernel));
+}
+function createProductionRuntimePostprocess(snapshot, lights = [], renderWidth = 1280, renderHeight = 720, temporalSupported = true) {
     const nodes = groups.flatten(snapshot.nodes);
     const authoredBloom = nodes.find((node) => node.kind === "effect" && node.effect === "bloom");
+    // A5: the DISTINCT volumetric-fog node submits the depth-aware inscatter
+    // pass (renderer-owned depth attaches automatically); quality "off" (or no
+    // node) submits nothing and the scene keeps forward exp2 fog only.
+    const authoredVolumetricFog = nodes.find((node) => node.kind === "effect" && node.effect === "volumetric-fog");
+    const volumetricPass = authoredVolumetricFog
+        ? resolveVolumetricFog({
+            density: authoredVolumetricFog.density,
+            intensity: authoredVolumetricFog.intensity,
+            ...(authoredVolumetricFog.lightPosition ? { lightPosition: authoredVolumetricFog.lightPosition } : {}),
+            ...(authoredVolumetricFog.heightFalloff !== undefined ? { heightFalloff: authoredVolumetricFog.heightFalloff } : {}),
+            ...(authoredVolumetricFog.heightReference !== undefined ? { heightReference: authoredVolumetricFog.heightReference } : {}),
+            ...(authoredVolumetricFog.volumetricQuality ? { quality: authoredVolumetricFog.volumetricQuality } : {})
+        }, lights, renderWidth, renderHeight).pass
+        : null;
     const bloomRequested = Boolean(authoredBloom);
     // Root previously advertised `ssao` in `requestedPasses` whenever a scene added
     // effects.ambientOcclusion() or effects.contactOcclusion(), but never submitted
@@ -7908,15 +8811,45 @@ function createProductionRuntimePostprocess(snapshot) {
     const authoredAmbientOcclusion = nodes.find((node) => node.kind === "effect" && node.effect === "ambient-occlusion");
     const authoredContactOcclusion = nodes.find((node) => node.kind === "effect" && node.effect === "contact-occlusion");
     const authoredOcclusion = authoredAmbientOcclusion ?? authoredContactOcclusion;
+    // The renderer owns temporal GPU inputs. Root checks actual drawable
+    // geometry before requesting them; unsupported scenes retain ordinary output.
+    const authoredColorGrade = nodes.find((node) => node.kind === "effect" && node.effect === "color-grade");
+    const authoredAntiAlias = nodes.find((node) => node.kind === "effect" && node.effect === "anti-alias");
+    const authoredOutline = nodes.find((node) => node.kind === "effect" && node.effect === "outline");
+    const authoredSsr = nodes.find((node) => node.kind === "effect" && node.effect === "screen-space-reflections");
+    const authoredDof = nodes.find((node) => node.kind === "effect" && node.effect === "depth-of-field");
+    const authoredMotionBlur = nodes.find((node) => node.kind === "effect" && node.effect === "motion-blur");
+    const temporalRequested = temporalSupported && (Boolean(authoredMotionBlur) || authoredAntiAlias?.mode === "taa");
+    let sceneKey = productionTemporalSceneKeys.get(snapshot);
+    if (!sceneKey) {
+        sceneKey = `root-scene-${++productionTemporalSceneSequence}`;
+        productionTemporalSceneKeys.set(snapshot, sceneKey);
+    }
+    const fxaaRequested = (authoredAntiAlias?.mode ?? "fxaa") === "fxaa";
+    const outlineChannels = colorToRgba(authoredOutline?.color ?? "#ff9822");
     return {
         // Tone mapping requires unclamped linear input. RGBA8 quantized dark clear
         // colors and clipped highlights before ACES, which produced washed-out output.
         targetFormat: "rgba16f",
+        ...(temporalRequested ? {
+            temporal: { sceneKey },
+            ...(authoredMotionBlur ? { motionBlur: { samples: 8, scale: clampNumber(authoredMotionBlur.intensity ?? .5, 0, 2) } } : {}),
+            ...(authoredAntiAlias?.mode === "taa" ? { taa: { blend: .9 } } : {})
+        } : {}),
         ...(bloomRequested ? {
             bloom: {
                 threshold: clampNumber(authoredBloom?.threshold ?? 0.78, 0, 1),
                 intensity: clampNumber(authoredBloom?.intensity ?? 0.3, 0, 2),
-                radius: Math.max(1, Math.min(4, Math.round(authoredBloom?.radius ?? 2)))
+                // Public bloom radius follows the normalized UnrealBloomPass-style
+                // control used by routes and prefabs (normally 0..1), while the native
+                // separable blur consumes an integer pixel kernel. Preserve legacy
+                // explicit pixel kernels above 1 and spread normalized values across
+                // 1..4 so common authored values such as 0.22/0.38 do not all collapse
+                // to a one-pixel blur after rounding.
+                radius: resolveNativeBloomRadius(authoredBloom?.radius),
+                ...(authoredBloom?.quality !== undefined ? { quality: authoredBloom.quality } : {}),
+                ...(authoredBloom?.softKnee !== undefined ? { softKnee: authoredBloom.softKnee } : {}),
+                ...(authoredBloom?.shoulder !== undefined ? { shoulder: authoredBloom.shoulder } : {})
             }
         } : {}),
         ...(authoredOcclusion ? {
@@ -7937,7 +8870,41 @@ function createProductionRuntimePostprocess(snapshot) {
             operator: "aces",
             inputColorSpace: "linear",
             outputColorSpace: "srgb"
-        }
+        },
+        ...(authoredColorGrade ? {
+            colorGrade: {
+                contrast: clampNumber(authoredColorGrade.contrast ?? 1, 0, 3),
+                saturation: clampNumber(authoredColorGrade.saturation ?? 1, 0, 3)
+            }
+        } : {}),
+        ...(authoredOutline ? {
+            outline: {
+                color: [
+                    Math.round(outlineChannels[0] * 255),
+                    Math.round(outlineChannels[1] * 255),
+                    Math.round(outlineChannels[2] * 255),
+                    255
+                ],
+                width: Math.max(1, Math.min(6, Math.round(authoredOutline.width ?? 3))),
+                threshold: clampNumber(authoredOutline.threshold ?? 0.12, 0, 4),
+                opacity: clampNumber(authoredOutline.intensity ?? 0.9, 0, 1)
+            }
+        } : {}),
+        ...(fxaaRequested && authoredAntiAlias ? { fxaa: {} } : {}),
+        ...(authoredSsr ? {
+            ssr: {
+                intensity: clampNumber(authoredSsr.intensity ?? 0.9, 0, 2),
+                maxDistance: 18
+            }
+        } : {}),
+        ...(authoredDof ? {
+            depthOfField: {
+                focusDepth: clampNumber(authoredDof.focus ?? 0.02, 0, 1),
+                focusRange: clampNumber(0.02 + clampNumber(authoredDof.aperture ?? 0.35, 0, 1) * 0.3, 0.001, 1),
+                maxRadius: Math.max(0, Math.min(8, Math.round(authoredDof.maxBlur ?? 4)))
+            }
+        } : {}),
+        ...(volumetricPass ? { volumetricLight: volumetricPass } : {})
     };
 }
 function createProductionRuntimeShadowOptions(snapshot, collectedLights) {
@@ -7956,11 +8923,11 @@ function createProductionRuntimeShadowOptions(snapshot, collectedLights) {
     }, 1);
     const shadowCaster = collectedLights.find((light) => light.castsShadow);
     const size = sceneRadius > 30 ? 4096 : sceneRadius > 10 ? 2048 : 1024;
-    const texelWorldSize = (sceneRadius * 2) / size;
+    const tuning = resolveProductionRuntimeShadowTuning(shadowCaster?.kind, size, sceneRadius);
     return {
         enabled: Boolean(shadowCaster),
         size,
-        bias: clampNumber(texelWorldSize * 0.55, 0.00035, 0.004),
+        ...tuning,
         strength: category === "city-day" ? 0.38
             : category === "material" || category === "product" ? 0.24
                 : 0.32,
@@ -7970,6 +8937,30 @@ function createProductionRuntimeShadowOptions(snapshot, collectedLights) {
         label: `aura3d-root-production-${category}-${size}px-shadow-map`
     };
 }
+/**
+ * Shadow bias is compared in normalized light-depth space. Directional maps use
+ * an orthographic projection, so their existing scene-radius/texel heuristic is
+ * world-linear. A spot map is perspective: applying that world-space value at
+ * the far end of its cone erased legitimate caster/receiver separation (Aura
+ * Clash measured 0.00147 normalized depth versus the old 0.004 constant bias),
+ * and the default slope term could erase the remainder on a vertical receiver.
+ * Keep the established directional/point policy intact and use a bounded
+ * fraction of one normalized spot-map texel for both perspective terms.
+ */
+export function resolveProductionRuntimeShadowTuning(kind, size, sceneRadius) {
+    if (!Number.isInteger(size) || size <= 0)
+        throw new RangeError("Shadow-map size must be a positive integer.");
+    if (!Number.isFinite(sceneRadius) || sceneRadius <= 0)
+        throw new RangeError("Shadow scene radius must be finite and positive.");
+    if (kind === "spot") {
+        return {
+            bias: clampNumber(0.15 / size, 0.00005, 0.00035),
+            slopeBias: 0.12
+        };
+    }
+    const texelWorldSize = (sceneRadius * 2) / size;
+    return { bias: clampNumber(texelWorldSize * 0.55, 0.00035, 0.004) };
+}
 /**
  * Device-observed shadow state. `requested` comes from the submitted shadow
  * options, but `mapRendered`/`mapSampled` come only from what the device
@@ -7977,11 +8968,12 @@ function createProductionRuntimeShadowOptions(snapshot, collectedLights) {
  * sample it. This is what stops the root report from publishing an unconditional
  * `shadows.enabled: true`.
  */
-function createProductionRuntimeShadowObservation(shadowOptions, diagnostics) {
+function createProductionRuntimeShadowObservation(shadowOptions, diagnostics, observed) {
     const nativeShadowMapBindings = diagnostics.nativeShadowMapBindings ?? 0;
-    const mapRendered = Boolean(shadowOptions.enabled) && (diagnostics.shadowRenderTargetsAllocated ?? 0) > 0;
+    const mapRendered = Boolean(shadowOptions.enabled) && observed !== null && (diagnostics.shadowRenderTargetsAllocated ?? 0) > 0;
     return {
         requested: Boolean(shadowOptions.enabled),
+        observed,
         mapRendered,
         mapSampled: mapRendered && nativeShadowMapBindings > 0,
         mapSize: shadowOptions.size,
@@ -7990,6 +8982,79 @@ function createProductionRuntimeShadowObservation(shadowOptions, diagnostics) {
         shadowRenderTargetsAllocated: diagnostics.shadowRenderTargetsAllocated ?? 0
     };
 }
+/**
+ * G1 SDF text observation (muse3jsparity-PRD): per-resource fail-closed gate
+ * (`describeSdfTextPixelBacking`) ANDed across mounted SDF resources. Layout
+ * alone never backs pixels; lastOpacity is the live LOD x occlusion proof.
+ */
+function createProductionTextObservation(entries) {
+    const sdf = entries.flatMap((entry) => entry.resources.filter((resource) => resource.sdfText !== null));
+    if (sdf.length === 0) {
+        return {
+            sdfTexts: 0,
+            textPixelBacked: false,
+            quadCount: 0,
+            lastOpacity: 1,
+            reason: "no SDF text nodes mounted"
+        };
+    }
+    const gates = sdf.map((resource) => describeSdfTextPixelBacking({
+        atlasUploaded: resource.textureStatus === "textured" && resource.texturedMaterial !== null,
+        quadsSubmitted: resource.sdfText.lastSubmitted,
+        quadCount: resource.sdfText.quadCount
+    }));
+    const backed = gates.filter((gate) => gate.textPixelBacked).length;
+    const quadCount = sdf.reduce((total, resource) => total + (resource.sdfText?.quadCount ?? 0), 0);
+    const lastOpacity = Math.min(...sdf.map((resource) => resource.sdfText?.lastOpacity ?? 1));
+    return {
+        sdfTexts: sdf.length,
+        textPixelBacked: backed === sdf.length,
+        quadCount,
+        lastOpacity,
+        reason: backed === sdf.length
+            ? `${backed}/${sdf.length} SDF quad sets sampled from uploaded label textures (${quadCount} quads)`
+            : `${backed}/${sdf.length} SDF quad sets backed: ${gates.filter((gate) => !gate.textPixelBacked).map((gate) => gate.reason).join("; ")}`
+    };
+}
+/**
+ * M2 texture streaming observation (muse3jsparity-PRD): funds the
+ * post-upgrade texture table (SDF label images + C1 upgrades) against the
+ * budget with distance-prioritized residency. Empty table = nothing to fund.
+ */
+function createProductionTexturesObservation(entries, cameraEye, budgetBytes) {
+    const budget = normalizeTextureBudgetBytes(budgetBytes);
+    const table = entries.flatMap((entry, entryIndex) => entry.resources
+        .filter((resource) => resource.textureMipBytes.length > 0)
+        .map((resource, resourceIndex) => {
+        const position = entry.node.position ?? [0, 0, 0];
+        return {
+            id: `${entry.node.name ?? `primitive-${entryIndex}`}#${resourceIndex}`,
+            mipBytesCoarseToFine: resource.textureMipBytes,
+            distanceMeters: Math.hypot(cameraEye[0] - position[0], cameraEye[1] - position[1], cameraEye[2] - position[2])
+        };
+    }));
+    if (table.length === 0) {
+        return {
+            budgetBytes: budget,
+            usedBytes: 0,
+            requestedBytes: 0,
+            overBudget: false,
+            overBudgetBytes: 0,
+            residentEntries: 0,
+            evictedEntries: []
+        };
+    }
+    const residency = describeTextureStreamingResidency(table, budget);
+    return {
+        budgetBytes: budget,
+        usedBytes: residency.usedBytes,
+        requestedBytes: residency.requestedBytes,
+        overBudget: residency.overBudget,
+        overBudgetBytes: residency.overBudgetBytes,
+        residentEntries: residency.residents.filter((resident) => resident.residentLevels > 0).length,
+        evictedEntries: [...residency.evicted]
+    };
+}
 function createProductionRuntimePostprocessObservation(diagnostics) {
     const actualPasses = diagnostics.postprocessPassNames ?? [];
     const pixelBacked = actualPasses.length > 0 && diagnostics.lastError === null;
@@ -8002,7 +9067,8 @@ function createProductionRuntimePostprocessObservation(diagnostics) {
         pixelBacked,
         actualPasses,
         fallbackPasses: pixelBacked ? [] : ["direct-render"],
-        targetFormat: diagnostics.postprocessTargetFormat
+        targetFormat: diagnostics.postprocessTargetFormat,
+        executionMode: diagnostics.postprocessPlan?.executionMode ?? "unknown"
     };
 }
 function createProductionRuntimeCollectedLights(snapshot) {
@@ -8010,17 +9076,36 @@ function createProductionRuntimeCollectedLights(snapshot) {
     const descriptors = authoredLights.flatMap((node, index) => createProductionRuntimeLightDescriptors(node, index));
     if (descriptors.length === 0)
         return createProductionRuntimeFallbackLights();
-    const shadowCasterIndex = descriptors.reduce((selected, descriptor, index) => {
-        if (selected < 0)
-            return index;
-        const current = descriptors[selected];
-        if (descriptor.shadowPriority !== current.shadowPriority) {
-            return descriptor.shadowPriority > current.shadowPriority ? index : selected;
-        }
-        return descriptor.intensity > current.intensity ? index : selected;
-    }, -1);
+    const shadowCasterIndex = resolveProductionShadowCasterIndex(descriptors);
     return descriptors.map((descriptor, index) => createProductionRuntimeCollectedLight(descriptor, index === shadowCasterIndex));
 }
+/**
+ * N1 caster selection (pure, unit-tested): an explicit `shadow: true`
+ * request wins the single caster slot over unrequested lights; ties and
+ * all-unrequested scenes keep the legacy priority-then-intensity order.
+ */
+export function resolveProductionShadowCasterIndex(descriptors) {
+    const explicitlyRequested = descriptors
+        .map((descriptor, index) => ({ descriptor, index }))
+        .filter(({ descriptor }) => descriptor.shadowRequested);
+    // An authored false is scene-level opt-out when no light is explicitly
+    // requested. Otherwise another unspecified light would silently take the
+    // legacy caster slot and make `shadow: false` visually ineffective.
+    if (explicitlyRequested.length === 0 && descriptors.some((descriptor) => descriptor.shadowDisabled === true)) {
+        return -1;
+    }
+    const candidates = explicitlyRequested.length > 0
+        ? explicitlyRequested
+        : descriptors.map((descriptor, index) => ({ descriptor, index }));
+    return candidates.reduce((selected, candidate) => {
+        if (selected === undefined)
+            return candidate;
+        if (candidate.descriptor.shadowPriority !== selected.descriptor.shadowPriority) {
+            return candidate.descriptor.shadowPriority > selected.descriptor.shadowPriority ? candidate : selected;
+        }
+        return candidate.descriptor.intensity > selected.descriptor.intensity ? candidate : selected;
+    }, undefined)?.index ?? -1;
+}
 function createProductionRuntimeLightDescriptors(node, authoredIndex) {
     const name = node.name?.trim() || `aura-authored-${node.light}-${authoredIndex + 1}`;
     const color = colorToLinearRgb(node.color ?? "#ffffff");
@@ -8044,6 +9129,8 @@ function createProductionRuntimeLightDescriptors(node, authoredIndex) {
                 spotAngle: 0,
                 penumbra: 0,
                 shadowPriority: 3,
+                shadowRequested: node.shadow === true,
+                shadowDisabled: node.shadow === false,
                 authoredLight: node.light
             }];
     }
@@ -8059,12 +9146,34 @@ function createProductionRuntimeLightDescriptors(node, authoredIndex) {
                 spotAngle: 0,
                 penumbra: 0,
                 shadowPriority: 1,
+                shadowRequested: false,
                 authoredLight: node.light
             }];
     }
     if (node.light === "studio") {
         return createProductionRuntimeStudioLightDescriptors(node, name, color, intensity, position);
     }
+    if (node.light === "spot") {
+        // N1 (muse3jsparity-PRD): authored spot with an explicit cone. The aim
+        // target wins over lookAt; the direction feeds the B1 spot shadow path
+        // and the A5 volumetric dominant-light selection.
+        const spotTarget = node.target ?? node.lookAt ?? [0, 0.75, 0];
+        return [{
+                kind: "spot",
+                name,
+                color,
+                intensity,
+                position,
+                direction: normalize3([spotTarget[0] - position[0], spotTarget[1] - position[1], spotTarget[2] - position[2]]),
+                range: Math.max(1, node.distance ?? 12),
+                spotAngle: clampNumber(node.angle ?? Math.PI / 6, 0.08, Math.PI / 2 - 0.01),
+                penumbra: clampNumber(node.penumbra ?? 0.4, 0, 1),
+                shadowPriority: 2,
+                shadowRequested: node.shadow === true,
+                shadowDisabled: node.shadow === false,
+                authoredLight: node.light
+            }];
+    }
     const width = positiveFinite(node.width, node.light === "softbox" ? 2.4 : 2.2)
         * productionRuntimeLightAxisScale(node.scale, 0);
     const height = positiveFinite(node.height, node.light === "softbox" ? 1.6 : 1.2)
@@ -8083,6 +9192,7 @@ function createProductionRuntimeLightDescriptors(node, authoredIndex) {
             spotAngle: clampNumber(Math.atan2(halfDiagonal, targetDistance), 0.08, Math.PI / 2 - 0.01),
             penumbra: node.light === "softbox" ? 0.78 : 0.42,
             shadowPriority: 2,
+            shadowRequested: false,
             authoredLight: node.light,
             authoredWidth: width,
             authoredHeight: height
@@ -8112,6 +9222,7 @@ function createProductionRuntimeStudioLightDescriptors(node, name, color, intens
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 3,
+            shadowRequested: false,
             authoredLight: node.light
         },
         {
@@ -8125,6 +9236,7 @@ function createProductionRuntimeStudioLightDescriptors(node, name, color, intens
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: node.light
         },
         {
@@ -8138,6 +9250,7 @@ function createProductionRuntimeStudioLightDescriptors(node, name, color, intens
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: node.light
         }
     ];
@@ -8157,6 +9270,7 @@ function createProductionRuntimeFallbackLights() {
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 3,
+            shadowRequested: false,
             authoredLight: "fallback"
         },
         {
@@ -8170,6 +9284,7 @@ function createProductionRuntimeFallbackLights() {
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: "fallback"
         },
         {
@@ -8183,6 +9298,7 @@ function createProductionRuntimeFallbackLights() {
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: "fallback"
         }
     ];
@@ -8342,6 +9458,7 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
         height: canvas.height,
         backend: "webgl2",
         antialias: true,
+        ...(getRootRenderSource(canvas) ? { errorCheckMode: "frame" } : {}),
         preserveDrawingBuffer: true,
         // Background colors are display intent. Pre-invert the renderer's coupled
         // matrix-fitted ACES transform so presentation preserves that authored color.
@@ -8349,53 +9466,153 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
     });
     let latestDeviceDiagnostics = productionRenderer.getDiagnostics();
     let latestFeatures = productionRenderer.getFeatures();
+    // M2 streaming distances measure against the live camera eye; refreshed
+    // every render so residency follows the camera instead of mount intent.
+    let latestCameraEye = resolveCameraFrame(snapshot, snapshot.camera, 0, runtimeNodes).eye;
     const runtimeWarnings = new Set();
+    // C1 textured upgrade: fire-and-forget after mount. Scalar first frames stay
+    // fast; outcomes land in textureUpgradeWarnings, which render() never clears
+    // (per-frame runtimeWarnings are rebuilt every frame).
+    const textureUpgradeWarnings = new Set();
+    void upgradeProductionPrimitiveTextures(primitiveEntries, (message) => {
+        textureUpgradeWarnings.add(message);
+    }, Number(canvas.getContext("webgl2")?.getParameter(WebGL2RenderingContext.MAX_TEXTURE_SIZE) ?? 4096)).catch((error) => {
+        textureUpgradeWarnings.add(`textured upgrade pass failed (${error instanceof Error ? error.message : String(error)}); scalar materials retained`);
+    });
     const productionEnvironment = createProductionRuntimeEnvironment(snapshot);
+    // B3 HDRI upgrade: fire-and-forget after mount. First frames render the
+    // studio procedural fallback; the HDR chain swaps the lighting object the
+    // render closure reads every frame. Outcomes land in hdriWarnings, which
+    // render() never clears (per-frame runtimeWarnings are rebuilt every frame).
+    let currentEnvironmentLighting = productionEnvironment.lighting;
+    const hdriWarnings = new Set();
+    const hdriState = { status: productionEnvironment.hdriUrl ? "pending" : "none" };
+    let disposeHdriEnvironment = null;
+    if (flattened.some((node) => node.kind === "environment" && node.environment === "hdri" && node.texture?.kind !== "aura-asset-ref")) {
+        hdriWarnings.add("hdri environment has no texture asset ref; studio procedural fallback retained");
+    }
+    if (productionEnvironment.hdriUrl) {
+        const hdriUrl = productionEnvironment.hdriUrl;
+        const hdriReflectionUrl = productionEnvironment.hdriReflectionUrl;
+        const hdriIntensity = productionEnvironment.intensity;
+        const hdriRotation = productionEnvironment.hdriRotation;
+        void upgradeProductionEnvironmentHdri(hdriUrl, hdriIntensity, hdriReflectionUrl, hdriRotation)
+            .then((result) => {
+            disposeHdriEnvironment?.();
+            disposeHdriEnvironment = result.dispose;
+            currentEnvironmentLighting = result.lighting;
+            hdriState.status = "ready";
+            hdriState.maxLinearValue = result.maxLinearValue;
+            hdriState.specularMipCount = result.specularMipCount;
+            hdriState.dualProbe = result.dualProbe;
+        })
+            .catch((error) => {
+            hdriState.status = "fallback";
+            hdriWarnings.add(`HDRI upgrade failed for ${hdriUrl} (${error instanceof Error ? error.message : String(error)}); studio procedural fallback retained`);
+        });
+    }
     const productionRuntimeLights = createProductionRuntimeCollectedLights(snapshot);
     const authoredLightNodes = flattened.filter((node) => node.kind === "light");
     const authoredDirectLightNodes = authoredLightNodes.filter((node) => node.light !== "ambient");
     const authoredAmbientLightCount = authoredLightNodes.length - authoredDirectLightNodes.length;
     const authoredAreaProxyCount = authoredDirectLightNodes.filter((node) => node.light === "rect" || node.light === "softbox").length;
-    const buildDiagnostics = () => createRendererDiagnosticReport(snapshot, {
-        mounted: true,
-        backend: "production-runtime",
-        postprocess: createProductionRuntimePostprocessObservation(latestDeviceDiagnostics),
-        shadow: createProductionRuntimeShadowObservation(createProductionRuntimeShadowOptions(snapshot, productionRuntimeLights), latestDeviceDiagnostics),
-        environment: {
-            enabled: true,
-            preset: productionEnvironment.preset,
-            intensity: productionEnvironment.intensity,
-            evidence: productionEnvironment.evidence
-        },
-        warnings: [
-            `Production runtime bridge active with ${actorEntries.length} typed GLB actor${actorEntries.length === 1 ? "" : "s"} and ${primitiveEntries.length} Aura primitive${primitiveEntries.length === 1 ? "" : "s"} on ${productionRenderer.backend}.`,
-            ...(authoredDirectLightNodes.length === 0
-                ? ["Production runtime direct-light fallback active: the scene has no authored directional, point, studio, rect, or softbox light."]
-                : [`Production runtime derived ${productionRuntimeLights.length} collected direct light${productionRuntimeLights.length === 1 ? "" : "s"} from ${authoredDirectLightNodes.length} authored scene light${authoredDirectLightNodes.length === 1 ? "" : "s"}.`]),
-            ...(authoredAmbientLightCount > 0
-                ? [`${authoredAmbientLightCount} authored ambient light${authoredAmbientLightCount === 1 ? "" : "s"} remain environment-lighting intent and are not mislabeled as direct CollectedLight entries.`]
-                : []),
-            ...(authoredAreaProxyCount > 0
-                ? [`${authoredAreaProxyCount} authored rect/softbox light${authoredAreaProxyCount === 1 ? "" : "s"} use bounded spot-light proxies whose cone and range derive from authored width and height; this does not claim physical area-light shading.`]
-                : []),
-            ...(flattened.some((node) => node.kind === "effect")
-                ? ["Effect nodes are requested in the scene graph; production bridge diagnostics report them, but unsupported postprocess/effect passes remain non-pixel-backed until the runtime feature reports support."]
-                : []),
-            ...(productionRenderer.backendSelection.fallback ? [`Production runtime backend fallback: ${productionRenderer.backendSelection.reason}`] : []),
-            ...latestFeatures
-                .filter((feature) => feature.state !== "supported")
-                .map((feature) => `Production runtime feature ${feature.id} is ${feature.state}: ${feature.detail}`),
-            ...runtimeWarnings
-        ],
-        deviceDiagnostics: latestDeviceDiagnostics,
-        lodSelections: primitiveEntries
-            .filter((entry) => Boolean(entry.node.lod?.levels.length))
-            .map((entry) => ({
-            nodeName: entry.node.name ?? "unnamed distance LOD",
-            levelIndex: entry.currentLodIndex,
-            levelName: entry.resources[entry.currentLodIndex]?.name ?? `level-${entry.currentLodIndex}`
-        }))
-    }, rendererOptions);
+    // N1 + G1 + M2 observations refresh on every diagnostics read from the
+    // live entries/device state — never cached intent.
+    const buildDiagnostics = () => {
+        const shadowObservation = createProductionRuntimeShadowObservation({ ...createProductionRuntimeShadowOptions(snapshot, productionRuntimeLights), ...(getRootPerformanceQuality(canvas) ? { size: getRootPerformanceQuality(canvas).shadowSize } : {}) }, latestDeviceDiagnostics, productionRenderer.getShadowEvidence());
+        const spotCaster = productionRuntimeLights.find((light) => light.castsShadow);
+        const spotAngle = spotCaster?.kind === "spot" ? spotCaster.spotAngle : undefined;
+        const texturesObservation = createProductionTexturesObservation(primitiveEntries, latestCameraEye, rendererOptions?.textureBudgetBytes ?? normalizeTextureBudgetBytes(undefined));
+        const streamingWarnings = texturesObservation.overBudget
+            ? [`texture streaming over budget by ${texturesObservation.overBudgetBytes} bytes `
+                    + `(${texturesObservation.residentEntries} resident, `
+                    + `${texturesObservation.evictedEntries.length} evicted: ${texturesObservation.evictedEntries.join(", ") || "none"}); `
+                    + `raise renderer.textureBudgetBytes above ${texturesObservation.requestedBytes} bytes or move textures closer`]
+            : [];
+        return createRendererDiagnosticReport(snapshot, {
+            mounted: true,
+            backend: "production-runtime",
+            postprocess: createProductionRuntimePostprocessObservation(latestDeviceDiagnostics),
+            shadow: {
+                ...shadowObservation,
+                spot: describeProductionSpotShadow({
+                    requested: flattened.some((node) => node.kind === "light" && node.light === "spot" && node.shadow === true),
+                    casterIsSpot: spotCaster?.kind === "spot",
+                    ...(spotCaster === undefined ? {} : { casterName: spotCaster.source.name }),
+                    ...(spotAngle === undefined ? {} : { angle: spotAngle }),
+                    ...(spotCaster?.kind === "spot" ? { penumbra: spotCaster.penumbra, range: spotCaster.range } : {}),
+                    mapRendered: shadowObservation.mapRendered,
+                    mapSampled: shadowObservation.mapSampled
+                })
+            },
+            text: createProductionTextObservation(primitiveEntries),
+            textures: texturesObservation,
+            environment: {
+                enabled: true,
+                preset: productionEnvironment.preset,
+                intensity: productionEnvironment.intensity,
+                evidence: hdriState.status === "ready"
+                    ? `${productionEnvironment.evidence} — HDRI chain ready${hdriState.dualProbe ? " (dual-probe: illumination diffuse + reflection specular)" : " (single probe)"} (maxLinear ${hdriState.maxLinearValue}, ${hdriState.specularMipCount} specular mips)`
+                    : productionEnvironment.evidence,
+                // B3 iblPixelBacked: true only after the HDR chain swaps the live
+                // lighting object. Procedural first frames and fallbacks never claim it.
+                iblPixelBacked: hdriState.status === "ready",
+                hdriStatus: hdriState.status,
+                ...(hdriState.dualProbe === undefined ? {} : { dualProbe: hdriState.dualProbe }),
+                ...(productionEnvironment.hdriRotation === undefined ? {} : { hdriRotation: productionEnvironment.hdriRotation })
+            },
+            warnings: [
+                `Production runtime bridge active with ${actorEntries.length} typed GLB actor${actorEntries.length === 1 ? "" : "s"} and ${primitiveEntries.length} Aura primitive${primitiveEntries.length === 1 ? "" : "s"} on ${productionRenderer.backend}.`,
+                ...(authoredDirectLightNodes.length === 0
+                    ? ["Production runtime direct-light fallback active: the scene has no authored directional, point, studio, rect, or softbox light."]
+                    : [`Production runtime derived ${productionRuntimeLights.length} collected direct light${productionRuntimeLights.length === 1 ? "" : "s"} from ${authoredDirectLightNodes.length} authored scene light${authoredDirectLightNodes.length === 1 ? "" : "s"}.`]),
+                ...(authoredAmbientLightCount > 0
+                    ? [`${authoredAmbientLightCount} authored ambient light${authoredAmbientLightCount === 1 ? "" : "s"} remain environment-lighting intent and are not mislabeled as direct CollectedLight entries.`]
+                    : []),
+                ...(authoredAreaProxyCount > 0
+                    ? [`${authoredAreaProxyCount} authored rect/softbox light${authoredAreaProxyCount === 1 ? "" : "s"} use bounded spot-light proxies whose cone and range derive from authored width and height; this does not claim physical area-light shading.`]
+                    : []),
+                ...(flattened.some((node) => node.kind === "effect")
+                    ? ["Effect nodes are requested in the scene graph; production bridge diagnostics report them, but unsupported postprocess/effect passes remain non-pixel-backed until the runtime feature reports support."]
+                    : []),
+                ...(productionRenderer.backendSelection.fallback ? [`Production runtime backend fallback: ${productionRenderer.backendSelection.reason}`] : []),
+                ...latestFeatures
+                    .filter((feature) => feature.state !== "supported")
+                    .map((feature) => `Production runtime feature ${feature.id} is ${feature.state}: ${feature.detail}`),
+                ...runtimeWarnings,
+                ...textureUpgradeWarnings,
+                ...streamingWarnings,
+                ...hdriWarnings
+            ],
+            deviceDiagnostics: latestDeviceDiagnostics,
+            lodSelections: primitiveEntries
+                .filter((entry) => Boolean(entry.node.lod?.levels.length))
+                .map((entry) => ({
+                nodeName: entry.node.name ?? "unnamed distance LOD",
+                levelIndex: entry.currentLodIndex,
+                levelName: entry.resources[entry.currentLodIndex]?.name ?? `level-${entry.currentLodIndex}`
+            })),
+            texturedMaterials: primitiveEntries.flatMap((entry) => entry.resources.map((resource) => ({
+                nodeName: entry.node.name ?? `aura-primitive-${entry.node.primitive}`,
+                levelName: resource.name,
+                status: resource.textureStatus,
+                slots: resource.textureSlots,
+                pixelBacked: resource.textureStatus === "textured" && resource.texturedMaterial !== null,
+                warnings: resource.textureWarnings
+            })))
+        }, rendererOptions);
+    };
+    let preparedFrame;
+    const buildFrame = (time) => {
+        runtimeWarnings.clear();
+        latestCameraEye = resolveCameraFrame(snapshot, snapshot.camera, time, runtimeNodes).eye;
+        return createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, primitiveEntries, time, runtimeNodes, runtimeWarnings, currentEnvironmentLighting, productionRuntimeLights);
+    };
+    const takePreparedFrame = (time) => {
+        const prepared = preparedFrame?.time === time ? preparedFrame.input : undefined;
+        preparedFrame = undefined;
+        return prepared ?? buildFrame(time);
+    };
     return {
         get backend() {
             return productionRenderer.backend;
@@ -8403,17 +9620,34 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
         get diagnostics() {
             return buildDiagnostics();
         },
+        update(time) {
+            // Building the frame applies controller-bound actor clips, root-motion
+            // consumption, foot IK, morphs and imported-asset evidence. Discarding the
+            // returned input deliberately avoids a GPU/device submission.
+            preparedFrame = { time, input: buildFrame(time) };
+        },
         render(time) {
-            runtimeWarnings.clear();
-            const input = createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, primitiveEntries, time, runtimeNodes, runtimeWarnings, productionEnvironment.lighting, productionRuntimeLights);
+            const input = takePreparedFrame(time);
             const result = productionRenderer.renderInteractiveFrame(input);
             latestDeviceDiagnostics = result.diagnostics;
+            getRootRenderSource(canvas)?.onFrame?.(latestDeviceDiagnostics, [...(input.source.collectRenderItems?.() ?? [])]);
+            latestFeatures = result.features;
+            return latestDeviceDiagnostics.drawCalls;
+        },
+        async renderAsync(time) {
+            const input = takePreparedFrame(time);
+            const result = await productionRenderer.renderInteractiveFrameAsync(input);
+            latestDeviceDiagnostics = result.diagnostics;
+            getRootRenderSource(canvas)?.onFrame?.(latestDeviceDiagnostics, [...(input.source.collectRenderItems?.() ?? [])]);
             latestFeatures = result.features;
             return latestDeviceDiagnostics.drawCalls;
         },
         viewProjection(time) {
             return createViewProjection(snapshot, canvas.width / Math.max(1, canvas.height), time, runtimeNodes);
         },
+        resetTemporalHistory(reason) {
+            productionRenderer.resetTemporalHistory(reason);
+        },
         resize(width, height) {
             productionRenderer.resize(width, height);
         },
@@ -8427,69 +9661,185 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
             return productionRenderer.deviceLost();
         },
         dispose() {
+            disposeHdriEnvironment?.();
             productionRenderer.dispose();
             for (const { actor } of actorEntries)
                 actor.dispose();
             for (const { resources } of primitiveEntries) {
-                for (const { geometry, material } of resources) {
+                for (const { geometry, material, texturedMaterial, textureDisposer } of resources) {
+                    textureDisposer?.();
                     geometry.dispose();
                     material.dispose();
+                    texturedMaterial?.dispose();
                 }
             }
         }
     };
 }
 function createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, primitiveEntries, time, runtimeNodes, runtimeWarnings, environmentLighting, collectedLights) {
-    const items = [];
+    const compatibility = getRootRenderSource(canvas);
+    const attachedItems = compatibility ? [...(compatibility.source.collectRenderItems?.() ?? compatibility.source.renderItems ?? [])] : [];
+    const items = [...attachedItems];
     const viewProjectionMatrix = createViewProjection(snapshot, canvas.width / Math.max(1, canvas.height), time, runtimeNodes);
     const cameraPosition = resolveCameraFrame(snapshot, snapshot.camera, time, runtimeNodes).eye;
-    for (const entry of actorEntries) {
-        const currentState = resolveProductionActorRuntimeState(entry, runtimeNodes);
-        const currentNode = currentState.node;
+    for (const [actorIndex, entry] of actorEntries.entries()) {
+        let currentState = resolveProductionActorRuntimeState(entry, runtimeNodes);
+        let currentNode = currentState.node;
         if (currentNode.visible === false)
             continue;
-        applyProductionActorAnimation(entry, currentNode, currentState.animationBinding, time, runtimeWarnings);
+        let modelMatrix = [...createModelMatrix(currentNode, productionActorModelBounds(currentNode.asset, entry.actor), shouldNormalizeModelNode(currentNode), time)];
+        // The foot-planting post-pass solves in the same world space this matrix draws into;
+        // refresh its matrix before the clip plays so the solve uses this frame, not the last.
+        applyProductionActorFootPlanting(entry, currentState.animationBinding, modelMatrix, runtimeWarnings);
+        if (currentState.animationPose) {
+            try {
+                entry.actor.applyRetargetedPose(currentState.animationPose, currentState.animationPoseTime ?? time);
+                entry.rootMotionCursors = undefined;
+            }
+            catch (error) {
+                runtimeWarnings.add(`Typed GLB actor "${entry.actor.id}" failed to apply bound pose: ${productionRenderErrorMessage(error)}`);
+            }
+        }
+        else
+            applyProductionActorAnimation(entry, currentNode, currentState.animationBinding, time, runtimeWarnings, modelMatrix, () => {
+                currentState = resolveProductionActorRuntimeState(entry, runtimeNodes);
+                currentNode = currentState.node;
+                modelMatrix = [...createModelMatrix(currentNode, productionActorModelBounds(currentNode.asset, entry.actor), shouldNormalizeModelNode(currentNode), time)];
+                applyProductionActorFootPlanting(entry, currentState.animationBinding, modelMatrix, runtimeWarnings);
+            });
         applyProductionActorMorphTargets(entry, currentState.morphTargets, runtimeWarnings);
-        const modelMatrix = [...createModelMatrix(currentNode, productionActorModelBounds(currentNode.asset, entry.actor), shouldNormalizeModelNode(currentNode), time)];
-        const actorItems = entry.actor.collectRenderItems({ modelMatrix });
-        items.push(...actorItems.map((item) => ({ ...item, castShadow: currentNode.castShadow })));
+        // Wrinkle detail (E1 face-rig demo): resolve morph weights through the model's hook.
+        // Absent hook (or empty weights) resolves to 0 = today's rendering exactly.
+        const wrinkleStrength = currentNode.wrinkle
+            ? resolveWrinkleMapStrength(currentState.morphTargets ?? {}, currentNode.wrinkle)
+            : undefined;
+        const actorItems = entry.actor.collectRenderItems({
+            modelMatrix,
+            ...(wrinkleStrength === undefined ? {} : { wrinkleStrength })
+        });
+        // P2 (muse3jsparity-PRD): model instances attach exactly like primitive
+        // nodes. Skinned actors cannot instance (D1 matrix) — warn once and draw
+        // single instead of silently dropping copies.
+        const modelInstances = currentNode.instances;
+        let modelInstanceAttach = {};
+        if (modelInstances && modelInstances.length > 0) {
+            if (actorItems.some((item) => item.skinning)) {
+                warnOnInstancingFallback({
+                    material: currentNode.name ?? currentNode.asset.id,
+                    requestedInstances: modelInstances.length,
+                    drawnBatches: Math.max(1, actorItems.length),
+                    reason: "skinned-palette-overflow-cpu-fallback",
+                    onWarning: (message) => runtimeWarnings.add(message)
+                });
+            }
+            else {
+                modelInstanceAttach = {
+                    instanceTransforms: createProductionModelInstanceTransforms(modelInstances, currentNode, productionActorModelBounds(currentNode.asset, entry.actor), time),
+                    ...(currentNode.instanceColors
+                        ? { instanceColors: createProductionInstanceColors(currentNode.instanceColors, modelInstances.length) }
+                        : {})
+                };
+            }
+        }
+        if (currentNode.instancedModelWarning)
+            runtimeWarnings.add(currentNode.instancedModelWarning);
+        // A GLB mesh has its own authored local/world transform. Native instance
+        // transforms must apply the complete normalized node placement BEFORE that
+        // mesh transform, exactly like an individually mounted actor. The previous
+        // base(actorRoot * mesh) * instance(actorRoot) order normalized twice and
+        // rotated/scaled the instance translations in the mesh's coordinate system.
+        const localActorItems = modelInstanceAttach.instanceTransforms
+            ? entry.actor.collectRenderItems({ modelMatrix: identityMat4(), ...(wrinkleStrength === undefined ? {} : { wrinkleStrength }) })
+            : undefined;
+        items.push(...actorItems.map((item, itemIndex) => {
+            const nativeMatrices = modelInstanceAttach.instanceTransforms;
+            const localItem = localActorItems?.[itemIndex];
+            if (nativeMatrices && !localItem)
+                throw new Error("Instanced GLB mesh collection changed within one frame");
+            return { ...item, label: `actor-${actorIndex}:mesh-${itemIndex}:${item.label ?? "mesh"}`, castShadow: currentNode.castShadow, ...modelInstanceAttach,
+                ...(nativeMatrices && localItem ? {
+                    modelMatrix: identityMat4(),
+                    instanceTransforms: composeModelInstanceMatrices(nativeMatrices, localItem.modelMatrix ?? identityMat4())
+                } : {}) };
+        }));
         attachProductionActorEvidence(currentNode, entry.actor, actorItems, runtimeNodes);
     }
-    for (const entry of primitiveEntries) {
+    // G1 SDF occlusion test, built once per frame only when SDF quads exist
+    // (same cost argument as WS-2.7: one bbox per node, negligible beside render).
+    const sdfEntries = primitiveEntries.filter((entry) => entry.resources.some((resource) => resource.sdfText !== null));
+    const sdfOcclusionTest = sdfEntries.length > 0
+        ? createSceneLabelOcclusionTest(snapshot, cameraPosition, runtimeNodes)
+        : undefined;
+    for (const [primitiveIndex, entry] of primitiveEntries.entries()) {
         const currentState = resolveProductionPrimitiveRuntimeState(entry, runtimeNodes);
         if (!currentState.visible)
             continue;
-        const resource = selectProductionPrimitiveResource(entry, currentState.node, cameraPosition);
+        const resource = selectProductionPrimitiveResource(entry, currentState.node, cameraPosition, getRootPerformanceQuality(canvas)?.lodBias ?? 1);
+        if (resource.sdfText && resource.texturedMaterial) {
+            // G1 per-frame SDF opacity: LOD fade from the live camera distance
+            // times the scene occlusion policy, written to the quad material.
+            // Occlusion "hide" skips submission (no pixels, no backing claim).
+            const position = currentState.node.position ?? [0, 0, 0];
+            const distance = Math.hypot(cameraPosition[0] - position[0], cameraPosition[1] - position[1], cameraPosition[2] - position[2]);
+            const frame = resolveSdfTextFrameOpacity({
+                distance,
+                ...(resource.sdfText.lodFadeNear === undefined ? {} : { lodFadeNear: resource.sdfText.lodFadeNear }),
+                ...(resource.sdfText.lodFadeFar === undefined ? {} : { lodFadeFar: resource.sdfText.lodFadeFar }),
+                occluded: sdfOcclusionTest?.(position) ?? false,
+                occlusionPolicy: resource.sdfText.occlusionPolicy
+            });
+            resource.sdfText.lastOpacity = frame.opacity;
+            resource.sdfText.lastVisible = frame.visible;
+            resource.sdfText.lastSubmitted = frame.visible;
+            if (!frame.visible)
+                continue;
+            const base = resource.texturedMaterial.getParameter("baseColor");
+            const rgb = Array.isArray(base) && base.length >= 3
+                ? [base[0] ?? 1, base[1] ?? 1, base[2] ?? 1]
+                : [1, 1, 1];
+            resource.texturedMaterial.setParameter("baseColor", [rgb[0], rgb[1], rgb[2], frame.opacity]);
+        }
         items.push({
             geometry: resource.geometry,
-            material: resource.material,
+            material: resource.texturedMaterial ?? resource.material,
             modelMatrix: createModelMatrix(currentState.node, resource.bounds, false, time),
-            label: currentState.node.name ?? `aura-primitive-${currentState.node.primitive}`,
+            label: `primitive-${primitiveIndex}:${resource.name}:${currentState.node.name ?? currentState.node.primitive}`,
             castShadow: currentState.node.castShadow,
             includeInAutoFrame: false,
             ...(currentState.node.instances ? { instanceTransforms: createProductionInstanceTransforms(currentState.node.instances, currentState.node), instanceColors: createProductionInstanceColors(currentState.node.instanceColors, currentState.node.instances.length) } : {})
         });
     }
+    const unsupportedTemporal = items.find(item => {
+        const base = item.material && "baseMaterial" in item.material ? item.material.baseMaterial : item.material;
+        return Boolean(item.skinning || item.morphTargets?.length || item.instanceTransforms?.length || item.geometry.topology !== "triangles" || base?.renderState.blend);
+    });
+    const temporalRequested = groups.flatten(snapshot.nodes).some(node => node.kind === "effect" && (node.effect === "motion-blur" || (node.effect === "anti-alias" && node.mode === "taa")));
+    for (const warning of runtimeWarnings)
+        if (warning.startsWith("TEMPORAL_UNSUPPORTED_GEOMETRY:"))
+            runtimeWarnings.delete(warning);
+    if (temporalRequested && unsupportedTemporal)
+        runtimeWarnings.add(`TEMPORAL_UNSUPPORTED_GEOMETRY: ${unsupportedTemporal.label}; requires opaque rigid noninstanced triangles`);
     const source = {
+        ...(compatibility?.source ?? {}),
         collectRenderItems: () => items,
-        cameraPolicy: "require",
-        staticBatching: true,
+        cameraPolicy: compatibility?.source.cameraPolicy ?? "require",
+        staticBatching: !temporalRequested,
         frustumCulling: true,
-        collectedLights,
-        environmentLighting,
+        collectedLights: [...collectedLights, ...(compatibility?.source.collectedLights ?? [])],
+        environmentLighting: compatibility?.source.environmentLighting ?? environmentLighting,
         // The production runtime owns the pixel-backed HDR target and pass chain for
         // routes that request effects. The diagnostics are device-observed, so a
         // compositor failure is reported as fallback rather than claimed as a pass.
-        postprocess: createProductionRuntimePostprocess(snapshot),
-        shadow: createProductionRuntimeShadowOptions(snapshot, collectedLights),
-        environmentFog: createProductionRuntimeEnvironmentFog(snapshot),
-        cameraPosition
+        postprocess: compatibility?.source.postprocess ?? createProductionRuntimePostprocess(snapshot, collectedLights, canvas.width, canvas.height, !unsupportedTemporal),
+        shadow: { ...createProductionRuntimeShadowOptions(snapshot, collectedLights), ...(getRootPerformanceQuality(canvas) ? { size: getRootPerformanceQuality(canvas).shadowSize } : {}) },
+        environmentFog: compatibility?.source.environmentFog ?? createProductionRuntimeEnvironmentFog(snapshot, collectedLights, canvas.width, canvas.height),
+        ...(compatibility?.source.cameraPolicy === "auto-frame" ? {} : { cameraPosition })
     };
     const cameraLike = { viewProjectionMatrix };
     return {
         source,
-        camera: cameraLike,
-        metadata: createProductionRuntimeMetadata(actorEntries, primitiveEntries)
+        ...(compatibility?.source.cameraPolicy === "auto-frame" ? {} : { camera: cameraLike }),
+        metadata: includeRootSourceMetadata(createProductionRuntimeMetadata(actorEntries, primitiveEntries), attachedItems)
     };
 }
 function createProductionRuntimePrimitiveEntries(nodes) {
@@ -8497,10 +9847,610 @@ function createProductionRuntimePrimitiveEntries(nodes) {
         .filter((node) => node.kind === "primitive")
         .map((node) => ({ node, resources: createProductionPrimitiveResources(node), currentLodIndex: 0 }));
 }
+function blankProductionPrimitiveTextureState() {
+    return { texturedMaterial: null, textureStatus: "none", textureSlots: [], textureWarnings: [], sdfText: null, textureBytes: 0, textureMipBytes: [] };
+}
+/**
+ * C1 texture intent classification (pure, unit-tested). Asset refs resolve to
+ * fetchable urls; procedural inputs have no rasterizer and are reported so
+ * the caller can warn instead of silently dropping them.
+ */
+const ROOT_EXTENSION_TEXTURE_SLOTS = ["clearcoat", "clearcoatRoughness", "clearcoatNormal", "sheenColor", "sheenRoughness", "iridescence", "iridescenceThickness", "anisotropy"];
+export function createProductionPrimitiveTextureIntent(materialSpec) {
+    const refUrl = (input) => input && typeof input === "object" && input.kind === "aura-asset-ref"
+        ? input.url ?? undefined
+        : undefined;
+    const procedurals = [];
+    const noteProcedural = (slot, input) => {
+        if (input && typeof input === "object" && input.kind === "aura-procedural-texture") {
+            procedurals.push(`${slot}:${input.texture}`);
+        }
+    };
+    noteProcedural("normal", materialSpec?.normal);
+    noteProcedural("roughnessMap", materialSpec?.roughnessMap);
+    noteProcedural("metalnessMap", materialSpec?.metalnessMap);
+    noteProcedural("occlusionMap", materialSpec?.occlusionMap);
+    noteProcedural("emissiveMap", materialSpec?.emissiveMap);
+    const baseColorUrl = refUrl(materialSpec?.texture);
+    const normalUrl = refUrl(materialSpec?.normal);
+    const roughnessUrl = refUrl(materialSpec?.roughnessMap);
+    const metalnessUrl = refUrl(materialSpec?.metalnessMap);
+    const occlusionUrl = refUrl(materialSpec?.occlusionMap);
+    const emissiveUrl = refUrl(materialSpec?.emissiveMap);
+    const extensionMaps = Object.fromEntries(ROOT_EXTENSION_TEXTURE_SLOTS.flatMap((slot) => {
+        const input = materialSpec?.[`${slot}Map`];
+        if (input === undefined)
+            return [];
+        if (!input || typeof input !== "object" || input.kind !== "aura-asset-ref" || input.type !== "texture") {
+            throw new AuraRuntimeError("unsupported-texture", `${slot}Map requires a typed texture asset reference`);
+        }
+        if (!["png", "jpg", "jpeg", "webp"].includes(input.format) || !input.url) {
+            throw new AuraRuntimeError("unsupported-texture", `${slot}Map requires a fetchable png, jpg, jpeg or webp texture`);
+        }
+        const texCoord = materialSpec?.texCoords?.[slot] ?? 0;
+        if (texCoord !== 0 && texCoord !== 1)
+            throw new RangeError(`${slot} texCoord must be 0 or 1`);
+        const transform = materialSpec?.texTransforms?.[slot];
+        if (transform && [...(transform.offset ?? [0, 0]), ...(transform.scale ?? [1, 1]), transform.rotation ?? 0].some((value) => !Number.isFinite(value))) {
+            throw new RangeError(`${slot} texture transform must contain finite values`);
+        }
+        return [[slot, { url: input.url, colorSpace: slot === "sheenColor" ? "srgb" : "linear", texCoord, ...(transform ? { transform } : {}) }]];
+    }));
+    return {
+        ...(baseColorUrl ? { baseColorUrl } : {}),
+        ...(normalUrl ? { normalUrl } : {}),
+        ...(roughnessUrl ? { roughnessUrl } : {}),
+        ...(metalnessUrl ? { metalnessUrl } : {}),
+        ...(occlusionUrl ? { occlusionUrl } : {}),
+        ...(emissiveUrl ? { emissiveUrl } : {}),
+        ...(Object.keys(extensionMaps).length ? { extensionMaps } : {}),
+        proceduralInputs: procedurals
+    };
+}
+/**
+ * C1 metallic-roughness compositing (pure, unit-tested). glTF convention:
+ * R = occlusion (unused here, forced to 255), G = roughness, B = metallic.
+ * Missing channels fall back to the scalar spec values.
+ */
+const productionPrimitiveBitmapPixels = new WeakMap();
+async function loadProductionPrimitiveBitmap(url) {
+    if (typeof fetch !== "function" || typeof createImageBitmap !== "function") {
+        throw new Error("texture fetch requires fetch + createImageBitmap (browser production mount)");
+    }
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`texture fetch failed with status ${response.status} for ${url}`);
+    const blob = await response.blob();
+    const bitmap = await createImageBitmap(blob, { premultiplyAlpha: "none", colorSpaceConversion: "none" });
+    try {
+        const { decodePngTexturePixels } = await import("./PngTexturePixels.js");
+        const pixels = await decodePngTexturePixels(new Uint8Array(await blob.arrayBuffer()));
+        if (pixels)
+            productionPrimitiveBitmapPixels.set(bitmap, pixels);
+        return bitmap;
+    }
+    catch (error) {
+        bitmap.close();
+        throw error;
+    }
+}
+function bitmapRgbaPixels(bitmap) {
+    const decoded = productionPrimitiveBitmapPixels.get(bitmap);
+    if (decoded)
+        return decoded;
+    if (typeof document === "undefined")
+        throw new Error("texture compositing requires a DOM canvas");
+    const canvas = document.createElement("canvas");
+    canvas.width = bitmap.width;
+    canvas.height = bitmap.height;
+    const context = canvas.getContext("2d", { willReadFrequently: true });
+    if (!context)
+        throw new Error("2d canvas unavailable for texture compositing");
+    context.drawImage(bitmap, 0, 0);
+    const image = context.getImageData(0, 0, bitmap.width, bitmap.height);
+    return { width: bitmap.width, height: bitmap.height, data: new Uint8Array(image.data) };
+}
+/**
+ * C1 post-mount textured upgrade (muse3jsparity-PRD). Runs fire-and-forget
+ * after mount: scalar first frames stay fast and honest, and every outcome —
+ * textured, fallback, or skipped — is recorded on the resource with warnings.
+ * Procedural inputs have no rasterizer: recorded + warned, never faked.
+ */
+export async function upgradeProductionPrimitiveTextures(entries, warn, maxTextureSize = 4096) {
+    for (const entry of entries) {
+        for (const resource of entry.resources) {
+            const spec = resource.materialSpec;
+            const intent = createProductionPrimitiveTextureIntent(spec);
+            for (const procedural of intent.proceduralInputs) {
+                // Static channel (collectGeneratedCodeWarnings) already warns; record
+                // per-resource without duplicating into runtime warnings.
+                resource.textureWarnings.push(`procedural texture ${procedural} on "${resource.name}" has no rasterizer; recorded only, scalar material retained`);
+            }
+            const urls = [intent.baseColorUrl, intent.normalUrl, intent.roughnessUrl, intent.metalnessUrl, intent.occlusionUrl, intent.emissiveUrl, ...Object.values(intent.extensionMaps ?? {}).map((map) => map.url)].filter((url) => typeof url === "string" && url.length > 0);
+            if (urls.length === 0)
+                continue;
+            if (resource.textureStatus !== "none")
+                continue;
+            resource.textureStatus = "pending";
+            try {
+                await upgradeProductionPrimitiveResource(resource, resource.sourceNode, spec, intent, maxTextureSize);
+            }
+            catch (error) {
+                resource.textureStatus = "fallback";
+                const message = `textured upgrade failed for "${resource.name}" (${error instanceof Error ? error.message : String(error)}); scalar material retained`;
+                resource.textureWarnings.push(message);
+                warn(message);
+            }
+        }
+    }
+}
+/**
+ * B3 post-mount HDRI upgrade (muse3jsparity-PRD). Fetches a Radiance `.hdr`
+ * asset, runs the HDR→cubemap→GGX-prefilter→BRDF-LUT chain, and returns the
+ * live lighting object plus its disposal. Throws on fetch/parse failure so
+ * the caller keeps the honest procedural fallback and warns.
+ */
+export async function upgradeProductionEnvironmentHdri(url, intensity, reflectionUrl, rotation) {
+    if (typeof fetch !== "function") {
+        throw new Error("HDRI upgrade requires fetch (browser production mount)");
+    }
+    const fetchRadiance = async (assetUrl) => {
+        const response = await fetch(assetUrl);
+        if (!response.ok)
+            throw new Error(`HDRI fetch failed with status ${response.status} for ${assetUrl}`);
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.length === 0)
+            throw new Error(`HDRI asset is empty for ${assetUrl}`);
+        return bytes;
+    };
+    const clampIntensity = Math.max(0, intensity);
+    const illumination = createProductionPbrHdrPipelineFromRadiance(await fetchRadiance(url), {
+        id: "root-hdri-environment",
+        label: "Root HDRI environment",
+        intensity: clampIntensity,
+        ...(rotation !== undefined ? { rotation } : {})
+    });
+    if (!illumination.diagnostics.realRadianceHdr)
+        throw new Error(`HDRI asset did not parse as Radiance HDR for ${url}`);
+    if (!reflectionUrl) {
+        const resources = createProductionEnvironmentLightingResources(illumination);
+        return {
+            lighting: resources.lighting,
+            dispose: resources.dispose,
+            maxLinearValue: illumination.diagnostics.maxLinearValue,
+            specularMipCount: illumination.diagnostics.specularMipCount,
+            dualProbe: false
+        };
+    }
+    const reflection = createProductionPbrHdrPipelineFromRadiance(await fetchRadiance(reflectionUrl), {
+        id: "root-hdri-reflection-environment",
+        label: "Root HDRI reflection environment",
+        intensity: clampIntensity,
+        ...(rotation !== undefined ? { rotation } : {})
+    });
+    if (!reflection.diagnostics.realRadianceHdr)
+        throw new Error(`HDRI reflection asset did not parse as Radiance HDR for ${reflectionUrl}`);
+    const dual = createDualProbeEnvironmentLightingResources({ illumination, reflection });
+    return {
+        lighting: dual.lighting,
+        dispose: dual.dispose,
+        maxLinearValue: Math.max(illumination.diagnostics.maxLinearValue, reflection.diagnostics.maxLinearValue),
+        specularMipCount: reflection.diagnostics.specularMipCount,
+        dualProbe: true
+    };
+}
+async function upgradeProductionPrimitiveResource(resource, node, spec, intent, maxTextureSize) {
+    const fail = (message) => new Error(message);
+    if (!resource.geometry.vertexBuffer.format.hasAttribute("uv")) {
+        throw fail(`"${resource.name}" geometry carries no uv set; textured upgrade needs generated uvs`);
+    }
+    const scalars = resolveProductionPrimitiveScalars(node);
+    const extensionEntries = Object.entries(intent.extensionMaps ?? {});
+    const needsScalarAtlas = extensionEntries.some(([slot]) => slot.startsWith("clearcoat"))
+        && extensionEntries.some(([slot]) => slot.startsWith("sheen") || slot === "anisotropy")
+        && extensionEntries.some(([slot]) => slot.startsWith("iridescence"));
+    if (extensionEntries.some(([, map]) => map.texCoord === 1) && !resource.geometry.vertexBuffer.format.hasAttribute("uv1")) {
+        throw fail(`"${resource.name}" geometry carries no uv1 set requested by extension texture`);
+    }
+    const ownedBitmaps = [];
+    const ownedTextures = [];
+    const bitmapLoads = new Map();
+    const load = (url) => {
+        let pending = bitmapLoads.get(url);
+        if (!pending) {
+            pending = loadProductionPrimitiveBitmap(url).then((bitmap) => {
+                ownedBitmaps.push(bitmap);
+                return bitmap;
+            });
+            bitmapLoads.set(url, pending);
+        }
+        return pending;
+    };
+    const own = (texture) => { ownedTextures.push(texture); return texture; };
+    const disposeTextures = () => {
+        for (const texture of ownedTextures)
+            texture.dispose();
+        for (const bitmap of ownedBitmaps)
+            bitmap.close();
+        ownedTextures.length = 0;
+        ownedBitmaps.length = 0;
+    };
+    try {
+        const baseResults = await Promise.allSettled([
+            intent.baseColorUrl ? load(intent.baseColorUrl) : Promise.resolve(undefined),
+            intent.normalUrl ? load(intent.normalUrl) : Promise.resolve(undefined),
+            intent.roughnessUrl ? load(intent.roughnessUrl) : Promise.resolve(undefined),
+            intent.metalnessUrl ? load(intent.metalnessUrl) : Promise.resolve(undefined),
+            intent.occlusionUrl ? load(intent.occlusionUrl) : Promise.resolve(undefined),
+            intent.emissiveUrl ? load(intent.emissiveUrl) : Promise.resolve(undefined)
+        ]);
+        const failure = baseResults.find((result) => result.status === "rejected");
+        if (failure?.status === "rejected")
+            throw failure.reason;
+        const [baseColorSource, normalSource, roughnessSource, metalnessSource, occlusionSource, emissiveSource] = baseResults.map((result) => result.status === "fulfilled" ? result.value : undefined);
+        const slots = [];
+        const extensionOptions = {};
+        const extensionSources = [];
+        const atlasPixels = {};
+        for (const [slot, map] of extensionEntries) {
+            const source = await load(map.url);
+            extensionSources.push(source);
+            if (needsScalarAtlas && ["clearcoat", "clearcoatRoughness", "sheenRoughness", "iridescence", "iridescenceThickness"].includes(slot)) {
+                Object.assign(atlasPixels, { [slot]: bitmapRgbaPixels(source) });
+            }
+            extensionOptions[`${slot}Texture`] = own(new Texture({ width: source.width, height: source.height, source, colorSpace: map.colorSpace, label: `${resource.name}-${slot}` }));
+            if (map.transform)
+                extensionOptions[`${slot}TextureTransform`] = { ...map.transform };
+            slots.push(slot);
+        }
+        if (needsScalarAtlas) {
+            const { createExtensionScalarAtlas } = await import("../../rendering/extension-scalar-atlas.js");
+            const atlas = createExtensionScalarAtlas(atlasPixels, maxTextureSize);
+            own(atlas.texture);
+            extensionOptions.extensionScalarAtlas = atlas;
+        }
+        const baseColorTexture = baseColorSource
+            ? own(new Texture({ width: baseColorSource.width, height: baseColorSource.height, source: baseColorSource, colorSpace: "srgb", label: `${resource.name}-basecolor` }))
+            : undefined;
+        if (baseColorTexture)
+            slots.push("baseColor");
+        const normalTexture = normalSource
+            ? own(new Texture({ width: normalSource.width, height: normalSource.height, source: normalSource, colorSpace: "linear", label: `${resource.name}-normal` }))
+            : undefined;
+        if (normalTexture)
+            slots.push("normal");
+        let metallicRoughnessTexture;
+        if (roughnessSource ?? metalnessSource) {
+            const base = roughnessSource ?? metalnessSource;
+            const size = { width: base.width, height: base.height };
+            const readPixels = (bitmap) => {
+                if (!bitmap)
+                    return undefined;
+                const decoded = bitmapRgbaPixels(bitmap);
+                if (decoded.width !== size.width || decoded.height !== size.height) {
+                    const canvas = document.createElement("canvas");
+                    canvas.width = size.width;
+                    canvas.height = size.height;
+                    const context = canvas.getContext("2d", { willReadFrequently: true });
+                    if (!context)
+                        throw fail("2d canvas unavailable for texture compositing");
+                    context.drawImage(bitmap, 0, 0, size.width, size.height);
+                    return new Uint8Array(context.getImageData(0, 0, size.width, size.height).data);
+                }
+                return decoded.data;
+            };
+            const composited = compositeMetallicRoughnessPixels(readPixels(roughnessSource), readPixels(metalnessSource), size.width * size.height, spec?.roughness ?? 0.58, spec?.metallic ?? spec?.metalness ?? 0);
+            metallicRoughnessTexture = own(new Texture({ width: size.width, height: size.height, data: composited, colorSpace: "linear", label: `${resource.name}-metallicroughness` }));
+            slots.push("metallicRoughness");
+        }
+        const occlusionTexture = occlusionSource
+            ? own(new Texture({ width: occlusionSource.width, height: occlusionSource.height, source: occlusionSource, colorSpace: "linear", label: `${resource.name}-occlusion` }))
+            : undefined;
+        if (occlusionTexture)
+            slots.push("occlusion");
+        const emissiveTexture = emissiveSource
+            ? own(new Texture({ width: emissiveSource.width, height: emissiveSource.height, source: emissiveSource, colorSpace: "srgb", label: `${resource.name}-emissive` }))
+            : undefined;
+        if (emissiveTexture)
+            slots.push("emissive");
+        if (slots.length === 0)
+            throw fail(`no texture resolved for "${resource.name}"`);
+        // M2 streaming table: resident bytes from the decoded sources (base +
+        // full mip-chain estimate) with the chain keyed off the largest source.
+        const loadedDims = [baseColorSource, normalSource, roughnessSource, metalnessSource, occlusionSource, emissiveSource, ...extensionSources]
+            .filter((source) => source !== undefined)
+            .map((source) => ({ width: source.width, height: source.height }));
+        const loadedBaseBytes = loadedDims.reduce((total, dims) => total + dims.width * dims.height * 4, 0);
+        const largestDims = loadedDims.reduce((largest, dims) => (dims.width * dims.height > largest.width * largest.height ? dims : largest), { width: 1, height: 1 });
+        resource.textureBytes = Math.round(loadedBaseBytes * (4 / 3));
+        resource.textureMipBytes = mipChainBytesCoarseToFine(largestDims.width, largestDims.height);
+        const texCoords = spec?.texCoords;
+        // C3: every root textured slot shares one capability-gated sampler request
+        // (default 8x where supported; the renderer clamps to the device maximum).
+        const textureSampler = new Sampler({
+            maxAnisotropy: resolveSamplerAnisotropy({ desired: spec?.textureAnisotropy }).applied
+        });
+        for (const [slot] of extensionEntries)
+            extensionOptions[`${slot}Sampler`] = textureSampler;
+        resource.texturedMaterial = new TexturedPBRMaterial({
+            name: `a3d-production-textured-primitive-${resource.name}`,
+            baseColor: [scalars.baseColor[0], scalars.baseColor[1], scalars.baseColor[2], scalars.opacity],
+            metallic: clamp01(spec?.metallic ?? spec?.metalness ?? 0),
+            roughness: clamp01(spec?.roughness ?? 0.58),
+            emissiveColor: spec?.emissive
+                ? [scalars.emissiveColor[0], scalars.emissiveColor[1], scalars.emissiveColor[2]]
+                : emissiveTexture ? [1, 1, 1] : [scalars.emissiveColor[0], scalars.emissiveColor[1], scalars.emissiveColor[2]],
+            emissiveStrength: Math.max(0, spec?.emissiveIntensity ?? (spec?.emissive || emissiveTexture ? 1.35 : 0)),
+            occlusionStrength: clamp01(spec?.occlusionStrength ?? 1),
+            clearcoatFactor: scalars.clearcoat,
+            clearcoatRoughnessFactor: clamp01(spec?.clearcoatRoughness ?? 0.34),
+            clearcoatNormalScale: Math.max(0, spec?.clearcoatNormalScale ?? 1),
+            ...extensionOptions,
+            sheenColorFactor: [scalars.sheenColor[0], scalars.sheenColor[1], scalars.sheenColor[2]],
+            sheenRoughnessFactor: clamp01(spec?.sheenRoughness ?? 0.3),
+            anisotropyStrength: scalars.anisotropy,
+            anisotropyRotation: spec?.anisotropyRotation ?? 0,
+            iridescenceFactor: scalars.iridescence,
+            iridescenceIor: Math.max(1, spec?.iridescenceIOR ?? 1.3),
+            ...(scalars.thicknessRange ? { iridescenceThicknessMinimum: scalars.thicknessRange[0], iridescenceThicknessMaximum: scalars.thicknessRange[1] } : {}),
+            transmissionFactor: scalars.transmission,
+            ...(spec?.thickness === undefined ? {} : { volumeThicknessFactor: Math.max(0, spec.thickness) }),
+            ...(spec?.ior === undefined ? {} : { ior: Math.max(1, spec.ior) }),
+            ...(spec?.attenuationColor ? { volumeAttenuationColor: colorToLinearRgb(spec.attenuationColor) } : {}),
+            ...(spec?.attenuationDistance === undefined ? {} : { volumeAttenuationDistance: Math.max(0, spec.attenuationDistance) }),
+            environmentIntensity: scalars.environmentIntensity,
+            envMapIntensity: scalars.envMapIntensity,
+            renderState: {
+                blend: scalars.opacity < 0.999,
+                depthWrite: scalars.opacity >= 0.999,
+                cullMode: node.primitive === "plane" || scalars.opacity < 0.999 ? "none" : "back"
+            },
+            ...(baseColorTexture ? { baseColorTexture, baseColorSampler: textureSampler } : {}),
+            ...(normalTexture ? { normalTexture, normalSampler: textureSampler, normalScale: spec?.normalScale ?? 1 } : {}),
+            ...(metallicRoughnessTexture ? { metallicRoughnessTexture, metallicRoughnessSampler: textureSampler } : {}),
+            ...(occlusionTexture ? { occlusionTexture, occlusionSampler: textureSampler } : {}),
+            ...(emissiveTexture ? { emissiveTexture, emissiveSampler: textureSampler } : {}),
+            ...(spec?.texTransforms?.baseColor ? { baseColorTextureTransform: { ...spec.texTransforms.baseColor } } : {}),
+            ...(spec?.texTransforms?.normal ? { normalTextureTransform: { ...spec.texTransforms.normal } } : {}),
+            ...(spec?.texTransforms?.metallicRoughness ? { metallicRoughnessTextureTransform: { ...spec.texTransforms.metallicRoughness } } : {}),
+            ...(spec?.texTransforms?.occlusion ? { occlusionTextureTransform: { ...spec.texTransforms.occlusion } } : {}),
+            ...(spec?.texTransforms?.emissive ? { emissiveTextureTransform: { ...spec.texTransforms.emissive } } : {}),
+            ...((texCoords?.baseColor ?? 0) > 0 || (texCoords?.normal ?? 0) > 0 || (texCoords?.metallicRoughness ?? 0) > 0 || (texCoords?.occlusion ?? 0) > 0 || (texCoords?.emissive ?? 0) > 0 || extensionEntries.length > 0
+                ? {
+                    textureTexCoords: {
+                        ...Object.fromEntries(extensionEntries.map(([slot, map]) => [slot, map.texCoord])),
+                        ...(baseColorTexture && (texCoords?.baseColor ?? 0) > 0 ? { baseColor: 1 } : {}),
+                        ...(normalTexture && (texCoords?.normal ?? 0) > 0 ? { normal: 1 } : {}),
+                        ...(metallicRoughnessTexture && (texCoords?.metallicRoughness ?? 0) > 0 ? { metallicRoughness: 1 } : {}),
+                        ...(occlusionTexture && (texCoords?.occlusion ?? 0) > 0 ? { occlusion: 1 } : {}),
+                        ...(emissiveTexture && (texCoords?.emissive ?? 0) > 0 ? { emissive: 1 } : {})
+                    }
+                }
+                : {})
+        });
+        if (resource.material.disposed) {
+            resource.texturedMaterial.dispose();
+            resource.texturedMaterial = null;
+            throw fail("primitive disposed while texture upgrade was pending");
+        }
+        resource.textureDisposer = disposeTextures;
+        resource.textureStatus = "textured";
+        resource.textureSlots = slots;
+    }
+    catch (error) {
+        disposeTextures();
+        throw error;
+    }
+}
+export function compositeMetallicRoughnessPixels(rough, metal, pixelCount, roughnessScalar, metalnessScalar) {
+    const out = new Uint8Array(pixelCount * 4);
+    const fallbackG = Math.round(clamp01(roughnessScalar) * 255);
+    const fallbackB = Math.round(clamp01(metalnessScalar) * 255);
+    for (let pixel = 0; pixel < pixelCount; pixel += 1) {
+        const base = pixel * 4;
+        out[base] = 255;
+        out[base + 1] = rough ? rough[base + 1] ?? fallbackG : fallbackG;
+        out[base + 2] = metal ? metal[base + 2] ?? fallbackB : fallbackB;
+        out[base + 3] = 255;
+    }
+    return out;
+}
+/**
+ * G1 SDF text resource (muse3jsparity-PRD): replays the recorded descriptor
+ * through the atlas sampler at mount, uploads the label image as a native
+ * texture, and submits atlas-derived quads. Returns null (extruded fallback)
+ * with a warning when the sampler cannot run — never a silent mesh swap.
+ */
+function createSdfTextPrimitiveResource(node, warn) {
+    const text = node.text3D;
+    if (!text || text.backend !== "sdf")
+        return null;
+    try {
+        const layout = layoutSdfText(text.text, rootSdfFontAtlas(), {
+            size: text.sdfSize ?? 1,
+            ...(text.sdfLetterSpacing === undefined ? {} : { letterSpacing: text.sdfLetterSpacing }),
+            ...(text.sdfStyle === undefined ? {} : { style: text.sdfStyle })
+        });
+        const style = layout.style;
+        const styled = text.sdfStyle !== undefined && (style.outlineWidthEm > 0 || style.glowRadiusEm > 0 || style.shadowOffsetEm !== undefined);
+        const image = rasterizeSdfTextLabelImage(layout, rootSdfFontAtlas(), {
+            texelsPerWorldUnit: 64,
+            ...(styled
+                ? {
+                    outline: [1, 0.85, 0.6, 1],
+                    glow: [0.5, 0.8, 1, 1],
+                    shadow: [0, 0, 0, 1]
+                }
+                : {})
+        });
+        const mesh = createSdfTextQuadMesh(layout, image);
+        const vertexCount = mesh.vertexCount;
+        const vertices = new VertexBuffer(VertexFormat.P3N3T4T2T2, vertexCount);
+        for (let index = 0; index < vertexCount; index += 1) {
+            vertices.setAttribute(index, "position", [mesh.positions[index * 3] ?? 0, mesh.positions[index * 3 + 1] ?? 0, 0]);
+            vertices.setAttribute(index, "normal", [0, 0, 1]);
+            vertices.setAttribute(index, "tangent", [1, 0, 0, 1]);
+            vertices.setAttribute(index, "uv", [mesh.uvs[index * 2] ?? 0, mesh.uvs[index * 2 + 1] ?? 0]);
+            vertices.setAttribute(index, "uv1", [mesh.uvs[index * 2] ?? 0, mesh.uvs[index * 2 + 1] ?? 0]);
+        }
+        const geometry = new Geometry(vertices, new IndexBuffer(mesh.indices, vertexCount), "triangles", { min: [mesh.min[0], mesh.min[1], mesh.min[2]], max: [mesh.max[0], mesh.max[1], mesh.max[2]] });
+        const opacity = clamp01(node.material?.opacity ?? 1);
+        const labelTexture = new Texture({
+            width: image.width,
+            height: image.height,
+            data: image.data,
+            colorSpace: "srgb",
+            label: `${node.name ?? "sdf-text"}-sdf-label`
+        });
+        const sampler = new Sampler({ maxAnisotropy: resolveSamplerAnisotropy({ desired: node.material?.textureAnisotropy }).applied });
+        const texturedMaterial = new TexturedPBRMaterial({
+            name: `a3d-production-sdf-text-${node.name ?? "label"}`,
+            baseColor: [1, 1, 1, opacity],
+            metallic: 0,
+            roughness: 0.9,
+            emissiveColor: [0.92, 0.92, 0.92],
+            emissiveStrength: 0.9,
+            occlusionStrength: 0,
+            environmentIntensity: 0,
+            renderState: { blend: true, depthWrite: false, cullMode: "none" },
+            baseColorTexture: labelTexture,
+            baseColorSampler: sampler,
+            emissiveTexture: labelTexture,
+            emissiveSampler: sampler
+        });
+        const mipBytes = mipChainBytesCoarseToFine(image.width, image.height);
+        return {
+            geometry,
+            material: createProductionPrimitiveMaterial(node),
+            bounds: { min: [mesh.min[0], mesh.min[1], mesh.min[2]], max: [mesh.max[0], mesh.max[1], mesh.max[2]] },
+            name: node.name ?? "sdf-text",
+            materialSpec: node.material,
+            sourceNode: node,
+            ...blankProductionPrimitiveTextureState(),
+            texturedMaterial,
+            textureStatus: "textured",
+            textureSlots: ["baseColor", "emissive"],
+            textureWarnings: [],
+            sdfText: {
+                quadCount: mesh.quadCount,
+                imageBytes: image.width * image.height * 4,
+                ...(style.lodFadeNear === undefined ? {} : { lodFadeNear: style.lodFadeNear }),
+                ...(style.lodFadeFar === undefined ? {} : { lodFadeFar: style.lodFadeFar }),
+                occlusionPolicy: (text.sdfOcclusion ?? "dim"),
+                lastOpacity: opacity,
+                lastVisible: true,
+                lastSubmitted: false
+            },
+            textureBytes: Math.round(image.width * image.height * 4 * (4 / 3)),
+            textureMipBytes: mipBytes
+        };
+    }
+    catch (error) {
+        warn(`SDF text sampler failed for "${node.name ?? "sdf-text"}" (${error instanceof Error ? error.message : String(error)}); extruded mesh fallback retained`);
+        return null;
+    }
+}
+/**
+ * M2 mip-chain byte estimate (pure, unit-tested): full chain from the base
+ * level, coarse-to-fine, RGBA8. Matches the GPU residency the bridge funds.
+ */
+export function mipChainBytesCoarseToFine(width, height) {
+    if (!Number.isInteger(width) || width <= 0 || !Number.isInteger(height) || height <= 0) {
+        throw new Error("Mip-chain bytes require positive integer dimensions.");
+    }
+    const levels = [];
+    let w = width;
+    let h = height;
+    while (true) {
+        levels.unshift(w * h * 4);
+        if (w === 1 && h === 1)
+            break;
+        w = Math.max(1, Math.floor(w / 2));
+        h = Math.max(1, Math.floor(h / 2));
+    }
+    return levels;
+}
+/** M2 streaming budget normalization (pure, unit-tested): default 256 MiB, fail-closed. */
+export function normalizeTextureBudgetBytes(value) {
+    if (value === undefined)
+        return 256 * 1024 * 1024;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error("Aura3D textureBudgetBytes must be a positive byte count.");
+    }
+    return Math.floor(value);
+}
+/**
+ * M2 streaming residency from the post-upgrade texture table (pure,
+ * unit-tested): distance-prioritized mip funding against the budget with
+ * over-budget telemetry for the unfunded tail.
+ */
+export function describeTextureStreamingResidency(table, budgetBytes) {
+    const candidates = table.map((entry) => ({
+        id: entry.id,
+        mipBytesCoarseToFine: entry.mipBytesCoarseToFine,
+        distanceMeters: entry.distanceMeters
+    }));
+    return evaluateDistancePrioritizedMipResidency(candidates, normalizeTextureBudgetBytes(budgetBytes));
+}
+/**
+ * N1 spot shadow observation (pure, unit-tested): cone + atlas tier from the
+ * authored spot, pixel-backing gated on the device-observed map signals with
+ * the spot as caster. No signal, no claim.
+ */
+export function describeProductionSpotShadow(input) {
+    if (!input.requested || !input.casterIsSpot || input.angle === undefined) {
+        return {
+            requested: input.requested,
+            casterIsSpot: input.casterIsSpot,
+            ...(input.casterName === undefined ? {} : { casterName: input.casterName }),
+            spotPixelBacked: false,
+            reason: !input.requested
+                ? "no authored spot requested a shadow map"
+                : !input.casterIsSpot
+                    ? "shadow requested but the caster slot went to a non-spot light"
+                    : "spot caster has no cone description"
+        };
+    }
+    // Tier selection validates the cone fail-closed (RangeError on bad angle);
+    // the full projection matrix composes in-device from this cone + range.
+    const tier = selectSpotShadowAtlasTier(input.angle);
+    createSpotShadowProjection(input.angle, Math.max(1, input.range ?? 12));
+    const backed = input.mapRendered && input.mapSampled;
+    return {
+        requested: true,
+        casterIsSpot: true,
+        ...(input.casterName === undefined ? {} : { casterName: input.casterName }),
+        angle: input.angle,
+        ...(input.penumbra === undefined ? {} : { penumbra: input.penumbra }),
+        range: Math.max(1, input.range ?? 12),
+        atlasResolution: tier.resolution,
+        atlasReason: tier.reason,
+        spotPixelBacked: backed,
+        reason: backed
+            ? `spot shadow map rendered and sampled (${tier.resolution}px ${tier.reason})`
+            : "spot caster selected but the device shows no rendered+sampled shadow map yet"
+    };
+}
 function createProductionPrimitiveResources(node) {
+    const sdfWarnings = [];
+    const sdfResource = createSdfTextPrimitiveResource(node, (message) => { sdfWarnings.push(message); });
     const levels = node.lod?.levels;
     if (!levels?.length) {
-        return [{ geometry: createProductionPrimitiveGeometry(node), material: createProductionPrimitiveMaterial(node), bounds: primitiveGeometryBounds(node), name: node.name ?? node.primitive }];
+        if (sdfResource)
+            return [sdfResource];
+        const fallback = {
+            geometry: createProductionPrimitiveGeometry(node),
+            material: createProductionPrimitiveMaterial(node),
+            bounds: primitiveGeometryBounds(node),
+            name: node.name ?? node.primitive,
+            materialSpec: node.material,
+            sourceNode: node,
+            ...blankProductionPrimitiveTextureState()
+        };
+        // Sampler failures stay visible on the fallback resource (surfaced via
+        // texturedMaterials diagnostics), never swallowed by the mesh swap.
+        fallback.textureWarnings.push(...sdfWarnings);
+        return [fallback];
     }
     return levels.map((level, index) => {
         if (!level.primitive && !level.geometry)
@@ -8512,18 +10462,40 @@ function createProductionPrimitiveResources(node) {
             material: level.material ?? node.material,
             lod: undefined
         };
-        return { geometry: createProductionPrimitiveGeometry(levelNode), material: createProductionPrimitiveMaterial(levelNode), bounds: primitiveGeometryBounds(levelNode), name: level.name };
+        const levelWarnings = [];
+        const levelSdf = createSdfTextPrimitiveResource(levelNode, (message) => { levelWarnings.push(message); });
+        if (levelSdf)
+            return { ...levelSdf, name: level.name };
+        const levelFallback = {
+            geometry: createProductionPrimitiveGeometry(levelNode),
+            material: createProductionPrimitiveMaterial(levelNode),
+            bounds: primitiveGeometryBounds(levelNode),
+            name: level.name,
+            materialSpec: levelNode.material,
+            sourceNode: levelNode,
+            ...blankProductionPrimitiveTextureState()
+        };
+        levelFallback.textureWarnings.push(...levelWarnings);
+        return levelFallback;
     });
 }
-function selectProductionPrimitiveResource(entry, node, cameraPosition) {
+function selectProductionPrimitiveResource(entry, node, cameraPosition, lodBias = 1) {
     if (!node.lod?.levels.length)
         return entry.resources[0];
     const position = node.position ?? [0, 0, 0];
     const distance = Math.hypot(cameraPosition[0] - position[0], cameraPosition[1] - position[1], cameraPosition[2] - position[2]);
-    const selection = selectAuraRootLodLevel(distance, node.lod.levels, entry.currentLodIndex, node.lod.hysteresis ?? 0);
+    const selection = selectAuraRootLodLevel(distance * lodBias, node.lod.levels, entry.currentLodIndex, node.lod.hysteresis ?? 0);
     entry.currentLodIndex = selection.levelIndex;
     return entry.resources[selection.levelIndex] ?? entry.resources[entry.resources.length - 1];
 }
+function createProductionModelInstanceTransforms(transforms, node, bounds, time) {
+    const matrices = new Float32Array(transforms.length * 16);
+    transforms.forEach((transform, index) => {
+        const localNode = { ...node, ...transform };
+        matrices.set(createModelMatrix(localNode, bounds, shouldNormalizeModelNode(node), time), index * 16);
+    });
+    return matrices;
+}
 function createProductionInstanceTransforms(transforms, node) {
     const matrices = new Float32Array(transforms.length * 16);
     transforms.forEach((transform, index) => {
@@ -8559,37 +10531,7 @@ function resolveProductionPrimitiveRuntimeState(entry, runtimeNodes) {
         visible: runtimeSnapshot.visible
     };
 }
-/**
- * Build the production `PBRMaterial` for a primitive node.
- *
- * ## WS-2.1a — the parameter drop this function used to be
- *
- * Until 1.6 this forwarded `clearcoat` and **nothing else** from the extended material surface.
- * `AuraMaterialSpec` accepts `sheen`, `sheenRoughness`, `sheenColor`, `iridescence`,
- * `iridescenceIOR`, `iridescenceThicknessRange`, `anisotropy`, `anisotropyRotation`, `transmission`,
- * `thickness`, `ior`, `attenuationColor` and `attenuationDistance`; `PBRMaterial` accepts a uniform
- * for every one of them and binds them all. The bridge between the two dropped them on the floor.
- *
- * How that presented, measured by `tools/material-structural-parity` before the fix:
- *
- * ```
- * material.pbr({ ..., sheen: 1 })         -> byte-identical frame to sheen: 0
- * material.pbr({ ..., iridescence: 1 })   -> byte-identical frame to iridescence: 0
- * material.pbr({ ..., clearcoat: 1 })     -> byte-identical frame to clearcoat: 0
- * ```
- *
- * `clearcoat` was *forwarded* and still produced an identical frame, which pins the second, separate
- * defect: `a3dPbrExtensionEnvironmentLight` in `ShaderChunks.ts` adds its lobes to
- * `specularRadiance`, a term that is zero without an environment map. Forwarding alone is necessary
- * and not sufficient, so `environmentIntensity` now also has a floor when an extension factor is
- * present — otherwise a developer setting `clearcoat: 1` on a scene with no environment sees nothing
- * and has no way to find out why.
- *
- * The reason this survived so long is worth stating: three of the four lobes are scalar
- * approximations rather than real BRDFs, and **nobody could tell**, because the parameters never
- * arrived. The plumbing defect concealed the shading defect.
- */
-function createProductionPrimitiveMaterial(node) {
+function resolveProductionPrimitiveScalars(node) {
     const materialSpec = node.material;
     const baseColor = colorToLinearRgba(materialSpec?.color ?? materialSpec?.emissive ?? "#d7dee8");
     const opacity = clamp01(materialSpec?.opacity ?? baseColor[3] ?? 1);
@@ -8620,6 +10562,17 @@ function createProductionPrimitiveMaterial(node) {
     const environmentIntensity = declaresExtension
         ? Math.max(0.35, requestedEnvironmentIntensity)
         : requestedEnvironmentIntensity;
+    // B3: the sampled env-map scale defaults to 1 (no look change) and honors
+    // an explicitly authored envMapIntensity, including 0 (killed response).
+    const envMapIntensity = materialSpec?.envMapIntensity === undefined ? 1 : Math.max(0, materialSpec.envMapIntensity);
+    return {
+        materialSpec, baseColor, opacity, emissiveColor, clearcoat, sheen, iridescence,
+        anisotropy, transmission, thicknessRange, sheenColor, declaresExtension, environmentIntensity, envMapIntensity
+    };
+}
+function createProductionPrimitiveMaterial(node) {
+    const materialSpec = node.material;
+    const { baseColor, opacity, emissiveColor, clearcoat, sheenColor, declaresExtension, transmission, thicknessRange, sheen, iridescence, anisotropy, environmentIntensity, envMapIntensity } = resolveProductionPrimitiveScalars(node);
     /*
      * Native instance submission requires the renderer's instanced shader contract. The ordinary
      * PBR shader intentionally has no instance matrix inputs and ForwardPass therefore expands it.
@@ -8637,6 +10590,7 @@ function createProductionPrimitiveMaterial(node) {
             emissiveColor,
             emissiveStrength: Math.max(0, materialSpec?.emissiveIntensity ?? (materialSpec?.emissive ? 1.35 : 0)),
             environmentIntensity,
+            envMapIntensity,
             renderState: {
                 blend: opacity < 0.999,
                 depthWrite: opacity >= 0.999,
@@ -8667,6 +10621,7 @@ function createProductionPrimitiveMaterial(node) {
         ...(materialSpec?.attenuationColor ? { volumeAttenuationColor: colorToLinearRgb(materialSpec.attenuationColor) } : {}),
         ...(materialSpec?.attenuationDistance === undefined ? {} : { volumeAttenuationDistance: Math.max(0, materialSpec.attenuationDistance) }),
         environmentIntensity,
+        envMapIntensity,
         renderState: {
             blend: opacity < 0.999,
             depthWrite: opacity >= 0.999,
@@ -8689,6 +10644,12 @@ function primitiveGeometryBounds(nodeOrPrimitive) {
         throw new Error("Aura3D custom primitive requires geometry.");
     return createProductionPrimitiveMesh(primitive).bounds;
 }
+function tilingSecondUnwrap(uvs) {
+    const uv1s = new Float32Array(uvs.length);
+    for (let i = 0; i < uvs.length; i += 1)
+        uv1s[i] = (uvs[i] ?? 0) * 2;
+    return uv1s;
+}
 function createProductionPrimitiveMesh(primitive) {
     if (primitive === "sphere")
         return createSphereGeometry();
@@ -8740,11 +10701,24 @@ function calculateCustomGeometryNormals(spec) {
 }
 function createProductionGeometryFromPrimitiveMesh(mesh) {
     const vertexCount = mesh.positions.length / 3;
-    const vertices = new VertexBuffer(VertexFormat.P3N3, vertexCount);
+    const textured = Boolean(mesh.uvs && mesh.uvs.length === vertexCount * 2
+        && mesh.tangents && mesh.tangents.length === vertexCount * 4);
+    const vertices = new VertexBuffer(textured ? VertexFormat.P3N3T4T2T2 : VertexFormat.P3N3, vertexCount);
     for (let index = 0; index < vertexCount; index += 1) {
         const base = index * 3;
         vertices.setAttribute(index, "position", [mesh.positions[base] ?? 0, mesh.positions[base + 1] ?? 0, mesh.positions[base + 2] ?? 0]);
         vertices.setAttribute(index, "normal", [mesh.normals[base] ?? 0, mesh.normals[base + 1] ?? 1, mesh.normals[base + 2] ?? 0]);
+        if (textured) {
+            const uvBase = index * 2;
+            const tangentBase = index * 4;
+            vertices.setAttribute(index, "tangent", [
+                mesh.tangents[tangentBase] ?? 1, mesh.tangents[tangentBase + 1] ?? 0,
+                mesh.tangents[tangentBase + 2] ?? 0, mesh.tangents[tangentBase + 3] ?? 1
+            ]);
+            vertices.setAttribute(index, "uv", [mesh.uvs[uvBase] ?? 0, mesh.uvs[uvBase + 1] ?? 0]);
+            const uv1 = mesh.uv1s && mesh.uv1s.length === vertexCount * 2 ? mesh.uv1s : mesh.uvs;
+            vertices.setAttribute(index, "uv1", [uv1[uvBase] ?? 0, uv1[uvBase + 1] ?? 0]);
+        }
     }
     return new Geometry(vertices, new IndexBuffer(Array.from(mesh.indices), vertexCount), "triangles", mesh.bounds);
 }
@@ -8766,10 +10740,12 @@ function resolveProductionActorRuntimeState(entry, runtimeNodes) {
             animation: runtimeSnapshot.animation ?? entry.node.animation
         },
         animationBinding: runtimeSnapshot.animationBinding,
+        animationPose: runtimeSnapshot.animationPose,
+        animationPoseTime: runtimeSnapshot.animationPoseBinding?.localTime ?? runtimeSnapshot.animationPoseBinding?.captureTime,
         ...(Object.keys(morphTargets).length > 0 ? { morphTargets } : {})
     };
 }
-function applyProductionActorAnimation(entry, node, animationBinding, time, runtimeWarnings) {
+function applyProductionActorAnimation(entry, node, animationBinding, time, runtimeWarnings, modelMatrix, refreshAfterMovement) {
     const animation = node.animation;
     if (!animation?.clip || isModelTransformAnimationClip(animation.clip))
         return;
@@ -8779,12 +10755,84 @@ function applyProductionActorAnimation(entry, node, animationBinding, time, runt
         return;
     }
     try {
-        entry.actor.playClip(clipName, resolveProductionActorAnimationSeconds(animation, animationBinding, time));
+        const binding = animationBinding?.rootMotion;
+        if (binding && animationBinding) {
+            const observed = animationBinding.rootMotionSamples ?? [{
+                    playbackId: animationBinding.playbackId ?? clipName, clipName,
+                    time: animationBinding.rootMotionTime ?? 0, weight: 1,
+                    loop: animationBinding.loop ?? animation.loop ?? true, additive: false
+                }];
+            if (observed.length === 0) {
+                entry.rootMotionCursors = undefined;
+                return;
+            }
+            const cursors = entry.rootMotionCursors ?? new Map();
+            const samples = observed.map(sample => {
+                if (!Number.isFinite(sample.time) || sample.time < 0)
+                    throw new Error("Root motion requires a finite nonnegative unwrapped controller time.");
+                const previous = cursors.get(sample.playbackId);
+                return { clipName: sample.clipName, target: binding.target,
+                    fromTime: previous === undefined ? 0 : Math.min(previous, sample.time),
+                    toTime: sample.time, weight: sample.weight, loop: sample.loop, additive: sample.additive };
+            });
+            const commitCursors = () => { entry.rootMotionCursors = new Map(observed.map(sample => [sample.playbackId, sample.time])); };
+            const result = entry.actor.playRootMotionClips(samples, {
+                worldFromLocal: [...modelMatrix],
+                move: requested => {
+                    if (samples.every(sample => sample.fromTime === sample.toTime))
+                        return [0, 0, 0];
+                    const accepted = binding.move(requested);
+                    // Advance cursors before pose/IK work: retrying a failed pose cannot move twice.
+                    commitCursors();
+                    refreshAfterMovement();
+                    return accepted;
+                }
+            });
+            commitCursors();
+            binding.onSample?.(result.motion);
+        }
+        else {
+            entry.rootMotionCursors = undefined;
+            entry.actor.playClip(clipName, resolveProductionActorAnimationSeconds(animation, animationBinding, time));
+        }
     }
     catch (error) {
         runtimeWarnings.add(`Typed GLB actor "${entry.actor.id}" failed to apply clip "${clipName}": ${productionRenderErrorMessage(error)}`);
     }
 }
+/**
+ * Applies controller-bound foot planting (E2) to the typed GLB actor. The resolved config
+ * is refreshed every frame with the actor's live model matrix: time-animated model nodes
+ * (float/orbit/turntable) move, and the post-pass solves in world space, so a stale matrix
+ * would plant feet in yesterday's frame. Foot-lock state survives the refresh — the runtime
+ * keeps its rig across matrix-only updates and resets it only when the leg set, ground, or
+ * solve parameters change.
+ */
+function applyProductionActorFootPlanting(entry, animationBinding, modelMatrix, runtimeWarnings) {
+    const footPlanting = animationBinding?.footPlanting;
+    try {
+        entry.actor.animation.setFootPlanting((footPlanting === undefined
+            ? undefined
+            : { ...footPlanting, legs: footPlanting.legs.map(leg => ({ ...leg, ...(leg.contactPhase ? { contact: leg.contactPhase(animationBinding?.localTime ?? 0) } : {}) })), ...spreadFootPlantingWorldMatrix(modelMatrix) }));
+    }
+    catch (error) {
+        runtimeWarnings.add(`Typed GLB actor "${entry.actor.id}" failed to apply foot planting: ${productionRenderErrorMessage(error)}`);
+    }
+}
+/**
+ * Packages the actor model matrix as the post-pass `worldFromLocal`. The matrix the
+ * renderer draws with (column-major 16, model-local → world) is exactly the space the
+ * foot-planting ground speaks, so the same array threads both paths. Returns {} when the
+ * matrix is missing or malformed so the pass falls back to actor-local solving.
+ */
+function spreadFootPlantingWorldMatrix(modelMatrix) {
+    if (!modelMatrix || modelMatrix.length !== 16)
+        return {};
+    const worldFromLocal = Array.from(modelMatrix, (component) => Number(component));
+    if (worldFromLocal.some((component) => !Number.isFinite(component)))
+        return {};
+    return { worldFromLocal };
+}
 function applyProductionActorMorphTargets(entry, morphTargets, runtimeWarnings) {
     if (!morphTargets || Object.keys(morphTargets).length === 0)
         return;
@@ -8832,7 +10880,17 @@ function createRuntimeEvidenceFromTypedGLBActor(node, actor, renderItems) {
         },
         renderItemCount: renderItems.length,
         skinnedRenderItemCount: renderItems.filter((item) => item.skinning).length,
-        morphRenderItemCount: renderItems.filter((item) => item.morphTargets && item.morphTargets.length > 0).length
+        morphRenderItemCount: renderItems.filter((item) => item.morphTargets && item.morphTargets.length > 0).length,
+        lastMaterialTracksApplied: actorEvidence.lastMaterialTracksApplied,
+        lastLightTracksApplied: actorEvidence.lastLightTracksApplied,
+        lastFootPlantingGroundedFeet: actorEvidence.lastFootPlantingGroundedFeet,
+        lastFootPlantingTargetError: actorEvidence.lastFootPlantingTargetError,
+        lastFootPlantingHipOffset: actorEvidence.lastFootPlantingHipOffset,
+        lastFootPlantingMissingLegs: [...actorEvidence.lastFootPlantingMissingLegs],
+        lastFootPlantingFeet: actorEvidence.lastFootPlantingFeet,
+        lastFootPlantingSurfaces: actorEvidence.lastFootPlantingSurfaces,
+        lastFootPlantingDeformation: actorEvidence.lastFootPlantingDeformation,
+        footPlantingConfigured: actorEvidence.footPlantingConfigured
     });
 }
 function createProductionRuntimeMetadata(actorEntries, primitiveEntries) {
@@ -9277,7 +11335,9 @@ 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");
+    return effectNodes.some((node) => node.effect === "bloom" || node.effect === "ambient-occlusion" || node.effect === "contact-occlusion"
+        || node.effect === "color-grade" || node.effect === "anti-alias" || node.effect === "outline"
+        || node.effect === "screen-space-reflections" || node.effect === "depth-of-field" || node.effect === "motion-blur");
 }
 async function createWebGLSceneRenderer(canvas, snapshot, rendererOptions, runtimeWarnings = [], runtimeNodes) {
     const gl = canvas.getContext("webgl2", { antialias: true, preserveDrawingBuffer: true });
@@ -9313,7 +11373,8 @@ async function createWebGLSceneRenderer(canvas, snapshot, rendererOptions, runti
             contactOcclusionReceiver: false,
             pixelBacked: false,
             actualPasses: [],
-            fallbackPasses: hasRuntimePostProcessEffects(requestedEffectNodes) ? ["webgl2-direct-render"] : []
+            fallbackPasses: hasRuntimePostProcessEffects(requestedEffectNodes) ? ["webgl2-direct-render"] : [],
+            executionMode: "none"
         },
         warnings: [
             "Aura3D WebGL2 agent runtime is an explicit safe-basic fallback; advanced postprocess, environment prefiltering, shadow maps, and GLB animation mixers are reported as unsupported unless the production runtime proves them.",
@@ -10549,6 +12610,8 @@ function textureRef(texture, uvs, key) {
     return { [key]: texture.index };
 }
 function createPlaneGeometry() {
+    const uvs = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
+    const tangents = new Float32Array([1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1]);
     return {
         positions: new Float32Array([
             -0.5, 0, -0.5,
@@ -10569,10 +12632,21 @@ function createPlaneGeometry() {
         // up-normal downward. The plane then faced away from every overhead light and
         // received no direct lighting or visible cast shadows.
         indices: new Uint16Array([0, 2, 1, 0, 3, 2]),
-        bounds: { min: [-0.5, 0, -0.5], max: [0.5, 0, 0.5] }
+        bounds: { min: [-0.5, 0, -0.5], max: [0.5, 0, 0.5] },
+        uvs,
+        uv1s: tilingSecondUnwrap(uvs),
+        tangents
     };
 }
 function createBoxGeometry() {
+    // One full 0-1 unwrap per face, matching the 4-vertex face order below.
+    const faceUvs = [0, 0, 1, 0, 1, 1, 0, 1];
+    const uvs = new Float32Array([...faceUvs, ...faceUvs, ...faceUvs, ...faceUvs, ...faceUvs, ...faceUvs]);
+    // Analytic tangents along each face's +u direction (face order +z,-z,+y,-y,+x,-x).
+    const faceTangents = [
+        [1, 0, 0, 1], [-1, 0, 0, 1], [1, 0, 0, 1], [1, 0, 0, 1], [0, 0, -1, 1], [0, 0, 1, 1]
+    ];
+    const tangents = new Float32Array(faceTangents.flatMap((tangent) => [...tangent, ...tangent, ...tangent, ...tangent]));
     const positions = new Float32Array([
         -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5,
         0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5,
@@ -10600,7 +12674,10 @@ function createBoxGeometry() {
             16, 17, 18, 16, 18, 19,
             20, 21, 22, 20, 22, 23
         ]),
-        bounds: { min: [-0.5, -0.5, -0.5], max: [0.5, 0.5, 0.5] }
+        bounds: { min: [-0.5, -0.5, -0.5], max: [0.5, 0.5, 0.5] },
+        uvs,
+        uv1s: tilingSecondUnwrap(uvs),
+        tangents
     };
 }
 function createSphereGeometry() {
@@ -10608,6 +12685,8 @@ function createSphereGeometry() {
     const columns = 16;
     const positions = [];
     const normals = [];
+    const uvs = [];
+    const tangents = [];
     const indices = [];
     for (let row = 0; row <= rows; row += 1) {
         const v = row / rows;
@@ -10620,6 +12699,8 @@ function createSphereGeometry() {
             const z = Math.sin(theta) * Math.sin(phi);
             positions.push(x * 0.5, y * 0.5, z * 0.5);
             normals.push(x, y, z);
+            uvs.push(u, 1 - v);
+            tangents.push(-Math.sin(phi), 0, Math.cos(phi), 1);
         }
     }
     for (let row = 0; row < rows; row += 1) {
@@ -10632,11 +12713,15 @@ function createSphereGeometry() {
             indices.push(a, a + 1, b, b, a + 1, b + 1);
         }
     }
+    const sphereUvs = new Float32Array(uvs);
     return {
         positions: new Float32Array(positions),
         normals: new Float32Array(normals),
         indices: new Uint16Array(indices),
-        bounds: { min: [-0.5, -0.5, -0.5], max: [0.5, 0.5, 0.5] }
+        bounds: { min: [-0.5, -0.5, -0.5], max: [0.5, 0.5, 0.5] },
+        uvs: sphereUvs,
+        uv1s: tilingSecondUnwrap(sphereUvs),
+        tangents: new Float32Array(tangents)
     };
 }
 function createCylinderGeometry() {
@@ -10973,11 +13058,7 @@ function createViewProjection(snapshot, aspect, time, runtimeNodes) {
     const cameraSpec = snapshot.camera;
     const { target, eye } = resolveCameraFrame(snapshot, cameraSpec, time, runtimeNodes);
     const view = lookAtMat4([...eye], [...target], [0, 1, 0]);
-    const halfHeight = Math.max(1e-4, cameraSpec.orthographicSize ?? 1.4);
-    const halfWidth = Math.max(1e-4, halfHeight * aspect);
-    const projection = isOrthographicCameraMode(cameraSpec.mode)
-        ? orthographicMat4(-halfWidth, halfWidth, -halfHeight, halfHeight, 0.05, 100)
-        : perspectiveMat4(((cameraSpec.fov ?? 45) * Math.PI) / 180, aspect, 0.05, 100);
+    const projection = createCameraProjection(cameraSpec, aspect);
     return new Float32Array(multiplyMat4(projection, view));
 }
 function createModelMatrix(node, bounds, normalizeToUnit, time = 0) {
@@ -11050,6 +13131,10 @@ function isModelTransformAnimationClip(clip) {
     return clip === "turntable" || clip === "float" || clip === "orbit";
 }
 function primitiveSize(node) {
+    // SDF quad positions are already authored in world units by layoutSdfText.
+    // Applying the public text size again here shrinks/grows the GPU quad twice.
+    if (node.text3D?.backend === "sdf")
+        return [1, 1, 1];
     if (typeof node.size === "number")
         return [node.size, node.size, node.size];
     return node.size ?? [1, 1, 1];
@@ -11370,7 +13455,9 @@ function snapshotDiagnostics(value) {
         renderer: value.renderer,
         warnings: [...value.warnings],
         errors: [...value.errors],
-        ...(value.labels ? { labels: value.labels } : {})
+        ...(value.labels ? { labels: value.labels } : {}),
+        ...(value.labelTelemetry ? { labelTelemetry: value.labelTelemetry } : {}),
+        ...(value.textBuckets ? { textBuckets: value.textBuckets } : {})
     };
 }
 function collectGeneratedCodeWarnings(snapshot) {
@@ -11381,6 +13468,17 @@ function collectGeneratedCodeWarnings(snapshot) {
     if (!snapshot.nodes.some((node) => node.kind === "interaction")) {
         warnings.push("Scene has no interactions. Suggested fix: add interactions.orbit() for product/viewer scenes.");
     }
+    const flatNodes = groups.flatten(snapshot.nodes);
+    // muse3jsparity-PRD C1: procedural texture inputs have no rasterizer. The
+    // intent is compile-time known, so warn here; fetch outcomes stay dynamic.
+    for (const node of flatNodes) {
+        if (node.kind !== "primitive" || !node.material)
+            continue;
+        const label = node.name ?? `aura-primitive-${node.primitive}`;
+        for (const procedural of createProductionPrimitiveTextureIntent(node.material).proceduralInputs) {
+            warnings.push(`procedural texture ${procedural} on "${label}" has no rasterizer; recorded only, scalar material retained`);
+        }
+    }
     for (const node of snapshot.nodes) {
         if (node.kind === "model" && createAssetProvenance(node.asset).source === "unsafe-url") {
             warnings.push(`Model uses unsafeModelUrl("${node.asset.url}"). Suggested fix: run assets add and use typed assets.`);
@@ -11544,6 +13642,16 @@ function drawEffect(context, width, height, node, time) {
         context.fillStyle = toAlphaColor(node.color ?? "#9fb7d9", node.density ?? 0.12);
         context.fillRect(0, height * 0.2, width, height * 0.8);
     }
+    if (node.effect === "volumetric-fog") {
+        context.fillStyle = toAlphaColor(node.color ?? "#6f84b9", node.density ?? 0.18);
+        context.fillRect(0, height * 0.2, width, height * 0.8);
+        const anchor = node.lightPosition ?? [0.5, 0.18];
+        const glow = context.createRadialGradient(width * anchor[0], height * anchor[1], 8, width * anchor[0], height * anchor[1], width * 0.3);
+        glow.addColorStop(0, toAlphaColor(node.color ?? "#fff3d6", (node.intensity ?? 0.7) * 0.35));
+        glow.addColorStop(1, "rgba(255,255,255,0)");
+        context.fillStyle = glow;
+        context.fillRect(0, 0, width, height);
+    }
     if (node.effect === "bloom") {
         const gradient = context.createRadialGradient(width * 0.5, height * 0.45, 20, width * 0.5, height * 0.45, width * 0.46);
         gradient.addColorStop(0, toAlphaColor(node.color ?? "#ffffff", (node.intensity ?? 0.35) * 0.3));
@@ -11596,6 +13704,29 @@ function drawEffect(context, width, height, node, time) {
             }
         }
     }
+    if (node.effect === "snow") {
+        const density = Math.max(0.2, Math.min(1.6, node.density ?? node.intensity ?? 0.68));
+        const intensity = Math.max(0.1, Math.min(1.4, node.intensity ?? 0.4));
+        const color = node.color ?? "#e8f1ff";
+        if (node.mist !== false) {
+            context.fillStyle = toAlphaColor(color, Math.min(0.1, 0.03 + intensity * 0.04));
+            context.fillRect(0, height * 0.2, width, height * 0.72);
+        }
+        const drift = (node.wind?.[0] ?? -0.85) * 0.02;
+        for (let layer = 0; layer < 3; layer += 1) {
+            const count = Math.round((layer === 2 ? 30 : 52) * density);
+            const size = layer === 2 ? 3.1 : layer === 1 ? 2.2 : 1.4;
+            context.fillStyle = toAlphaColor(color, Math.min(0.85, 0.34 + intensity * (0.3 - layer * 0.06)));
+            for (let i = 0; i < count; i += 1) {
+                const sway = Math.sin(time * 0.0011 * (node.speed ?? 1) + i * 1.7 + layer) * (6 + layer * 5);
+                const x = (((i * 61 + layer * 197 + time * 0.008 * (node.speed ?? 1) * drift * 60) % width) + width) % width + sway * 0.14;
+                const y = ((i * 97 + layer * 131 + time * 0.028 * (node.speed ?? 1) * (1 + layer * 0.3)) % (height * 0.86)) + height * 0.06;
+                context.beginPath();
+                context.arc(x, y, size, 0, Math.PI * 2);
+                context.fill();
+            }
+        }
+    }
     if (node.effect === "particles") {
         const isFountain = node.emitter === "fountain";
         // Fountain cap matches prefabs.particleFountain's 2400 maximum so rendered counts never undercut the scene JSON.