@aura3d/engine 2.0.3 → 3.0.0

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

@@ -22,10 +22,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 { AURA_NORMALIZED_MODEL_MAX_DIMENSION, boundsFromAsset, boundsHeight, boundsMaxDimension, boundsSize } from "./SceneGroundingUtils.js";
+import { collectLabelTelemetry, summarizeTextBuckets } from "./LabelTelemetry.js";
 import { createWorldLabelLayer } from "./WorldLabelRenderer.js";
 import { createAuraText3DGeometry, defineAuraCustomGeometry, selectAuraRootLodLevel } from "./RootGeometry.js";
 export * from "./RootGeometry.js";
@@ -49,10 +50,27 @@ 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";
+/**
+ * Deliberate public surface for the shared arcade vehicle core. The racing kit
+ * owns the certified circuit path; exporting the bare motion helper lets routes
+ * such as showcase-courier-rush prove a different driving personality on their
+ * own topology without touching kit internals. Pinned by unit test.
+ */
+export { createGameArcadeVehicle } from "./GameRuntime.js";
 export * from "./PlatformerMotion.js";
 export * from "./CombatFrameData.js";
 export * from "./SceneQueries.js";
@@ -76,7 +94,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";
@@ -107,6 +134,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";
@@ -146,6 +174,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";
@@ -237,7 +267,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 = {}) {
@@ -329,15 +360,103 @@ export const instances = {
     plane: (options) => instancedPrimitive("plane", options),
     cylinder: (options) => instancedPrimitive("cylinder", options),
     capsule: (options) => instancedPrimitive("capsule", options),
-    torus: (options) => instancedPrimitive("torus", options)
+    torus: (options) => instancedPrimitive("torus", options),
+    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)
@@ -389,6 +508,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",
@@ -397,7 +523,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",
@@ -691,33 +839,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."
     },
     {
@@ -771,9 +927,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."
     },
     {
@@ -797,7 +953,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");
@@ -821,6 +979,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.`);
     }
@@ -1040,6 +1203,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",
@@ -1127,6 +1304,8 @@ export const camera = {
         position: options.position,
         target: options.target ?? [0, 1, 0],
         offset: options.offset,
+        targetOffset: options.targetOffset,
+        offsetMode: options.offsetMode,
         fov: options.fov ?? 50,
         easing: options.easing,
         captureTime: options.captureTime,
@@ -1247,8 +1426,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));
@@ -1304,7 +1485,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,10 +1507,22 @@ export const effects = {
         antiBlowout: options.antiBlowout ?? true,
         maxIntensity: options.maxIntensity ?? 0.92
     }),
-    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,
@@ -1351,6 +1547,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` is recorded but withheld (no history binding
+     * at root) with an explicit diagnostic 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 (muse3jsparity-PRD A3): recorded but withheld (no
+     * velocity binding at root) with an explicit diagnostic 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",
@@ -1363,6 +1635,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",
@@ -1388,6 +1716,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",
@@ -1638,7 +2121,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",
@@ -1764,6 +2264,7 @@ function normalizeCreateAppRendererOptions(options) {
         mode,
         fallback: options?.fallback ?? "safe-basic",
         qualityProfile: profile.id,
+        textureBudgetBytes: normalizeTextureBudgetBytes(options?.textureBudgetBytes),
         profile
     };
 }
@@ -1807,17 +2308,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;
+    // muse3jsparity-PRD A3: newly requestable root passes. motion-blur and
+    // taa-mode anti-alias are recorded but withheld (no velocity/history binding
+    // at root) — requestedPasses names the intent, actualPasses the execution.
+    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 taaWithheld = (antiAliasNode?.mode ?? "fxaa") === "taa";
+    const motionBlurWithheld = Boolean(motionBlurNode);
     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) || motionBlurWithheld || 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,
+            taaWithheld
+        });
     const runtimeStatus = !postprocessRequested
         ? "disabled"
         : runtime?.mounted
@@ -1832,6 +2358,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("motion-blur is recorded but withheld: root has no velocity binding, so no motion-blur pass is submitted");
+    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("anti-alias mode \"taa\" is recorded but withheld: root has no history binding, so no taa pass is submitted");
+    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)
@@ -1881,7 +2429,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
@@ -1896,7 +2445,8 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             nativeShadowMapBindings: runtime?.shadow?.nativeShadowMapBindings ?? 0,
             shadowRenderTargetsAllocated: runtime?.shadow?.shadowRenderTargetsAllocated ?? 0,
             contactShadows,
-            mapType: "pcf-soft"
+            mapType: "pcf-soft",
+            ...(runtime?.shadow?.spot === undefined ? {} : { spot: runtime.shadow.spot })
         },
         occlusion: {
             enabled: ambientOcclusion || contactOcclusion,
@@ -1911,7 +2461,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,
@@ -1927,6 +2479,7 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             actualPasses: runtimePostprocess?.actualPasses ?? [],
             fallbackPasses: runtimePostprocess?.fallbackPasses ?? [],
             targetFormat: runtimePostprocess?.targetFormat,
+            executionMode: runtimePostprocess?.executionMode ?? "unknown",
             evidence: postprocessEvidence
         },
         runtime: {
@@ -1940,13 +2493,39 @@ function createRendererDiagnosticReport(snapshot, runtime, rendererOptions) {
             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,
@@ -1954,14 +2533,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 (withheld: no velocity binding)");
+    if (extra.taaWithheld)
+        passes.push("taa (withheld: no history binding)");
     passes.push("output");
     return passes;
 }
@@ -6374,6 +6970,13 @@ 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.footPlantingConfigured !== undefined ? { footPlantingConfigured: input.footPlantingConfigured } : {}),
         diagnostics
     };
 }
@@ -6739,7 +7342,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;
     };
@@ -7707,6 +8312,13 @@ 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") {
@@ -7804,16 +8416,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,
@@ -7868,14 +8501,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",
@@ -7885,10 +8520,46 @@ function createProductionRuntimeEnvironmentFog(snapshot) {
         density,
         maxOpacity: clampNumber(0.25 + intensity * 0.55, 0, 0.92)
     };
+    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 } : {})
+    };
 }
-function createProductionRuntimePostprocess(snapshot) {
+function createProductionRuntimePostprocess(snapshot, lights = [], renderWidth = 1280, renderHeight = 720) {
     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
@@ -7898,6 +8569,17 @@ 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;
+    // muse3jsparity-PRD A3: color-grade / outline / fxaa / ssr / dof submit real
+    // native options. motion-blur and taa are withheld (velocity/history have no
+    // root binding): the status layer warns instead of submitting doomed options
+    // that would fail the route with zero draw calls.
+    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 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.
@@ -7906,7 +8588,10 @@ function createProductionRuntimePostprocess(snapshot) {
             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)))
+                radius: Math.max(1, Math.min(4, Math.round(authoredBloom?.radius ?? 2))),
+                ...(authoredBloom?.quality !== undefined ? { quality: authoredBloom.quality } : {}),
+                ...(authoredBloom?.softKnee !== undefined ? { softKnee: authoredBloom.softKnee } : {}),
+                ...(authoredBloom?.shoulder !== undefined ? { shoulder: authoredBloom.shoulder } : {})
             }
         } : {}),
         ...(authoredOcclusion ? {
@@ -7927,7 +8612,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) {
@@ -7980,6 +8699,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;
@@ -7992,7 +8784,8 @@ function createProductionRuntimePostprocessObservation(diagnostics) {
         pixelBacked,
         actualPasses,
         fallbackPasses: pixelBacked ? [] : ["direct-render"],
-        targetFormat: diagnostics.postprocessTargetFormat
+        targetFormat: diagnostics.postprocessTargetFormat,
+        executionMode: diagnostics.postprocessPlan?.executionMode ?? "unknown"
     };
 }
 function createProductionRuntimeCollectedLights(snapshot) {
@@ -8000,16 +8793,26 @@ 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) => {
+    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) {
+    return 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;
+        const priority = descriptor.shadowPriority + (descriptor.shadowRequested ? 10 : 0);
+        const currentPriority = current.shadowPriority + (current.shadowRequested ? 10 : 0);
+        if (priority !== currentPriority) {
+            return priority > currentPriority ? index : selected;
         }
         return descriptor.intensity > current.intensity ? index : selected;
     }, -1);
-    return descriptors.map((descriptor, index) => createProductionRuntimeCollectedLight(descriptor, index === shadowCasterIndex));
 }
 function createProductionRuntimeLightDescriptors(node, authoredIndex) {
     const name = node.name?.trim() || `aura-authored-${node.light}-${authoredIndex + 1}`;
@@ -8034,6 +8837,7 @@ function createProductionRuntimeLightDescriptors(node, authoredIndex) {
                 spotAngle: 0,
                 penumbra: 0,
                 shadowPriority: 3,
+                shadowRequested: false,
                 authoredLight: node.light
             }];
     }
@@ -8049,12 +8853,33 @@ 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 ?? 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)
@@ -8073,6 +8898,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
@@ -8102,6 +8928,7 @@ function createProductionRuntimeStudioLightDescriptors(node, name, color, intens
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 3,
+            shadowRequested: false,
             authoredLight: node.light
         },
         {
@@ -8115,6 +8942,7 @@ function createProductionRuntimeStudioLightDescriptors(node, name, color, intens
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: node.light
         },
         {
@@ -8128,6 +8956,7 @@ function createProductionRuntimeStudioLightDescriptors(node, name, color, intens
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: node.light
         }
     ];
@@ -8147,6 +8976,7 @@ function createProductionRuntimeFallbackLights() {
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 3,
+            shadowRequested: false,
             authoredLight: "fallback"
         },
         {
@@ -8160,6 +8990,7 @@ function createProductionRuntimeFallbackLights() {
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: "fallback"
         },
         {
@@ -8173,6 +9004,7 @@ function createProductionRuntimeFallbackLights() {
             spotAngle: 0,
             penumbra: 0,
             shadowPriority: 0,
+            shadowRequested: false,
             authoredLight: "fallback"
         }
     ];
@@ -8306,6 +9138,7 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
                     width: canvas.width,
                     height: canvas.height,
                     ...(node.hiddenNodeNames ? { hiddenNodeNames: node.hiddenNodeNames } : {}),
+                    ...(node.role === "primaryWorld" ? { consolidateStaticMeshes: true } : {}),
                     ...(node.material?.color ? {
                         tint: {
                             baseColor: colorToLinearRgba(node.material.color),
@@ -8338,53 +9171,142 @@ 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);
+    }).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), latestDeviceDiagnostics);
+        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);
+    };
     return {
         get backend() {
             return productionRenderer.backend;
@@ -8394,7 +9316,8 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
         },
         render(time) {
             runtimeWarnings.clear();
-            const input = createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, primitiveEntries, time, runtimeNodes, runtimeWarnings, productionEnvironment.lighting, productionRuntimeLights);
+            latestCameraEye = resolveCameraFrame(snapshot, snapshot.camera, time, runtimeNodes).eye;
+            const input = createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, primitiveEntries, time, runtimeNodes, runtimeWarnings, currentEnvironmentLighting, productionRuntimeLights);
             const result = productionRenderer.renderInteractiveFrame(input);
             latestDeviceDiagnostics = result.diagnostics;
             latestFeatures = result.features;
@@ -8416,13 +9339,15 @@ async function createProductionRuntimeSceneRenderer(canvas, snapshot, rendererOp
             return productionRenderer.deviceLost();
         },
         dispose() {
+            disposeHdriEnvironment?.();
             productionRenderer.dispose();
             for (const { actor } of actorEntries)
-                actor.pipeline.dispose();
+                actor.dispose();
             for (const { resources } of primitiveEntries) {
-                for (const { geometry, material } of resources) {
+                for (const { geometry, material, texturedMaterial } of resources) {
                     geometry.dispose();
                     material.dispose();
+                    texturedMaterial?.dispose();
                 }
             }
         }
@@ -8437,23 +9362,91 @@ function createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, pr
         const currentNode = currentState.node;
         if (currentNode.visible === false)
             continue;
+        const 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);
         applyProductionActorAnimation(entry, currentNode, currentState.animationBinding, time, 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);
+        // 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);
+        items.push(...actorItems.map((item) => ({ ...item, castShadow: currentNode.castShadow, ...modelInstanceAttach })));
         attachProductionActorEvidence(currentNode, entry.actor, actorItems, runtimeNodes);
     }
+    // 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 entry of primitiveEntries) {
         const currentState = resolveProductionPrimitiveRuntimeState(entry, runtimeNodes);
         if (!currentState.visible)
             continue;
         const resource = selectProductionPrimitiveResource(entry, currentState.node, cameraPosition);
+        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}`,
+            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) } : {})
         });
@@ -8465,9 +9458,12 @@ function createProductionRuntimeRendererInput(snapshot, canvas, actorEntries, pr
         frustumCulling: true,
         collectedLights,
         environmentLighting,
-        postprocess: createProductionRuntimePostprocess(snapshot),
+        // 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, collectedLights, canvas.width, canvas.height),
         shadow: createProductionRuntimeShadowOptions(snapshot, collectedLights),
-        environmentFog: createProductionRuntimeEnvironmentFog(snapshot),
+        environmentFog: createProductionRuntimeEnvironmentFog(snapshot, collectedLights, canvas.width, canvas.height),
         cameraPosition
     };
     const cameraLike = { viewProjectionMatrix };
@@ -8482,10 +9478,505 @@ 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.
+ */
+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);
+    return {
+        ...(baseColorUrl ? { baseColorUrl } : {}),
+        ...(normalUrl ? { normalUrl } : {}),
+        ...(roughnessUrl ? { roughnessUrl } : {}),
+        ...(metalnessUrl ? { metalnessUrl } : {}),
+        ...(occlusionUrl ? { occlusionUrl } : {}),
+        ...(emissiveUrl ? { emissiveUrl } : {}),
+        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.
+ */
+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}`);
+    return await createImageBitmap(await response.blob());
+}
+function bitmapRgbaPixels(bitmap) {
+    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) {
+    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].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);
+            }
+            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) {
+    const fail = (message) => new Error(message);
+    if (resource.material instanceof InstancedPBRMaterial) {
+        throw fail(`instanced primitives have no textured material variant for "${resource.name}"`);
+    }
+    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 [baseColorSource, normalSource, roughnessSource, metalnessSource, occlusionSource, emissiveSource] = await Promise.all([
+        intent.baseColorUrl ? loadProductionPrimitiveBitmap(intent.baseColorUrl) : Promise.resolve(undefined),
+        intent.normalUrl ? loadProductionPrimitiveBitmap(intent.normalUrl) : Promise.resolve(undefined),
+        intent.roughnessUrl ? loadProductionPrimitiveBitmap(intent.roughnessUrl) : Promise.resolve(undefined),
+        intent.metalnessUrl ? loadProductionPrimitiveBitmap(intent.metalnessUrl) : Promise.resolve(undefined),
+        intent.occlusionUrl ? loadProductionPrimitiveBitmap(intent.occlusionUrl) : Promise.resolve(undefined),
+        intent.emissiveUrl ? loadProductionPrimitiveBitmap(intent.emissiveUrl) : Promise.resolve(undefined)
+    ]);
+    const slots = [];
+    const baseColorTexture = baseColorSource
+        ? 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
+        ? 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 = new Texture({ width: size.width, height: size.height, data: composited, colorSpace: "linear", label: `${resource.name}-metallicroughness` });
+        slots.push("metallicRoughness");
+    }
+    const occlusionTexture = occlusionSource
+        ? 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
+        ? 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]
+        .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
+    });
+    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),
+        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
+            ? {
+                textureTexCoords: {
+                    ...(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 } : {})
+                }
+            }
+            : {})
+    });
+    resource.textureStatus = "textured";
+    resource.textureSlots = slots;
+}
+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)
@@ -8497,7 +9988,21 @@ 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) {
@@ -8509,6 +10014,14 @@ function selectProductionPrimitiveResource(entry, node, cameraPosition) {
     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) => {
@@ -8544,37 +10057,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);
@@ -8605,6 +10088,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.
@@ -8622,6 +10116,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,
@@ -8652,6 +10147,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,
@@ -8674,6 +10170,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();
@@ -8725,11 +10227,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);
 }
@@ -8770,6 +10285,39 @@ function applyProductionActorAnimation(entry, node, animationBinding, time, runt
         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, ...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;
@@ -8817,7 +10365,14 @@ 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],
+        footPlantingConfigured: actorEvidence.footPlantingConfigured
     });
 }
 function createProductionRuntimeMetadata(actorEntries, primitiveEntries) {
@@ -9130,7 +10685,12 @@ function findRuntimeCameraTarget(cameraSpec, runtimeNodes) {
         return undefined;
     const targetNode = cameraSpec.targetNode;
     const directHandle = runtimeNodes.get(targetNode);
-    if (directHandle && directHandle.visible !== false)
+    // An explicitly named target remains a valid camera anchor while hidden.
+    // Composition probes temporarily suppress the hero node to isolate its
+    // pixels; dropping that target here would also drop target-yaw rotation and
+    // move the camera between the visible and suppressed captures. Visibility
+    // controls drawing, not whether the camera can follow the requested node.
+    if (directHandle)
         return { position: directHandle.position, rotation: directHandle.rotation };
     const namedHandle = runtimeNodes.all().find((handle) => handle.visible !== false && (handle.name === targetNode || handle.tags.includes(targetNode)));
     return namedHandle ? { position: namedHandle.position, rotation: namedHandle.rotation } : undefined;
@@ -9257,7 +10817,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 });
@@ -9293,7 +10855,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.",
@@ -10529,6 +12092,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,
@@ -10549,10 +12114,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,
@@ -10580,7 +12156,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() {
@@ -10588,6 +12167,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;
@@ -10600,6 +12181,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) {
@@ -10612,11 +12195,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() {
@@ -11285,8 +12872,33 @@ function validateSceneAssets(snapshot, assets) {
 }
 function createAssetProvenance(asset) {
     const remote = /^https?:\/\//i.test(asset.url);
+    /*
+     * A deployment may rewrite the URL of a generated manifest asset to an
+     * immutable external asset host (for example, GitHub media or an object
+     * store) so the site bundle does not need to carry every GLB.  URL location
+     * is therefore not a sufficient trust signal: the manifest identity is the
+     * typed ref's kind/id/hash plus durable source-path provenance.  Keep
+     * `unsafeModelUrl(...)` blocked by its sentinel id, and do not bless an
+     * arbitrary remote object that merely happens to carry a hash.
+     */
+    const manifestPaths = [
+        asset.metadata?.provenance?.sourcePath,
+        asset.metadata?.sourcePath,
+        asset.metadata?.outputPath,
+        asset.metadata?.provenance?.outputPath
+    ];
+    const hasDurableManifestProvenance = asset.kind === "aura-asset-ref"
+        && asset.id !== "unsafe"
+        && typeof asset.hash === "string"
+        && asset.hash.length > 0
+        && manifestPaths.some((value) => typeof value === "string" && value.replaceAll("\\", "/").startsWith("public/aura-assets/"));
+    const trustedManifestAsset = !remote || hasDurableManifestProvenance;
     return {
-        source: asset.id === "unsafe" || remote ? "unsafe-url" : asset.hash ? "typed-aura-assets-manifest" : "inline-definition",
+        source: asset.id === "unsafe" || !trustedManifestAsset
+            ? "unsafe-url"
+            : asset.hash
+                ? "typed-aura-assets-manifest"
+                : "inline-definition",
         id: asset.id,
         url: asset.url,
         ...(asset.hash ? { hash: asset.hash } : {}),
@@ -11325,7 +12937,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) {
@@ -11336,6 +12950,27 @@ 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.");
     }
+    // muse3jsparity-PRD A3: withheld postprocess intents must warn on the
+    // mounted channel too (plan-level warnings never reach app.diagnostics()).
+    const flatNodes = groups.flatten(snapshot.nodes);
+    const hasEffect = (effect) => flatNodes.some((node) => node.kind === "effect" && node.effect === effect);
+    if (hasEffect("motion-blur")) {
+        warnings.push("motion-blur is recorded but withheld: root has no velocity binding, so no motion-blur pass is submitted");
+    }
+    const antiAlias = flatNodes.find((node) => node.kind === "effect" && node.effect === "anti-alias");
+    if (antiAlias && (antiAlias.mode ?? "fxaa") === "taa") {
+        warnings.push("anti-alias mode \"taa\" is recorded but withheld: root has no history binding, so no taa pass is submitted");
+    }
+    // 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.`);
@@ -11499,6 +13134,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));
@@ -11551,6 +13196,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.