@forgeax/engine-render 0.1.19 → 0.1.20

package/dist/construct-renderer.mjs

@@ -1,11 +1,11 @@
 import { GlyphText, selectActiveCameraIndex, getActiveCamera } from './chunk-FJ6P52EE.mjs';
-import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Camera, DirectionalLight, PointLight, PointLightShadow, SpotLight, Skylight, SkyboxBackground, PostProcessParams, admitPointsLines, Fog, resolveVisibility, Atmosphere, Points, Lines, SortKey, pointShapeFromU32, CAMERA_PROJECTION_ORTHOGRAPHIC, MotionBlur, bloomEnabledFromF32, antialiasFromF32, tonemapFromF32, cameraProjectionFromF32, tonemapToU32 } from './chunk-YTQ5C7YQ.mjs';
+import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Camera, DirectionalLight, PointLight, PointLightShadow, SpotLight, Skylight, SkyboxBackground, PostProcessParams, VolumetricFog, inspectVolumetricFog, admitPointsLines, hasVolumetricFogCapability, Fog, resolveVisibility, Atmosphere, Points, Lines, SortKey, pointShapeFromU32, CAMERA_PROJECTION_ORTHOGRAPHIC, resolveSelectedVolumetricLight, extractVolumetricFog, MotionBlur, bloomEnabledFromF32, antialiasFromF32, tonemapFromF32, cameraProjectionFromF32, tonemapToU32 } from './chunk-CDTWTHZR.mjs';
 import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap } from './chunk-JDWARUOI.mjs';
-import { SKIN_MATERIAL_SHADER_ID, assertStorageBufferCap, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveMipUploadLayout, deriveRenderDataCubemap, createIblPipelines, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, CUBEMAP_FACE_VERTICES, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_COPY_DST, runIblPrecompute, GPU_BUFFER_USAGE_INDEX, createClusterBinScratch, GPU_BUFFER_USAGE_UNIFORM, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, retireTemporalGpuState, PostProcessError, resolveSsaoParameters, buildPerFrameBindGroups, PipelineSpecError, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, createHdrpBindGroupLayoutDescriptor, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, createPointsLinesLaneAdapter, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, writeHdrpClusterAndSsaoBuffers, warnZeroLightStandard, writeShadowParamsBuffer, computeProjectionMatrix, computeViewMatrix, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, writePointSpotLightBuffers, uploadMeshSsboBatch, colorFormatsForPassKind, configureSurface, buildPbrPipelineLayouts, buildPbrSkinLayouts, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, GPU_BUFFER_USAGE_STORAGE, FALLBACK_BYTES_PER_ROW, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_SHADER_STAGE_FRAGMENT, geometryRenderStateForTopology, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, createPointsLinesLaneContract, foldDispatchBuckets, variantSetFromDefines, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, buildBindGroupLayoutDescriptor, LIGHT_ARRAY_HEADER_BYTES, POINT_LIGHT_STD430_BYTES, LIGHT_ARRAY_MAX_SLOTS, SPOT_LIGHT_STD430_BYTES, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_INDIRECT, selectPasses, isStandardPbrMaterialShader, resolveSurfaceFormatPair, resolveSurfaceProfile, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, isSkinnedShadowCasterVariant, getTemporalGpuState, temporalReadIndex, temporalWriteIndex, GPU_SHADER_STAGE_VERTEX, importRenderPipelineSurface, aggregateTemporalDemand, addTypedSkyboxPass, addTypedScenePass, standardTemporalLaneAdmission, createStandardSceneDataTarget, addStandardSceneDataPass, addTypedFrameObservationPass, DEFERRED_COLOR_FORMATS, addTypedSsaoPasses, typedFrameClearColor, createRenderPipelineTarget, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateHdrpBuffers, buildFullscreenPostProcessPass, MATERIAL_PER_ENTITY_STRIDE, PREFILTER_SIZE, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSnapshotToUbo, residentTextureView, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-RJRUS55L.mjs';
+import { SKIN_MATERIAL_SHADER_ID, assertStorageBufferCap, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, CUBEMAP_FACE_VERTICES, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_COPY_DST, runIblPrecompute, GPU_BUFFER_USAGE_INDEX, createClusterBinScratch, GPU_BUFFER_USAGE_UNIFORM, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, retireTemporalGpuState, PostProcessError, resolveSsaoParameters, buildPerFrameBindGroups, PipelineSpecError, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, createHdrpBindGroupLayoutDescriptor, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, createPointsLinesLaneAdapter, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, writeHdrpClusterAndSsaoBuffers, warnZeroLightStandard, writeShadowParamsBuffer, computeProjectionMatrix, computeViewMatrix, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, writePointSpotLightBuffers, uploadMeshSsboBatch, colorFormatsForPassKind, configureSurface, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_MAP_READ, buildPbrPipelineLayouts, buildPbrSkinLayouts, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, GPU_BUFFER_USAGE_STORAGE, FALLBACK_BYTES_PER_ROW, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_SHADER_STAGE_FRAGMENT, geometryRenderStateForTopology, GPU_TEXTURE_USAGE_COPY_SRC, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, createPointsLinesLaneContract, foldDispatchBuckets, variantSetFromDefines, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, buildBindGroupLayoutDescriptor, LIGHT_ARRAY_HEADER_BYTES, POINT_LIGHT_STD430_BYTES, LIGHT_ARRAY_MAX_SLOTS, SPOT_LIGHT_STD430_BYTES, GPU_BUFFER_USAGE_INDIRECT, selectPasses, isStandardPbrMaterialShader, resolveSurfaceFormatPair, resolveSurfaceProfile, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, buildPbrMaterialUserRegionEntries, isSkinnedShadowCasterVariant, getTemporalGpuState, temporalReadIndex, temporalWriteIndex, GPU_SHADER_STAGE_VERTEX, importRenderPipelineSurface, aggregateTemporalDemand, addTypedSkyboxPass, addTypedScenePass, standardTemporalLaneAdmission, createStandardSceneDataTarget, addStandardSceneDataPass, addTypedFrameObservationPass, DEFERRED_COLOR_FORMATS, addTypedSsaoPasses, typedFrameClearColor, createRenderPipelineTarget, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, VIEW_UNIFORM_BYTES, getOrCreateHdrpBuffers, buildFullscreenPostProcessPass, MATERIAL_PER_ENTITY_STRIDE, PREFILTER_SIZE, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSnapshotToUbo, residentTextureView, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-4XINDLAY.mjs';
 import { getTransparentSortConfig, TRANSPARENT_SORT_MODE_DISTANCE, TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ } from './chunk-RXZ3RGOU.mjs';
-import { RendererContractFailureError, RendererOperationError, DEFAULT_STANDARD_PROFILE, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, RENDER_PHASE_CATALOG, DEFAULT_CLUSTER_GRID, resolveStandardLane, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderFeatureRegistrationConflictError, LifecycleConstructionError, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, TransmissionCapabilityMissingError, createSceneDataCatalog, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, ObservationUnavailableError, SkinMaterialMismatchError, MaterialSkinAttrMissingError, RenderFeaturePreparationFailedError, PointsLinesPrepareFailedError, EnvironmentSourceConflictError, FogCardinalityError, ShadowInvalidConfigError, AtmosphereInvalidParameterError, RenderFeaturePreparedStateMismatchError, RenderFeatureDrawRecordingFailedError, SceneDataUnavailableError, HdrpDeferredCapsInsufficientError, SkinPaletteOverflowError, PointShadowAtlasUninitializedError, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, isSceneDataTarget } from './chunk-LOSO4CTV.mjs';
+import { RendererContractFailureError, RendererOperationError, DEFAULT_STANDARD_PROFILE, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, RENDER_PHASE_CATALOG, DEFAULT_CLUSTER_GRID, resolveStandardLane, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderFeatureRegistrationConflictError, LifecycleConstructionError, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, TransmissionCapabilityMissingError, createSceneDataCatalog, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, TemporalFrameSubmitError, ObservationUnavailableError, SkinMaterialMismatchError, MaterialSkinAttrMissingError, RenderFeaturePreparationFailedError, PointsLinesPrepareFailedError, EnvironmentSourceConflictError, FogCardinalityError, ShadowInvalidConfigError, resolveVolumetricFogProfile, AtmosphereInvalidParameterError, RenderFeaturePreparedStateMismatchError, RenderFeatureDrawRecordingFailedError, SceneDataUnavailableError, HdrpDeferredCapsInsufficientError, SkinPaletteOverflowError, PointShadowAtlasUninitializedError, MAX_LIGHTS, CLUSTER_GRID_STRIDE_U32, LIGHT_INDEX_LIST_CAPACITY, isSceneDataTarget } from './chunk-TBQJOK2L.mjs';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-VFPLTKCU.mjs';
-import { getTextureIdentity, worldEntityKey, makeZeroCameraFallbackSnapshot } from './chunk-IPXCABEP.mjs';
+import { getTextureIdentity, worldEntityKey, makeZeroCameraFallbackSnapshot } from './chunk-M2MP4ZOU.mjs';
 import { AssetRegistry, DynamicTextureStore, adaptDynamicTextureDevice, getOrCreateMipmapPipeline, blitMipmapsSync, HANDLE_CUBE, HANDLE_TRIANGLE, HANDLE_QUAD, HANDLE_SPHERE, HANDLE_NINESLICE_QUAD, BuiltinAssetRegistry, numMipLevels, resolveAssetHandle, walkMaterialPassesOverSharedRefs, encodeMipmapLevel, resolveTilesetRuntime, MeshSsboCeilingReachedError, MeshSsboCapacityExceededError } from '@forgeax/engine-assets-runtime';
 import { audioLoader } from '@forgeax/engine-audio-webaudio';
 import { Update } from '@forgeax/engine-ecs';
@@ -14,8 +14,8 @@ import { PROCEDURAL_FLOATS_PER_VERTEX, deriveVertexLayoutProjection, deriveVerte
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import { ok, err, RhiError, validateDrawArgs } from '@forgeax/engine-rhi';
 import { Transform, ChildOf, collectSubtree, Name, registerPropagateTransforms, Children, projectHierarchy, MorphWeights } from '@forgeax/engine-scene';
-import { ShaderCatalog, findVariantByKey } from '@forgeax/engine-shader';
-import { err as err$1, ok as ok$1, derive, handleSlot, toShared, ASSET_ERROR_HINTS, countExtraUvSets, RenderQueue, IMAGE_ERROR_HINTS, AssetError, materialValuesToLinearRuntime, unpackSlot, TextError, unwrapHandle, materialGuidText } from '@forgeax/engine-types';
+import { ShaderCatalog, findVariantByKey, DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
+import { err as err$1, ok as ok$1, derive, handleSlot, toShared, deriveTextureLayout, ASSET_ERROR_HINTS, countExtraUvSets, RenderQueue, IMAGE_ERROR_HINTS, AssetError, materialValuesToLinearRuntime, unpackSlot, TextError, unwrapHandle, materialGuidText } from '@forgeax/engine-types';
 import { vec3, halfFloat, mat4, frustum, box3 } from '@forgeax/engine-math';
 import { resetFontConcurrency, decodeTileBits, trackFontConcurrency, layoutGlyphText, conservativeCubeAabb, bakeGlyphMesh } from '@forgeax/engine-graphics-extras';
 import { createCurrentFrameObservationLease, RenderGraphError, RenderGraphBuilder } from '@forgeax/engine-render-graph';
@@ -200,6 +200,8 @@ var GpuResidencyCache = class {
   // Hardware-probe caps injected at `configureGpuDevice`; guards the HDR cubemap
   // path (_uploadCubemapFromEquirect) when `rgba16floatRenderable` is false.
   caps = void 0;
+  deviceEpoch = 0;
+  textureGeneration = 0;
   textureGpuHandles = /* @__PURE__ */ new Map();
   samplerGpuHandles = /* @__PURE__ */ new Map();
   cubemapGpuHandles = /* @__PURE__ */ new Map();
@@ -235,6 +237,12 @@ var GpuResidencyCache = class {
    * the pull model builds resources lazily at first `ensureResident` access.
    */
   configureGpuDevice(device, asyncCreateShaderModule, registerCube, caps) {
+    for (const entry of this.textureGpuHandles.values()) {
+      if (!entry.texture.isDestroyed) entry.texture.destroy();
+    }
+    if (this.textureGpuHandles.size > 0) this.materialResourceEpoch += 1;
+    this.textureGpuHandles.clear();
+    this.deviceEpoch += 1;
     this.meshResidencyEpoch += 1;
     this.gpuDevice = device;
     this.asyncCreateShaderModule = asyncCreateShaderModule;
@@ -673,7 +681,7 @@ var GpuResidencyCache = class {
     const { tex, levels, gpuTexture } = prepared.value;
     const cacheKey = this.worldKey(handleSlot(handle), worldId);
     if (gpuTexture === void 0) return ok(void 0);
-    if (!projected.value.compressed && decoded.mipmap === true && levels > 1) {
+    if (!projected.value.compressed && tex.mips.kind === "generate" && levels > 1) {
       const factory = this.asyncCreateShaderModule;
       if (factory === void 0) {
         return err(
@@ -696,21 +704,22 @@ var GpuResidencyCache = class {
       }
       const blitRes = blitMipmapsSync(device, gpuTexture, {
         format: tex.format,
-        width: tex.width,
-        height: tex.height,
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
         levels
       });
       if (!blitRes.ok) return blitRes;
     }
     const viewRes = device.createTextureView(gpuTexture, {
       label: `texture-view-${cacheKey}`,
-      dimension: "2d"
+      dimension: projected.value.shape.viewDimension
     });
     if (!viewRes.ok) return viewRes;
     const previous = this.textureGpuHandles.get(cacheKey);
     const next = {
       texture: this.wrapTex(gpuTexture),
-      view: viewRes.value
+      view: viewRes.value,
+      receipt: this.textureReceipt(pod, projected.value)
     };
     this.textureGpuHandles.set(cacheKey, next);
     this.materialResourceEpoch += 1;
@@ -740,21 +749,25 @@ var GpuResidencyCache = class {
     }
     const { tex, levels, gpuTexture } = prepared.value;
     const cacheKey = this.worldKey(handleSlot(handle), worldId);
-    if (!renderData.compressed && decoded.mipmap === true && levels > 1) {
+    if (!renderData.compressed && tex.mips.kind === "generate" && levels > 1) {
       const blitRes = blitMipmapsSync(device, gpuTexture, {
         format: tex.format,
-        width: tex.width,
-        height: tex.height,
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
         levels
       });
       if (!blitRes.ok) return blitRes;
     }
     const viewRes = device.createTextureView(gpuTexture, {
       label: `texture-view-${cacheKey}`,
-      dimension: "2d"
+      dimension: renderData.shape.viewDimension
     });
     if (!viewRes.ok) return viewRes;
-    const entry = { texture: this.wrapTex(gpuTexture), view: viewRes.value };
+    const entry = {
+      texture: this.wrapTex(gpuTexture),
+      view: viewRes.value,
+      receipt: this.textureReceipt(pod, renderData)
+    };
     const previous = this.textureGpuHandles.get(cacheKey);
     this.textureGpuHandles.set(cacheKey, entry);
     this.materialResourceEpoch += 1;
@@ -763,6 +776,21 @@ var GpuResidencyCache = class {
     }
     return ok(entry);
   }
+  textureReceipt(pod, renderData) {
+    return {
+      shape: pod.shape,
+      format: renderData.format,
+      extent: {
+        width: renderData.physicalExtent.width,
+        height: renderData.physicalExtent.height,
+        depthOrArrayLayers: renderData.depthOrArrayLayers
+      },
+      bytes: pod.data.byteLength,
+      view: renderData.shape.viewDimension,
+      generation: ++this.textureGeneration,
+      deviceEpoch: this.deviceEpoch
+    };
+  }
   /**
    * Shared texture-upload prelude: format / colorSpace consistency assertion,
    * GPU texture allocation + writeTexture. Returns `gpuTexture: undefined`
@@ -789,13 +817,17 @@ var GpuResidencyCache = class {
     if (device === void 0) {
       return ok({ id, tex, levels, gpuTexture: void 0 });
     }
-    const maxDimension = device.limits.maxTextureDimension2D;
-    if (tex.width > maxDimension || tex.height > maxDimension) {
+    const maxDimension = tex.shape.viewDimension === "3d" ? device.limits.maxTextureDimension3D : device.limits.maxTextureDimension2D;
+    const width = tex.shape.extent.width;
+    const height = tex.shape.extent.height;
+    const layers = renderData.depthOrArrayLayers;
+    const exceedsLayerLimit = tex.shape.viewDimension === "2d-array" && layers > device.limits.maxTextureArrayLayers;
+    if (width > maxDimension || height > maxDimension || exceedsLayerLimit) {
       return err(
         makeImageError({
           code: "image-dimension-out-of-bounds",
-          requested: { width: tex.width, height: tex.height },
-          limit: maxDimension
+          requested: { width, height },
+          limit: exceedsLayerLimit ? device.limits.maxTextureArrayLayers : maxDimension
         })
       );
     }
@@ -804,11 +836,11 @@ var GpuResidencyCache = class {
       size: {
         width: renderData.physicalExtent.width,
         height: renderData.physicalExtent.height,
-        depthOrArrayLayers: 1
+        depthOrArrayLayers: renderData.depthOrArrayLayers
       },
       mipLevelCount: levels,
       sampleCount: 1,
-      dimension: "2d",
+      dimension: tex.shape.viewDimension === "3d" ? "3d" : "2d",
       format: renderData.format,
       usage: renderData.usage,
       viewFormats: [],
@@ -818,25 +850,74 @@ var GpuResidencyCache = class {
     const gpuTexture = createTexRes.value;
     const queue = device.queue;
     if (renderData.compressed) {
-      const layout = deriveMipUploadLayout(renderData.format, tex.width, tex.height, levels);
-      for (const lvl of layout) {
-        const slice = decoded.bytes.subarray(lvl.byteOffset, lvl.byteOffset + lvl.byteLength);
-        const writeRes = queue.writeTexture(
-          { texture: gpuTexture, mipLevel: lvl.level, origin: { x: 0, y: 0, z: 0 } },
-          slice,
-          { offset: 0, bytesPerRow: lvl.bytesPerRow, rowsPerImage: lvl.rowsPerImage },
-          { width: lvl.copyWidth, height: lvl.copyHeight, depthOrArrayLayers: 1 }
+      const layout = deriveTextureLayout({
+        shape: tex.shape,
+        format: renderData.format,
+        mips: tex.mips
+      });
+      if (!layout.ok) {
+        return err(
+          makeAssetError({
+            code: "invalid-source-format",
+            expected: layout.error.expected,
+            hint: layout.error.hint
+          })
         );
-        if (!writeRes.ok) return writeRes;
+      }
+      for (const level of layout.value.levels) {
+        for (let image = 0; image < level.imagesPerMip; image++) {
+          const imageBytes = level.bytesPerRow * level.rowsPerImage;
+          const offset2 = level.byteOffset + image * imageBytes;
+          const slice = decoded.bytes.subarray(offset2, offset2 + imageBytes);
+          const writeRes = queue.writeTexture(
+            {
+              texture: gpuTexture,
+              mipLevel: level.level,
+              origin: { x: 0, y: 0, z: image }
+            },
+            slice,
+            { offset: 0, bytesPerRow: level.bytesPerRow, rowsPerImage: level.rowsPerImage },
+            {
+              width: level.physicalWidth,
+              height: level.physicalHeight,
+              depthOrArrayLayers: 1
+            }
+          );
+          if (!writeRes.ok) return writeRes;
+        }
       }
       return ok({ id, tex, levels, gpuTexture });
     }
-    const bytesPerRow = renderData.bytesPerRow;
+    const textureLayout = deriveTextureLayout({
+      shape: tex.shape,
+      format: renderData.format,
+      mips: tex.mips
+    });
+    if (!textureLayout.ok) {
+      return err(
+        makeAssetError({
+          code: "invalid-source-format",
+          expected: textureLayout.error.expected,
+          hint: textureLayout.error.hint
+        })
+      );
+    }
+    const baseLevel = textureLayout.value.levels[0];
+    if (baseLevel === void 0) {
+      return err(
+        makeAssetError({
+          code: "invalid-source-format",
+          expected: "texture layout contains a base mip level",
+          hint: ASSET_ERROR_HINTS["invalid-source-format"]
+        })
+      );
+    }
+    const bytesPerRow = baseLevel.bytesPerRow;
     const writeTextureRes = queue.writeTexture(
       { texture: gpuTexture, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
       decoded.bytes,
-      { offset: 0, bytesPerRow, rowsPerImage: tex.height },
-      { width: tex.width, height: tex.height, depthOrArrayLayers: 1 }
+      { offset: 0, bytesPerRow, rowsPerImage: height },
+      { width, height, depthOrArrayLayers: renderData.depthOrArrayLayers }
     );
     if (!writeTextureRes.ok) return writeTextureRes;
     return ok({ id, tex, levels, gpuTexture });
@@ -913,14 +994,18 @@ var GpuResidencyCache = class {
       view: void 0,
       faceViews: []
     });
+    const sourceData = sourcePod.data instanceof Uint8ClampedArray ? new Uint8Array(
+      sourcePod.data.buffer,
+      sourcePod.data.byteOffset,
+      sourcePod.data.byteLength
+    ) : sourcePod.data;
     const sourceTex = {
       kind: "texture",
-      width: sourcePod.width,
-      height: sourcePod.height,
+      shape: { viewDimension: "2d", extent: { width: sourcePod.width, height: sourcePod.height } },
       format: sourcePod.format,
-      data: sourcePod.data,
+      data: sourceData,
       colorSpace: sourcePod.colorSpace,
-      mipmap: false
+      mips: { kind: "none" }
     };
     const projected = (() => {
       const p = deriveRenderDataCubemap(sourceTex);
@@ -936,16 +1021,9 @@ var GpuResidencyCache = class {
       );
     }
     const tex = projected.needsHalfConversion ? {
-      width: sourceTex.width,
-      height: sourceTex.height,
+      shape: sourceTex.shape,
       format: projected.outputFormat,
-      data: halfFloat.f32ToF16Bytes(
-        sourceTex.data instanceof Uint8ClampedArray ? new Uint8Array(
-          sourceTex.data.buffer,
-          sourceTex.data.byteOffset,
-          sourceTex.data.byteLength
-        ) : sourceTex.data
-      )} : sourceTex;
+      data: halfFloat.f32ToF16Bytes(sourceTex.data)} : sourceTex;
     const cubeFaceSize = projected.cubeFaceSize;
     const outputFormat = this.caps?.rgba16floatRenderable === false ? "rgba8unorm" : tex.format;
     const device = this.iblDevice;
@@ -1034,7 +1112,11 @@ var GpuResidencyCache = class {
     }
     const equirectTextureResult = device.createTexture({
       label: `equirect-${sourceId}`,
-      size: { width: tex.width, height: tex.height, depthOrArrayLayers: 1 },
+      size: {
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
+        depthOrArrayLayers: 1
+      },
       mipLevelCount: 1,
       sampleCount: 1,
       dimension: "2d",
@@ -1055,8 +1137,15 @@ var GpuResidencyCache = class {
     const equirectWriteResult = device.queue.writeTexture(
       { texture: equirectGpuTex },
       tex.data,
-      { bytesPerRow: tex.width * bytesPerPixel, rowsPerImage: tex.height },
-      { width: tex.width, height: tex.height, depthOrArrayLayers: 1 }
+      {
+        bytesPerRow: tex.shape.extent.width * bytesPerPixel,
+        rowsPerImage: tex.shape.extent.height
+      },
+      {
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
+        depthOrArrayLayers: 1
+      }
     );
     if (!equirectWriteResult.ok) return recordFailed(equirectWriteResult.error);
     const faceBufferResult = createFaceUniformsBuffer(device);
@@ -1268,14 +1357,13 @@ var GpuResidencyCache = class {
   }
 };
 function decodedFromTexture(tex) {
-  const bytes2 = tex.data instanceof Uint8ClampedArray ? new Uint8Array(tex.data.buffer, tex.data.byteOffset, tex.data.byteLength) : tex.data;
   return {
-    bytes: bytes2,
-    width: tex.width,
-    height: tex.height,
+    bytes: tex.data,
+    width: tex.shape.extent.width,
+    height: tex.shape.extent.height,
     mime: "image/png",
     colorSpace: tex.colorSpace,
-    mipmap: tex.mipmap
+    mipmap: tex.mips.kind === "generate"
   };
 }
 
@@ -3619,6 +3707,16 @@ function addTransmissionBackdropTemporalPass(graph, source) {
     encode: () => void 0
   });
 }
+
+// src/typed-shadow-atlas.ts
+function resolveDirectionalShadowAtlasGrid(cascadeCount) {
+  const count = Math.max(1, Math.min(4, Math.round(cascadeCount)));
+  if (count === 1) return { columns: 1, rows: 1 };
+  if (count === 2) return { columns: 2, rows: 1 };
+  return { columns: 2, rows: 2 };
+}
+
+// src/typed-shadow-passes.ts
 function recordShadowPass(graph, name, target4, loadOp, encode, executeIf) {
   return graph.addRasterPass(name, {
     accesses: [{ resource: target4.view, usage: "depth-stencil-write" }],
@@ -3634,18 +3732,18 @@ function recordShadowPass(graph, name, target4, loadOp, encode, executeIf) {
   });
 }
 function addTypedShadowPasses(graph, topology) {
-  const tilesPerSide = Math.ceil(Math.sqrt(topology.shadow.cascadeCount));
+  const atlasGrid = resolveDirectionalShadowAtlasGrid(topology.shadow.cascadeCount);
   const directional = createRenderPipelineTarget(graph, "directional-shadow-depth", {
     format: "depth32float",
     size: {
-      width: topology.shadow.mapSize * tilesPerSide,
-      height: topology.shadow.mapSize * tilesPerSide
+      width: topology.shadow.mapSize * atlasGrid.columns,
+      height: topology.shadow.mapSize * atlasGrid.rows
     }
   });
   if (!directional.ok) return directional;
   for (let cascade = 0; cascade < topology.shadow.cascadeCount; cascade += 1) {
-    const col = cascade % tilesPerSide;
-    const row = Math.floor(cascade / tilesPerSide);
+    const col = cascade % atlasGrid.columns;
+    const row = Math.floor(cascade / atlasGrid.columns);
     const added = recordShadowPass(
       graph,
       `shadowCascade${cascade}`,
@@ -3747,6 +3845,656 @@ function addTypedShadowPasses(graph, topology) {
   }
   return ok$1({ directional: directional.value, spot: spot.value, point });
 }
+var VOLUME_FROXEL_FORMAT = "rgba8unorm";
+var VOLUME_HISTORY_FORMAT = "rgba16float";
+var VOLUME_RESOLVED_FORMAT = "rgba16float";
+var VOLUME_PACKING_Z = 4;
+var VOLUMETRIC_FOG_PARAMS_BYTES = 8 * 16;
+function deriveVolumetricFogExtent(surface, depth = 64, tileSize = 4) {
+  const physicalTileSize = Math.max(2, Math.floor(tileSize / 2));
+  return {
+    width: Math.max(1, Math.ceil(surface.width / physicalTileSize)),
+    height: Math.max(1, Math.ceil(surface.height / physicalTileSize)),
+    depth: Math.max(1, depth)
+  };
+}
+function deriveVolumetricFogResolvedExtent(surface, froxelTileSize = 4) {
+  const resolveTileSize = froxelTileSize === 4 ? 8 : Math.max(1, froxelTileSize);
+  return deriveVolumetricFogExtent(surface, 1, resolveTileSize);
+}
+function inspectVolumetricFogResources(graph, options = {}) {
+  const volumeResources = graph.resources.filter(
+    (resource) => resource.label === "volume-froxel" || resource.label === "volume-resolved-current" || resource.label === "volume-history" || resource.label === "volume-temporal" || resource.label === "volume-params"
+  );
+  const bytes2 = (label) => volumeResources.filter((resource) => resource.label === label).reduce((total, resource) => total + (resource.byteSize ?? 0), 0);
+  const graphParameterResources = volumeResources.filter(
+    (resource) => resource.label === "volume-params"
+  );
+  const graphParameterBufferCount = graphParameterResources.length;
+  const parameterBufferCount = Math.max(
+    0,
+    Math.floor(options.parameterBufferCount ?? graphParameterBufferCount)
+  );
+  const froxel = volumeResources.find((resource) => resource.label === "volume-froxel");
+  const froxelExtent = froxel?.extent;
+  const resolvedExtent = volumeResources.find(
+    (resource) => resource.label === "volume-resolved-current"
+  )?.extent;
+  const currentBytes = bytes2("volume-resolved-current");
+  const historyBytes = bytes2("volume-history") + bytes2("volume-temporal");
+  const scratchBytes = bytes2("volume-froxel");
+  const bufferBytes = parameterBufferCount * VOLUMETRIC_FOG_PARAMS_BYTES;
+  const physicalAllocations = /* @__PURE__ */ new Set();
+  for (const resource of volumeResources) {
+    if (resource.label === "volume-params") continue;
+    physicalAllocations.add(resource.physicalAllocationKey ?? resource.label);
+  }
+  const totalBytes = currentBytes + historyBytes + scratchBytes + bufferBytes;
+  return Object.freeze({
+    generation: graph.generation,
+    liveResourceCount: volumeResources.length - graphParameterBufferCount + parameterBufferCount,
+    currentBytes,
+    historyBytes,
+    scratchBytes,
+    bufferBytes,
+    totalBytes,
+    physicalResourceCount: physicalAllocations.size + parameterBufferCount,
+    sampleCount: froxelExtent === void 0 ? 0 : froxelExtent.width * froxelExtent.height * froxelExtent.depthOrArrayLayers * VOLUME_PACKING_Z,
+    resolvedPixelCount: resolvedExtent === void 0 ? 0 : resolvedExtent.width * resolvedExtent.height
+  });
+}
+function textureDescriptor(format, extent) {
+  return {
+    format,
+    size: {
+      width: extent.width,
+      height: extent.height,
+      depthOrArrayLayers: Math.ceil(extent.depth / VOLUME_PACKING_Z)
+    },
+    dimension: "2d"
+  };
+}
+function resolvedDescriptor(extent) {
+  return {
+    format: VOLUME_RESOLVED_FORMAT,
+    size: { width: extent.width, height: extent.height, depthOrArrayLayers: 1 },
+    dimension: "2d"
+  };
+}
+function createVolumetricFogResources(graph, extent = { width: 64, height: 64, depth: 64 }, resolvedExtent) {
+  const effectiveResolvedExtent = resolvedExtent ?? {
+    width: extent.width,
+    height: extent.height,
+    depth: 1
+  };
+  const froxel = graph.createTexture(
+    "volume-froxel",
+    textureDescriptor(VOLUME_FROXEL_FORMAT, extent)
+  );
+  if (!froxel.ok) return froxel;
+  const froxelView = graph.view(froxel.value, {
+    label: "volume-froxel.view",
+    dimension: "2d-array",
+    baseArrayLayer: 0,
+    arrayLayerCount: Math.ceil(extent.depth / VOLUME_PACKING_Z)
+  });
+  if (!froxelView.ok) return froxelView;
+  const resolved2 = graph.createTexture(
+    "volume-resolved-current",
+    resolvedDescriptor(effectiveResolvedExtent)
+  );
+  if (!resolved2.ok) return resolved2;
+  const resolvedView = graph.view(resolved2.value, {
+    label: "volume-resolved-current.view",
+    dimension: "2d"
+  });
+  if (!resolvedView.ok) return resolvedView;
+  const history = graph.createTexture(
+    "volume-history",
+    resolvedDescriptor(effectiveResolvedExtent)
+  );
+  if (!history.ok) return history;
+  const historyView = graph.view(history.value, { label: "volume-history.view", dimension: "2d" });
+  if (!historyView.ok) return historyView;
+  const temporal = graph.createTexture(
+    "volume-temporal",
+    resolvedDescriptor(effectiveResolvedExtent)
+  );
+  if (!temporal.ok) return temporal;
+  const temporalView = graph.view(temporal.value, {
+    label: "volume-temporal.view",
+    dimension: "2d"
+  });
+  if (!temporalView.ok) return temporalView;
+  return ok$1({
+    extent,
+    resolvedExtent: effectiveResolvedExtent,
+    froxel: froxel.value,
+    froxelView: froxelView.value,
+    resolved: resolved2.value,
+    resolvedView: resolvedView.value,
+    history: history.value,
+    historyView: historyView.value,
+    temporal: temporal.value,
+    temporalView: temporalView.value
+  });
+}
+
+// src/volume/passes.ts
+function pipelineError(stage) {
+  return new RhiError({
+    code: "rhi-not-available",
+    expected: `volumetric fog ${stage} pipeline to be available`,
+    hint: "construct the renderer through a backend pack with shader module support"
+  });
+}
+function shaderSource(frame, stage) {
+  const source = frame.volumetricFogShaders?.[stage];
+  if (source === void 0) throw pipelineError(`${stage} shader source`);
+  return source;
+}
+function computeState(frame, source, label, entries, entryPoint = label) {
+  const factory = frame.runtime.shaderModuleFactory;
+  if (factory === void 0) throw pipelineError(label);
+  const module = factory.createShaderModule({ code: source, label });
+  if (!module.ok) throw module.error;
+  const layout = frame.runtime.device.createBindGroupLayout({ entries });
+  if (!layout.ok) throw layout.error;
+  const pipelineLayout = frame.runtime.device.createPipelineLayout({
+    label: `${label}.layout`,
+    bindGroupLayouts: [layout.value]
+  });
+  if (!pipelineLayout.ok) throw pipelineLayout.error;
+  const pipeline = frame.runtime.device.createComputePipeline({
+    label,
+    layout: pipelineLayout.value,
+    compute: { module: module.value, entryPoint }
+  });
+  if (!pipeline.ok) throw pipeline.error;
+  return { pipeline: pipeline.value, layout: layout.value };
+}
+function volumeBindGroup(frame, layout, entries) {
+  const group = frame.runtime.device.createBindGroup({ layout, entries });
+  if (!group.ok) throw group.error;
+  return group.value;
+}
+function importVolumeInputs(graph, topology, linearHdr, sceneDepth, directionalShadow, spotShadow, selectedLightKind) {
+  const volume = topology.volumetricFog;
+  if (volume?.enabled !== true || volume.format === void 0 || volume.extent === void 0)
+    return ok$1(void 0);
+  const texture = graph.importTexture(
+    "volume-density",
+    {
+      format: volume.format,
+      size: {
+        width: volume.extent.width,
+        height: volume.extent.height,
+        depthOrArrayLayers: volume.extent.depth
+      },
+      dimension: "3d",
+      usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING
+    },
+    (frame) => {
+      const context = frame.volumetricFog;
+      if (context === void 0) throw pipelineError("density residency");
+      return context.densityTexture;
+    }
+  );
+  if (!texture.ok) return texture;
+  const density = graph.importView(
+    texture.value,
+    { label: "volume-density.view", dimension: "3d" },
+    (frame) => {
+      const context = frame.volumetricFog;
+      if (context === void 0) throw pipelineError("density view residency");
+      return context.densityView;
+    }
+  );
+  if (!density.ok) return density;
+  const params = graph.importBuffer(
+    "volume-params",
+    { size: 128, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
+    (frame) => {
+      const context = frame.volumetricFog;
+      if (context === void 0) throw pipelineError("parameter residency");
+      return context.paramsBuffer;
+    }
+  );
+  if (!params.ok) return params;
+  const view = graph.importBuffer(
+    "volume-view",
+    { size: VIEW_UNIFORM_BYTES, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
+    (frame) => frame.pipelineState.viewUniformBuffer
+  );
+  if (!view.ok) return view;
+  const spotLights = graph.importBuffer(
+    "volume-spot-lights",
+    {
+      size: LIGHT_ARRAY_HEADER_BYTES + LIGHT_ARRAY_MAX_SLOTS * SPOT_LIGHT_STD430_BYTES,
+      usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST
+    },
+    (frame) => frame.pipelineState.spotLightsBuffer
+  );
+  if (!spotLights.ok) return spotLights;
+  const pointLights = graph.importBuffer(
+    "volume-point-lights",
+    { size: 16 + 4 * 32, usage: GPU_BUFFER_USAGE_STORAGE | GPU_BUFFER_USAGE_COPY_DST },
+    (frame) => frame.pipelineState.pointLightsBuffer
+  );
+  if (!pointLights.ok) return pointLights;
+  let projector;
+  if (volume.projector !== void 0) {
+    const projectorTexture = graph.importTexture(
+      "spot-projector",
+      {
+        format: "rgba8unorm-srgb",
+        size: { width: 128, height: 128, depthOrArrayLayers: 1 },
+        dimension: "2d",
+        usage: GPU_TEXTURE_USAGE_TEXTURE_BINDING
+      },
+      (frame) => {
+        const context = frame.volumetricFog;
+        if (context?.projectorTexture === void 0) throw pipelineError("projector residency");
+        return context.projectorTexture;
+      }
+    );
+    if (!projectorTexture.ok) return projectorTexture;
+    const projectorView = graph.importView(
+      projectorTexture.value,
+      { label: "spot-projector.view", dimension: "2d" },
+      (frame) => {
+        const context = frame.volumetricFog;
+        if (context?.projectorView === void 0) throw pipelineError("projector view residency");
+        return context.projectorView;
+      }
+    );
+    if (!projectorView.ok) return projectorView;
+    projector = projectorView.value;
+  }
+  return ok$1({
+    linearHdr,
+    sceneDepth,
+    density: density.value,
+    params: params.value,
+    view: view.value,
+    directionalShadow,
+    spotShadow,
+    pointLights: pointLights.value,
+    spotLights: spotLights.value,
+    selectedLightKind: selectedLightKind ?? "directional",
+    ...projector === void 0 ? {} : { projector }
+  });
+}
+function addAuthoredVolumetricFogPasses(graph, topology, linearHdr, sceneDepth, directionalShadow, spotShadow) {
+  const shadowLightKind = topology.volumetricFog?.spotLightEntity === void 0 ? topology.volumetricFog?.lightKind : "spot";
+  const imported = importVolumeInputs(
+    graph,
+    topology,
+    linearHdr,
+    sceneDepth,
+    directionalShadow,
+    spotShadow,
+    shadowLightKind
+  );
+  if (!imported.ok) return imported;
+  if (imported.value === void 0) return ok$1(void 0);
+  const resources = createVolumetricFogResources(
+    graph,
+    topology.volumetricFog?.froxelExtent ?? { width: 64, height: 64, depth: 64 },
+    topology.volumetricFog?.resolvedExtent
+  );
+  if (!resources.ok) return resources;
+  return addVolumetricFogPasses(graph, { ...imported.value, resources: resources.value });
+}
+function addVolumetricFogPasses(graph, inputs) {
+  const dispatchX = Math.ceil(inputs.resources.extent.width / 8);
+  const dispatchY = Math.ceil(inputs.resources.extent.height / 8);
+  const packedLayers = Math.ceil(inputs.resources.extent.depth / VOLUME_PACKING_Z);
+  const resolvedDispatchX = Math.ceil(inputs.resources.resolvedExtent.width / 8);
+  const resolvedDispatchY = Math.ceil(inputs.resources.resolvedExtent.height / 8);
+  let inject;
+  let integrate;
+  let temporal;
+  let composite;
+  let compositeLayout;
+  const injected = graph.addComputePass("volume-inject", {
+    accesses: [
+      { resource: inputs.params, usage: "uniform-read" },
+      { resource: inputs.view, usage: "uniform-read" },
+      {
+        resource: inputs.selectedLightKind === "spot" ? inputs.spotShadow : inputs.directionalShadow,
+        usage: "sampled-read"
+      },
+      { resource: inputs.spotLights, usage: "storage-read" },
+      { resource: inputs.pointLights, usage: "storage-read" },
+      ...inputs.projector === void 0 ? [] : [{ resource: inputs.projector, usage: "sampled-read" }],
+      { resource: inputs.resources.froxelView, usage: "storage-write" }
+    ],
+    encode: ({ pass, frame, resources }) => {
+      inject ??= computeState(frame, shaderSource(frame, "inject"), "volume_inject", [
+        { binding: 0, visibility: 4, buffer: { type: "uniform" } },
+        { binding: 3, visibility: 4, texture: { sampleType: "depth", viewDimension: "2d" } },
+        { binding: 4, visibility: 4, sampler: { type: "comparison" } },
+        { binding: 5, visibility: 4, buffer: { type: "uniform" } },
+        {
+          binding: 6,
+          visibility: 4,
+          storageTexture: {
+            access: "write-only",
+            format: VOLUME_FROXEL_FORMAT,
+            viewDimension: "2d-array"
+          }
+        },
+        { binding: 7, visibility: 4, buffer: { type: "read-only-storage" } },
+        { binding: 8, visibility: 4, buffer: { type: "read-only-storage" } }
+      ]);
+      const shadow = resources.textureView(
+        inputs.selectedLightKind === "spot" ? inputs.spotShadow : inputs.directionalShadow
+      );
+      const params = resources.buffer(inputs.params);
+      const view = resources.buffer(inputs.view);
+      const spotLights = resources.buffer(inputs.spotLights);
+      const pointLights = resources.buffer(inputs.pointLights);
+      const froxel = resources.textureView(inputs.resources.froxelView);
+      if (!shadow.ok) throw shadow.error;
+      if (!params.ok) throw params.error;
+      if (!view.ok) throw view.error;
+      if (!spotLights.ok) throw spotLights.error;
+      if (!pointLights.ok) throw pointLights.error;
+      if (!froxel.ok) throw froxel.error;
+      const shadowSampler = frame.runtime.device.createSampler({ compare: "less" });
+      if (!shadowSampler.ok) throw shadowSampler.error;
+      const bindings = volumeBindGroup(frame, inject.layout, [
+        { binding: 0, resource: { kind: "buffer", value: { buffer: view.value } } },
+        { binding: 3, resource: { kind: "textureView", value: shadow.value } },
+        { binding: 4, resource: { kind: "sampler", value: shadowSampler.value } },
+        { binding: 5, resource: { kind: "buffer", value: { buffer: params.value } } },
+        { binding: 6, resource: { kind: "textureView", value: froxel.value } },
+        { binding: 7, resource: { kind: "buffer", value: { buffer: spotLights.value } } },
+        { binding: 8, resource: { kind: "buffer", value: { buffer: pointLights.value } } }
+      ]);
+      pass.setPipeline(inject.pipeline);
+      pass.setBindGroup(0, bindings);
+      pass.dispatchWorkgroups(dispatchX, dispatchY, packedLayers);
+    }
+  });
+  if (!injected.ok) return injected;
+  const integratePass = graph.addComputePass("volume-integrate", {
+    accesses: [
+      { resource: inputs.resources.froxelView, usage: "sampled-read" },
+      { resource: inputs.sceneDepth, usage: "sampled-read" },
+      { resource: inputs.density, usage: "sampled-read" },
+      { resource: inputs.resources.resolvedView, usage: "storage-write" },
+      { resource: inputs.resources.historyView, usage: "storage-write" },
+      { resource: inputs.resources.temporalView, usage: "storage-write" },
+      { resource: inputs.params, usage: "uniform-read" },
+      { resource: inputs.view, usage: "uniform-read" },
+      { resource: inputs.spotLights, usage: "storage-read" },
+      { resource: inputs.pointLights, usage: "storage-read" },
+      ...inputs.projector === void 0 ? [] : [{ resource: inputs.projector, usage: "sampled-read" }]
+    ],
+    encode: ({ pass, frame, resources }) => {
+      integrate ??= computeState(frame, shaderSource(frame, "integrate"), "volume_integrate", [
+        { binding: 0, visibility: 4, texture: { sampleType: "float", viewDimension: "2d-array" } },
+        { binding: 1, visibility: 4, texture: { sampleType: "depth", viewDimension: "2d" } },
+        {
+          binding: 2,
+          visibility: 4,
+          storageTexture: {
+            access: "write-only",
+            format: VOLUME_RESOLVED_FORMAT,
+            viewDimension: "2d"
+          }
+        },
+        { binding: 3, visibility: 4, buffer: { type: "uniform" } },
+        { binding: 4, visibility: 4, buffer: { type: "uniform" } },
+        { binding: 5, visibility: 4, sampler: { type: "filtering" } },
+        { binding: 6, visibility: 4, texture: { sampleType: "float", viewDimension: "3d" } },
+        { binding: 7, visibility: 4, sampler: { type: "filtering" } },
+        {
+          binding: 8,
+          visibility: 4,
+          storageTexture: {
+            access: "write-only",
+            format: VOLUME_HISTORY_FORMAT,
+            viewDimension: "2d"
+          }
+        },
+        {
+          binding: 9,
+          visibility: 4,
+          storageTexture: {
+            access: "write-only",
+            format: VOLUME_HISTORY_FORMAT,
+            viewDimension: "2d"
+          }
+        },
+        { binding: 10, visibility: 4, buffer: { type: "read-only-storage" } },
+        { binding: 11, visibility: 4, buffer: { type: "read-only-storage" } },
+        { binding: 12, visibility: 4, texture: { sampleType: "float", viewDimension: "2d" } },
+        { binding: 13, visibility: 4, sampler: { type: "filtering" } }
+      ]);
+      const froxel = resources.textureView(inputs.resources.froxelView);
+      const depth = resources.textureView(inputs.sceneDepth);
+      const density = resources.textureView(inputs.density);
+      const resolved2 = resources.textureView(inputs.resources.resolvedView);
+      const historySeed = resources.textureView(inputs.resources.historyView);
+      const temporalSeed = resources.textureView(inputs.resources.temporalView);
+      const params = resources.buffer(inputs.params);
+      const view = resources.buffer(inputs.view);
+      const spotLights = resources.buffer(inputs.spotLights);
+      const pointLights = resources.buffer(inputs.pointLights);
+      const projector = inputs.projector === void 0 ? void 0 : resources.textureView(inputs.projector);
+      if (!froxel.ok) throw froxel.error;
+      if (!depth.ok) throw depth.error;
+      if (!density.ok) throw density.error;
+      if (!resolved2.ok) throw resolved2.error;
+      if (!historySeed.ok) throw historySeed.error;
+      if (!temporalSeed.ok) throw temporalSeed.error;
+      if (!params.ok) throw params.error;
+      if (!view.ok) throw view.error;
+      if (!spotLights.ok) throw spotLights.error;
+      if (!pointLights.ok) throw pointLights.error;
+      if (projector !== void 0 && !projector.ok) throw projector.error;
+      const sampler = frame.runtime.device.createSampler({
+        minFilter: "linear",
+        magFilter: "linear"
+      });
+      if (!sampler.ok) throw sampler.error;
+      const densitySampler = frame.runtime.device.createSampler({
+        minFilter: "linear",
+        magFilter: "linear",
+        addressModeU: "repeat",
+        addressModeV: "repeat",
+        addressModeW: "repeat"
+      });
+      if (!densitySampler.ok) throw densitySampler.error;
+      const bindings = volumeBindGroup(frame, integrate.layout, [
+        { binding: 0, resource: { kind: "textureView", value: froxel.value } },
+        { binding: 1, resource: { kind: "textureView", value: depth.value } },
+        { binding: 2, resource: { kind: "textureView", value: resolved2.value } },
+        { binding: 3, resource: { kind: "buffer", value: { buffer: params.value } } },
+        { binding: 4, resource: { kind: "buffer", value: { buffer: view.value } } },
+        { binding: 5, resource: { kind: "sampler", value: sampler.value } },
+        { binding: 6, resource: { kind: "textureView", value: density.value } },
+        { binding: 7, resource: { kind: "sampler", value: densitySampler.value } },
+        { binding: 8, resource: { kind: "textureView", value: historySeed.value } },
+        { binding: 9, resource: { kind: "textureView", value: temporalSeed.value } },
+        { binding: 10, resource: { kind: "buffer", value: { buffer: spotLights.value } } },
+        { binding: 11, resource: { kind: "buffer", value: { buffer: pointLights.value } } },
+        {
+          binding: 12,
+          resource: {
+            kind: "textureView",
+            value: projector === void 0 ? frame.pipelineState.defaultWhiteTextureView : projector.value
+          }
+        },
+        {
+          binding: 13,
+          resource: {
+            kind: "sampler",
+            value: frame.volumetricFog?.projectorSampler ?? frame.pipelineState.defaultSampler
+          }
+        }
+      ]);
+      pass.setPipeline(integrate.pipeline);
+      pass.setBindGroup(0, bindings);
+      pass.dispatchWorkgroups(resolvedDispatchX, resolvedDispatchY, 1);
+    }
+  });
+  if (!integratePass.ok) return integratePass;
+  const temporalPass = graph.addComputePass("volume-temporal", {
+    accesses: [
+      { resource: inputs.resources.resolvedView, usage: "sampled-read" },
+      { resource: inputs.resources.historyView, usage: "sampled-storage-read-write" },
+      { resource: inputs.resources.temporalView, usage: "sampled-storage-read-write" },
+      { resource: inputs.params, usage: "uniform-read" },
+      { resource: inputs.view, usage: "uniform-read" }
+    ],
+    encode: ({ pass, frame, resources }) => {
+      temporal ??= computeState(frame, shaderSource(frame, "temporal"), "volume_temporal", [
+        { binding: 0, visibility: 4, texture: { sampleType: "float", viewDimension: "2d" } },
+        { binding: 1, visibility: 4, texture: { sampleType: "float", viewDimension: "2d" } },
+        {
+          binding: 2,
+          visibility: 4,
+          storageTexture: {
+            access: "write-only",
+            format: VOLUME_HISTORY_FORMAT,
+            viewDimension: "2d"
+          }
+        },
+        { binding: 3, visibility: 4, buffer: { type: "uniform" } },
+        { binding: 4, visibility: 4, buffer: { type: "uniform" } }
+      ]);
+      const current = resources.textureView(inputs.resources.resolvedView);
+      const history = resources.textureView(
+        frame.volumetricFog?.historyReadSlot === 0 ? inputs.resources.historyView : inputs.resources.temporalView
+      );
+      const pending = resources.textureView(
+        frame.volumetricFog?.historyWriteSlot === 0 ? inputs.resources.historyView : inputs.resources.temporalView
+      );
+      const params = resources.buffer(inputs.params);
+      const view = resources.buffer(inputs.view);
+      if (!current.ok) throw current.error;
+      if (!history.ok) throw history.error;
+      if (!pending.ok) throw pending.error;
+      if (!params.ok) throw params.error;
+      if (!view.ok) throw view.error;
+      const bindings = volumeBindGroup(frame, temporal.layout, [
+        { binding: 0, resource: { kind: "textureView", value: current.value } },
+        { binding: 1, resource: { kind: "textureView", value: history.value } },
+        { binding: 2, resource: { kind: "textureView", value: pending.value } },
+        { binding: 3, resource: { kind: "buffer", value: { buffer: params.value } } },
+        { binding: 4, resource: { kind: "buffer", value: { buffer: view.value } } }
+      ]);
+      pass.setPipeline(temporal.pipeline);
+      pass.setBindGroup(0, bindings);
+      pass.dispatchWorkgroups(resolvedDispatchX, resolvedDispatchY, 1);
+    }
+  });
+  if (!temporalPass.ok) return temporalPass;
+  return graph.addRasterPass("volume-composite", {
+    accesses: [
+      { resource: inputs.resources.historyView, usage: "sampled-read" },
+      { resource: inputs.resources.temporalView, usage: "sampled-read" },
+      { resource: inputs.sceneDepth, usage: "sampled-read" },
+      { resource: inputs.view, usage: "uniform-read" },
+      { resource: inputs.linearHdr.view, usage: "color-attachment" }
+    ],
+    colorAttachments: [
+      {
+        view: inputs.linearHdr.view,
+        loadOp: "load",
+        storeOp: "store",
+        clearValue: { r: 0, g: 0, b: 0, a: 1 }
+      }
+    ],
+    encode: ({ pass, frame, resources }) => {
+      composite ??= (() => {
+        const factory = frame.runtime.shaderModuleFactory;
+        if (factory === void 0) throw pipelineError("volume_composite");
+        const module = factory.createShaderModule({
+          code: shaderSource(frame, "composite"),
+          label: "volume_composite"
+        });
+        if (!module.ok) throw module.error;
+        const layout = frame.runtime.device.createBindGroupLayout({
+          label: "volume_composite.bind-group-layout",
+          entries: [
+            {
+              binding: 0,
+              visibility: 2 | 1,
+              texture: { sampleType: "float", viewDimension: "2d" }
+            },
+            { binding: 1, visibility: 2 | 1, sampler: { type: "filtering" } },
+            {
+              binding: 2,
+              visibility: 2 | 1,
+              texture: { sampleType: "depth", viewDimension: "2d" }
+            },
+            { binding: 3, visibility: 2 | 1, buffer: { type: "uniform" } }
+          ]
+        });
+        if (!layout.ok) throw layout.error;
+        const pipelineLayout = frame.runtime.device.createPipelineLayout({
+          label: "volume_composite.layout",
+          bindGroupLayouts: [layout.value]
+        });
+        if (!pipelineLayout.ok) throw pipelineLayout.error;
+        const created = frame.runtime.device.createRenderPipeline({
+          label: "volume_composite",
+          layout: pipelineLayout.value,
+          vertex: { module: module.value, entryPoint: "volume_vs", buffers: [] },
+          fragment: {
+            module: module.value,
+            entryPoint: "volume_fs",
+            targets: [
+              {
+                format: inputs.linearHdr.format,
+                blend: {
+                  color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+                  alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+                }
+              }
+            ]
+          },
+          primitive: { topology: "triangle-list" }
+        });
+        if (!created.ok) throw created.error;
+        compositeLayout = layout.value;
+        return created.value;
+      })();
+      const resolved2 = resources.textureView(
+        frame.volumetricFog?.historyWriteSlot === 0 ? inputs.resources.historyView : inputs.resources.temporalView
+      );
+      const depth = resources.textureView(inputs.sceneDepth);
+      const view = resources.buffer(inputs.view);
+      if (!resolved2.ok) throw resolved2.error;
+      if (!depth.ok) throw depth.error;
+      if (!view.ok) throw view.error;
+      const sampler = frame.runtime.device.createSampler({
+        label: "volume_composite.sampler",
+        minFilter: "linear",
+        magFilter: "linear"
+      });
+      if (!sampler.ok) throw sampler.error;
+      const bindings = frame.runtime.device.createBindGroup({
+        layout: compositeLayout,
+        entries: [
+          { binding: 0, resource: { kind: "textureView", value: resolved2.value } },
+          { binding: 1, resource: { kind: "sampler", value: sampler.value } },
+          { binding: 2, resource: { kind: "textureView", value: depth.value } },
+          { binding: 3, resource: { kind: "buffer", value: { buffer: view.value } } }
+        ]
+      });
+      if (!bindings.ok) throw bindings.error;
+      pass.setPipeline(composite);
+      pass.setBindGroup(0, bindings.value);
+      pass.draw(3);
+    }
+  });
+}
 function addTypedDebugOverlayPass(graph, output) {
   return graph.addRasterPass("debug-overlay", {
     accesses: [{ resource: output.view, usage: "color-attachment" }],
@@ -4218,8 +4966,26 @@ function buildUrp(context, topology) {
     const temporal2 = addTransmissionBackdropTemporalPass(graph, sceneResolved.value);
     if (!temporal2.ok) return temporal2;
   }
+  if (topology.volumetricFog?.enabled === true) {
+    const depthSample = graph.view(depth.value.texture, {
+      label: "scene-depth.sample",
+      dimension: "2d",
+      aspect: "depth-only"
+    });
+    if (!depthSample.ok) return depthSample;
+    const volume = addAuthoredVolumetricFogPasses(
+      graph,
+      topology,
+      sceneResolved.value,
+      depthSample.value,
+      shadows.value.directional.view,
+      shadows.value.spot.view
+    );
+    if (!volume.ok) return volume;
+  }
   const features = context.contributeFeatures([
     {
+      name: "linear-hdr",
       kind: "scene-color",
       texture: scene.value.texture,
       view: scene.value.view,
@@ -4653,8 +5419,26 @@ function buildHdrp(context, topology) {
     const temporal2 = addTransmissionBackdropTemporalPass(graph, scene.value);
     if (!temporal2.ok) return temporal2;
   }
+  if (topology.volumetricFog?.enabled === true) {
+    const depthSample = graph.view(depth.value.texture, {
+      label: "scene-depth.sample",
+      dimension: "2d",
+      aspect: "depth-only"
+    });
+    if (!depthSample.ok) return depthSample;
+    const volume = addAuthoredVolumetricFogPasses(
+      graph,
+      topology,
+      scene.value,
+      depthSample.value,
+      shadows.value.directional.view,
+      shadows.value.spot.view
+    );
+    if (!volume.ok) return volume;
+  }
   const features = context.contributeFeatures([
     {
+      name: "linear-hdr",
       kind: "scene-color",
       texture: scene.value.texture,
       view: scene.value.view,
@@ -4892,8 +5676,180 @@ function buildPipelineForMaterialShader(id, entry, ctx, renderState, geometry, v
       })
     );
   }
-  return pipelineResult;
-}
+  return pipelineResult;
+}
+var MAX_VOLUME_PASSES = 4;
+var QUERY_COUNT = MAX_VOLUME_PASSES * 2;
+var QUERY_RESULT_BYTES = 8;
+var READBACK_BYTES = QUERY_COUNT * QUERY_RESULT_BYTES;
+var PASS_NAMES = [
+  "volume-inject",
+  "volume-integrate",
+  "volume-temporal",
+  "volume-composite"
+];
+function unavailable(reason) {
+  return Object.freeze({ status: "unavailable", reason });
+}
+var GpuTimingCapture = class _GpuTimingCapture {
+  #device;
+  #querySet;
+  #resolveBuffer;
+  #readbackBuffer;
+  #periodNanoseconds;
+  #started = /* @__PURE__ */ new Map();
+  #finished = /* @__PURE__ */ new Map();
+  #resolved = false;
+  #submitted = false;
+  #discarded = false;
+  #disposed = false;
+  #observation;
+  constructor(device, querySet, resolveBuffer, readbackBuffer, periodNanoseconds) {
+    this.#device = device;
+    this.#querySet = querySet;
+    this.#resolveBuffer = resolveBuffer;
+    this.#readbackBuffer = readbackBuffer;
+    this.#periodNanoseconds = periodNanoseconds;
+  }
+  static create(device) {
+    const period = device.caps.timestampPeriodNanoseconds;
+    if (!device.caps.timestampQuery || period === null || !Number.isFinite(period) || period <= 0) {
+      return ok$1(void 0);
+    }
+    const querySet = device.createQuerySet({
+      label: "volume-timing",
+      type: "timestamp",
+      count: QUERY_COUNT
+    });
+    if (!querySet.ok) return querySet;
+    const resolveBuffer = device.createBuffer({
+      label: "volume-timing.resolve",
+      size: READBACK_BYTES,
+      usage: GPU_BUFFER_USAGE_QUERY_RESOLVE | GPU_BUFFER_USAGE_COPY_SRC
+    });
+    if (!resolveBuffer.ok) {
+      device.destroyQuerySet(querySet.value);
+      return resolveBuffer;
+    }
+    const readbackBuffer = device.createBuffer({
+      label: "volume-timing.readback",
+      size: READBACK_BYTES,
+      usage: GPU_BUFFER_USAGE_MAP_READ | GPU_BUFFER_USAGE_COPY_DST
+    });
+    if (!readbackBuffer.ok) {
+      device.destroyBuffer(resolveBuffer.value);
+      device.destroyQuerySet(querySet.value);
+      return readbackBuffer;
+    }
+    return ok$1(
+      new _GpuTimingCapture(
+        device,
+        querySet.value,
+        resolveBuffer.value,
+        readbackBuffer.value,
+        period
+      )
+    );
+  }
+  beforePass(name, encoder) {
+    const index = PASS_NAMES.indexOf(name);
+    if (index < 0 || this.#started.has(name)) return;
+    this.#started.set(name, index);
+    encoder.writeTimestamp(this.#querySet, index * 2);
+  }
+  afterPass(name, encoder) {
+    const index = this.#started.get(name);
+    if (index === void 0 || this.#finished.has(name)) return;
+    this.#finished.set(name, index);
+    encoder.writeTimestamp(this.#querySet, index * 2 + 1);
+  }
+  resolve(encoder) {
+    if (this.#started.size === 0) {
+      this.#resolved = true;
+      return ok$1(void 0);
+    }
+    const resolved2 = encoder.resolveQuerySet(
+      this.#querySet,
+      0,
+      QUERY_COUNT,
+      this.#resolveBuffer,
+      0
+    );
+    if (!resolved2.ok) return resolved2;
+    encoder.copyBufferToBuffer(this.#resolveBuffer, this.#readbackBuffer, READBACK_BYTES);
+    this.#resolved = true;
+    return ok$1(void 0);
+  }
+  markSubmitted() {
+    if (!this.#discarded) this.#submitted = true;
+  }
+  discard() {
+    if (this.#discarded) return;
+    this.#discarded = true;
+    this.#resolved = true;
+    this.#submitted = false;
+    this.#dispose();
+  }
+  observation() {
+    if (this.#observation !== void 0) return this.#observation;
+    if (this.#discarded || !this.#resolved || !this.#submitted || this.#started.size === 0) {
+      this.#observation = Promise.resolve(
+        unavailable("timestamp capture did not reach an accepted volume submit")
+      );
+      this.#dispose();
+      return this.#observation;
+    }
+    this.#observation = this.#readbackBuffer.mapAsync(GPU_BUFFER_USAGE_MAP_READ).then((mapped) => {
+      if (!mapped.ok) return unavailable(`timestamp readback failed: ${mapped.error.code}`);
+      const range = mapped.value.getMappedRange();
+      if (!range.ok) {
+        mapped.value.unmap();
+        return unavailable(`timestamp mapping failed: ${range.error.code}`);
+      }
+      const values = new DataView(range.value);
+      const decoded = [...this.#finished.entries()].sort((a, b) => a[1] - b[1]).map(([name, index]) => ({
+        name,
+        begin: values.getBigUint64(index * 2 * QUERY_RESULT_BYTES, true),
+        end: values.getBigUint64((index * 2 + 1) * QUERY_RESULT_BYTES, true)
+      }));
+      if (decoded.some(({ end, begin }) => end < begin)) {
+        mapped.value.unmap();
+        this.#dispose();
+        return unavailable("timestamp query returned an end before its begin");
+      }
+      const passes = decoded.map(({ name, begin, end }) => ({
+        name,
+        milliseconds: Number(end - begin) * this.#periodNanoseconds / 1e6
+      }));
+      const firstBegin = decoded.reduce(
+        (first, sample) => sample.begin < first ? sample.begin : first,
+        decoded[0]?.begin ?? 0n
+      );
+      const lastEnd = decoded.reduce(
+        (last, sample) => sample.end > last ? sample.end : last,
+        decoded[0]?.end ?? 0n
+      );
+      const totalMs = Number(lastEnd - firstBegin) * this.#periodNanoseconds / 1e6;
+      mapped.value.unmap();
+      this.#dispose();
+      if (!Number.isFinite(totalMs) || passes.some((pass) => !Number.isFinite(pass.milliseconds))) {
+        return unavailable("timestamp query returned a non-finite duration");
+      }
+      return Object.freeze({ status: "ready", unit: "ms", totalMs, passes });
+    }).catch((cause) => {
+      this.#dispose();
+      return unavailable(`timestamp readback failed: ${String(cause)}`);
+    });
+    return this.#observation;
+  }
+  #dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#device.destroyBuffer(this.#resolveBuffer);
+    this.#device.destroyBuffer(this.#readbackBuffer);
+    this.#device.destroyQuerySet(this.#querySet);
+  }
+};
 
 // src/environment/graph.ts
 function sharedEnvironmentFrame(frame, _lane) {
@@ -7651,6 +8607,42 @@ function createPreparedGraphicsResolver(input) {
   };
 }
 
+// src/volume/temporal.ts
+function resolveVolumeTemporalReset(previous, next, options = {}) {
+  if (options.reprojection === "out-of-screen") {
+    return { reset: true, reason: "reprojection-out-of-screen" };
+  }
+  if (options.reprojection === "depth-discontinuity") {
+    return { reset: true, reason: "reprojection-depth-discontinuity" };
+  }
+  if (previous.width !== next.width || previous.height !== next.height) {
+    return { reset: true, reason: "resize" };
+  }
+  if (previous.cameraRevision !== next.cameraRevision) return { reset: true, reason: "camera-cut" };
+  if (previous.fogRevision !== next.fogRevision) return { reset: true, reason: "fog-revision" };
+  if (previous.lightRevision !== next.lightRevision) {
+    return { reset: true, reason: "light-revision" };
+  }
+  if (previous.lightKind !== next.lightKind || previous.lightEntity !== next.lightEntity) {
+    return { reset: true, reason: "light-revision" };
+  }
+  if (previous.pointLightEntity !== next.pointLightEntity || previous.spotLightEntity !== next.spotLightEntity) {
+    return { reset: true, reason: "light-revision" };
+  }
+  const previousProjector = previous.projector;
+  const nextProjector = next.projector;
+  if (previousProjector?.guid !== nextProjector?.guid || previousProjector?.generation !== nextProjector?.generation || previousProjector?.view !== nextProjector?.view || previousProjector?.sampler !== nextProjector?.sampler || previousProjector?.projection !== nextProjector?.projection || previousProjector?.revision !== nextProjector?.revision) {
+    return { reset: true, reason: "light-revision" };
+  }
+  if (previous.lightShadowRevision !== next.lightShadowRevision) {
+    return { reset: true, reason: "light-revision" };
+  }
+  if (previous.densityGeneration !== next.densityGeneration) {
+    return { reset: true, reason: "density-generation" };
+  }
+  return { reset: false };
+}
+
 // src/temporal/view.ts
 var HALTON_23_8 = Object.freeze([
   Object.freeze([0, -1 / 6]),
@@ -7832,11 +8824,14 @@ function resolveShadowMapSize(internals, lights) {
   const requested = lights.shadowMapSize;
   if (!(requested !== void 0 && requested > 0)) return requested;
   const cascades = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1)));
-  const tilesPerSide = Math.ceil(Math.sqrt(cascades));
+  const atlasGrid = resolveDirectionalShadowAtlasGrid(cascades);
   const maxDimension = internals.device.limits.maxTextureDimension2D;
   if (!(maxDimension > 0)) return Math.floor(requested);
   const depthTextureDimension = internals.device.caps?.backendKind === "wgpu-webgl2" ? Math.max(1, Math.floor(maxDimension / 2)) : maxDimension;
-  const maxPerTile = Math.max(1, Math.floor(depthTextureDimension / tilesPerSide));
+  const maxPerTile = Math.max(
+    1,
+    Math.floor(depthTextureDimension / Math.max(atlasGrid.columns, atlasGrid.rows))
+  );
   return Math.max(1, Math.min(Math.floor(requested), maxPerTile));
 }
 function resolveSpotShadowMapSize(internals, lights) {
@@ -8309,7 +9304,7 @@ function commitFeatureCandidate(internals, candidate) {
   state.plans = candidate.plans;
   state.fullscreenEffects = candidate.fullscreenEffects;
 }
-function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, transmissionDemand) {
+function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, transmissionDemand, volumetricFog) {
   const cascadeCount = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1)));
   const surfaceFormats = resolveSurfaceFormatPair(
     internals.device.caps.backendKind,
@@ -8335,6 +9330,11 @@ function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lig
       ])
     ]
   };
+  const volumeCapability = hasVolumetricFogCapability(
+    internals.device.caps,
+    internals.volumetricFogShaders
+  );
+  const selectedVolumeLight = volumetricFog?.lightKind === "spot" ? lights.spot.find((light) => light.entity === volumetricFog.lightEntity) : volumetricFog?.lightKind === "point" ? lights.point.find((light) => light.entity === volumetricFog.lightEntity) : volumetricFog?.lightKind === "directional" && lights.directional?.entity === volumetricFog.lightEntity ? lights.directional : volumetricFog?.lightKind === void 0 ? lights.directional : void 0;
   return ok$1({
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: internals.standardProfile,
@@ -8368,6 +9368,38 @@ function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lig
         ).length
       )
     },
+    volumetricFog: volumetricFog?.status === "available" && volumetricFog.densityAsset?.shape.viewDimension === "3d" && camera.tonemap !== "none" && selectedVolumeLight !== void 0 && volumeCapability ? (() => {
+      const volumeProfile = resolveVolumetricFogProfile(internals.standardProfile ?? {});
+      return {
+        enabled: true,
+        format: volumetricFog.densityAsset.format,
+        extent: {
+          width: volumetricFog.densityAsset.shape.extent.width,
+          height: volumetricFog.densityAsset.shape.extent.height,
+          depth: volumetricFog.densityAsset.shape.extent.depth
+        },
+        froxelExtent: deriveVolumetricFogExtent(
+          { width, height },
+          volumeProfile.depth,
+          volumeProfile.tileSize
+        ),
+        resolvedExtent: deriveVolumetricFogResolvedExtent(
+          { width, height },
+          volumeProfile.tileSize
+        ),
+        lightKind: volumetricFog.lightKind,
+        lightEntity: volumetricFog.lightEntity,
+        pointLightEntity: volumetricFog.pointLightEntity,
+        spotLightEntity: volumetricFog.spotLightEntity,
+        ...volumetricFog.projector === void 0 ? {} : {
+          projector: {
+            guid: volumetricFog.projector.guid,
+            generation: volumetricFog.projector.generation,
+            revision: volumetricFog.projector.revision
+          }
+        }
+      };
+    })() : { enabled: false },
     lane: {
       compute: internals.device.caps.compute,
       storageBuffer: internals.device.caps.storageBuffer,
@@ -8535,7 +9567,23 @@ function retire(frameState, graph) {
   frameState.retiredCompiledFrameGraphs.add(graph);
   graph.retire().finally(() => frameState.retiredCompiledFrameGraphs.delete(graph)).catch(() => void 0);
 }
-function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, clearOnly = false, transmissionDemand) {
+function settleVolumetricFogGraphCandidate(frameState, submitted) {
+  const candidate = frameState.volumetricFogCandidateGraph ?? null;
+  if (candidate === null) return;
+  const previous = frameState.volumetricFogPreviousGraph ?? null;
+  const previousKey = frameState.volumetricFogPreviousGraphKey ?? null;
+  if (submitted) {
+    if (previous !== null && previous !== candidate) retire(frameState, previous);
+  } else {
+    if (candidate !== previous) retire(frameState, candidate);
+    frameState.compiledFrameGraph = previous;
+    frameState.compiledFrameGraphTopologyKey = previousKey;
+  }
+  frameState.volumetricFogPreviousGraph = null;
+  frameState.volumetricFogPreviousGraphKey = null;
+  frameState.volumetricFogCandidateGraph = null;
+}
+function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, clearOnly = false, transmissionDemand, volumetricFog, volumeTopologyCandidate = false) {
   const surfaceWidth = Math.max(1, width);
   const surfaceHeight = Math.max(1, height);
   const featurePlans = featureGraphCandidate?.plans ?? getRenderFeatureGraphState(internals).plans;
@@ -8543,7 +9591,7 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   if (!projectedFeaturePlans.ok) {
     reportRenderFeatureGraphError(internals, projectedFeaturePlans.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : frameState.compiledFrameGraph;
   }
   const topologyResult = topologyOf(
     internals,
@@ -8557,12 +9605,13 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     shadowMapSize,
     gpuDriven,
     featureGraphCandidate,
-    transmissionDemand
+    transmissionDemand,
+    volumetricFog
   );
   if (!topologyResult.ok) {
     internals.errorRegistry.fire(topologyResult.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : frameState.compiledFrameGraph;
   }
   const topology = topologyResult.value;
   const key = JSON.stringify(topology);
@@ -8611,7 +9660,7 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   if (!built.ok) {
     internals.errorRegistry.fire(built.error);
     featureGraphCandidate?.onRejected?.();
-    return frameState.compiledFrameGraph;
+    return volumeTopologyCandidate ? null : frameState.compiledFrameGraph;
   }
   const compiled = builder.compile({
     device: internals.device,
@@ -8623,6 +9672,11 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     return frameState.compiledFrameGraph;
   }
   const previous = frameState.compiledFrameGraph;
+  if (volumeTopologyCandidate) {
+    frameState.volumetricFogPreviousGraph = previous;
+    frameState.volumetricFogPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+    frameState.volumetricFogCandidateGraph = compiled.value;
+  }
   frameState.compiledFrameGraph = compiled.value;
   frameState.compiledFrameGraphTopologyKey = key;
   const compiledTargets = compiled.value;
@@ -8637,17 +9691,36 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   if (featureGraphCandidate !== void 0) {
     commitFeatureCandidate(internals, featureGraphCandidate);
   }
-  if (previous !== null) retire(frameState, previous);
+  if (!volumeTopologyCandidate && previous !== null) retire(frameState, previous);
   return compiled.value;
 }
-function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPass) {
+function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPass, timingCapture) {
   const graph = frameState.compiledFrameGraph;
-  if (graph === null) return false;
+  const rejectTemporalFrame = () => {
+    if (frameState.temporalFrameInput === void 0) return;
+    frameState.temporalFrameTransaction.commit({ accepted: false });
+    frameState.temporalFrameInput = void 0;
+  };
+  if (graph === null) {
+    timingCapture?.discard();
+    settleVolumetricFogGraphCandidate(frameState, false);
+    rejectTemporalFrame();
+    return false;
+  }
+  const timedRunPass = timingCapture === void 0 ? runPass : (pass, encode) => {
+    timingCapture.beforePass(pass.name, encoder);
+    try {
+      if (runPass === void 0) encode();
+      else runPass(pass, encode);
+    } finally {
+      timingCapture.afterPass(pass.name, encoder);
+    }
+  };
   let preparedCommand = { command: void 0 };
   const transaction = executeRendererFrameTransaction({
     build: () => ({ ok: true, value: { command: void 0 } }),
     execute: () => {
-      const executed = graph.execute(frame, runPass);
+      const executed = graph.execute(frame, timedRunPass);
       if (!executed.ok) {
         internals.errorRegistry.fire(executed.error);
         return { ok: false, stage: "execute" };
@@ -8769,8 +9842,14 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
         );
         return { ok: false, stage: "finish" };
       }
+      const resolved2 = timingCapture?.resolve(encoder);
+      if (resolved2 !== void 0 && !resolved2.ok) {
+        timingCapture?.discard();
+        return { ok: false, stage: "finish" };
+      }
       const finished = encoder.finish();
       if (!finished.ok) {
+        timingCapture?.discard();
         internals.errorRegistry.fire(finished.error);
         return { ok: false, stage: "finish" };
       }
@@ -8780,9 +9859,11 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
     submit: () => {
       const submitted = internals.device.queue.submit([preparedCommand.command]);
       if (!submitted.ok) {
+        timingCapture?.discard();
         internals.errorRegistry.fire(submitted.error);
         return { ok: false, stage: "submit" };
       }
+      timingCapture?.markSubmitted();
       return { ok: true, value: void 0 };
     },
     commit: () => {
@@ -8854,6 +9935,7 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
       }
     },
     abort: (failure2) => {
+      timingCapture?.discard();
       frameState.bloomFrameReceipts = void 0;
       if (frameState.environmentGeneration !== void 0) {
         frameState.environmentLifecycle?.recordStageFailure(
@@ -8876,11 +9958,13 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
       }
     }
   });
+  settleVolumetricFogGraphCandidate(frameState, transaction.ok);
+  if (!transaction.ok) rejectTemporalFrame();
   return transaction.ok;
 }
 
 // src/record/frame.ts
-function unavailable(reason, hint) {
+function unavailable2(reason, hint) {
   return err(new ObservationUnavailableError(reason, hint));
 }
 function mapLeaseFailure(code, hint) {
@@ -8888,20 +9972,20 @@ function mapLeaseFailure(code, hint) {
   if (code === "observation-stale") reason = "stale";
   else if (code === "observation-invalid-format") reason = "format";
   else if (code === "observation-missing-copy-src") reason = "copy-src";
-  return unavailable(reason, hint);
+  return unavailable2(reason, hint);
 }
 async function observeCurrentFrame(options, source, currentFrameId) {
   if (options.semantic !== "linear-hdr") {
-    return unavailable("identity", "request the producer-owned linear-hdr semantic");
+    return unavailable2("identity", "request the producer-owned linear-hdr semantic");
   }
   if (source === void 0) {
-    return unavailable(
+    return unavailable2(
       "no-frame",
       "draw a frame through the Standard producer before requesting observation"
     );
   }
   if (source.pipelineId !== "forgeax::standard" || source.backendId.length === 0) {
-    return unavailable(
+    return unavailable2(
       "identity",
       "observe a producer with explicit pipeline and backend identity"
     );
@@ -8918,10 +10002,10 @@ async function observeCurrentFrame(options, source, currentFrameId) {
     bytesResult = await options.readback(leaseResult.value);
   } catch (cause) {
     const message = cause instanceof Error ? cause.message : String(cause);
-    return unavailable("readback-failed", `retry the current-frame readback after: ${message}`);
+    return unavailable2("readback-failed", `retry the current-frame readback after: ${message}`);
   }
   if (!bytesResult.ok) {
-    return unavailable("readback-failed", bytesResult.error.message);
+    return unavailable2("readback-failed", bytesResult.error.message);
   }
   const activeResult = leaseResult.value.beginReadback();
   if (!activeResult.ok) {
@@ -8980,7 +10064,432 @@ var EMPTY_ENTITY_KEYS = /* @__PURE__ */ new Set();
 function runRecordProfilePhase(runner, phase, action) {
   return runner === void 0 ? action() : runner(phase, action);
 }
-function recordFrame(internals, world, cameras, lights, renderables, transparentDispatch, frameState, dispatchCounts, bindGroupCounts, skylight, skylightCount, skybox, skyboxCount, postProcessParams, fog, worlds = [world], profilePhase, gpuDriven, renderReadLeases, featureGraphCandidate, pointsLinesOwner, environmentSignature2 = "", fogSignature = "", environmentReady = true, transmissionDemand) {
+var VOLUMETRIC_FOG_PASS_COUNT = 4;
+function nextVolumetricFogParamsSlot(frameState) {
+  const accepted = frameState.volumetricFogParamsAcceptedSlot;
+  const pending = frameState.volumetricFogParamsPendingSlot;
+  if (pending !== null && pending !== accepted) return pending;
+  return accepted === null ? 0 : accepted === 0 ? 1 : 0;
+}
+function stageVolumetricFogParams(internals, frameState, params) {
+  const slot = nextVolumetricFogParamsSlot(frameState);
+  let buffer = frameState.volumetricFogParamsBuffers[slot];
+  if (buffer === null) {
+    const created = internals.device.createBuffer({
+      label: `volumetric-fog-params-${slot}`,
+      size: VOLUMETRIC_FOG_PARAMS_BYTES,
+      usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
+      mappedAtCreation: false
+    });
+    if (!created.ok) {
+      internals.errorRegistry.fire(created.error);
+      return void 0;
+    }
+    buffer = created.value;
+    frameState.volumetricFogParamsBuffers[slot] = buffer;
+  }
+  const written = internals.device.queue.writeBuffer(buffer, 0, params);
+  if (!written.ok) {
+    internals.errorRegistry.fire(written.error);
+    return void 0;
+  }
+  frameState.volumetricFogParamsPendingSlot = slot;
+  frameState.volumetricFogPendingParams = new Float32Array(params);
+  return buffer;
+}
+function retireVolumetricFogParams(internals, frameState) {
+  const buffers = frameState.volumetricFogParamsBuffers;
+  frameState.volumetricFogParamsBuffers = [null, null];
+  frameState.volumetricFogParamsPendingSlot = null;
+  frameState.volumetricFogParamsAcceptedSlot = null;
+  frameState.volumetricFogAcceptedParams = void 0;
+  frameState.volumetricFogPendingParams = void 0;
+  const live = buffers.filter((buffer) => buffer !== null);
+  if (live.length === 0) return;
+  const device = internals.device;
+  const release = () => {
+    for (const buffer of live) {
+      const destroyed = device.destroyBuffer(buffer);
+      if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+    }
+  };
+  try {
+    void device.queue.onSubmittedWorkDone().then(release, release);
+  } catch {
+    release();
+  }
+}
+function volumeRevision(values) {
+  let hash = 2166136261;
+  for (const value of values) {
+    const quantized = Number.isFinite(value) ? Math.round(value * 1e6) : 0;
+    hash = Math.imul(hash ^ quantized, 16777619) >>> 0;
+  }
+  return hash;
+}
+function volumeTemporalSignature(fog, prepared, camera, lights, width, height) {
+  const authored = fog.fog;
+  const directional = lights.directional;
+  const cameraRevision = volumeRevision([
+    ...camera.world,
+    camera.fov,
+    camera.aspect,
+    camera.near,
+    camera.far,
+    camera.orthoLeft,
+    camera.orthoRight,
+    camera.orthoBottom,
+    camera.orthoTop
+  ]);
+  const fogRevision = authored === void 0 ? 0 : volumeRevision([
+    ...authored.bounds.min,
+    ...authored.bounds.max,
+    ...authored.extinction,
+    ...authored.albedo,
+    ...authored.emission,
+    authored.anisotropy,
+    authored.maxDistance
+  ]);
+  const selectedSpot = fog.spotLightEntity === void 0 ? fog.lightKind === "spot" ? lights.spot.find((spot) => spot.entity === fog.lightEntity) : void 0 : lights.spot.find((spot) => spot.entity === fog.spotLightEntity);
+  const selectedPoint = fog.pointLightEntity === void 0 ? fog.lightKind === "point" ? lights.point.find((point) => point.entity === fog.lightEntity) : void 0 : lights.point.find((point) => point.entity === fog.pointLightEntity);
+  const selectedDirectional = fog.lightKind === "directional" && directional?.entity === fog.lightEntity ? directional : void 0;
+  const lightRevision = selectedSpot === void 0 && selectedPoint === void 0 && selectedDirectional === void 0 ? 0 : volumeRevision(
+    selectedSpot === void 0 && selectedPoint === void 0 ? selectedDirectional === void 0 ? [] : [
+      ...selectedDirectional.direction,
+      ...selectedDirectional.color,
+      selectedDirectional.intensity,
+      ...lights.lightViewProj?.flatMap((matrix) => [...matrix]) ?? []
+    ] : [
+      ...selectedPoint === void 0 ? [] : [
+        ...selectedPoint.position,
+        ...selectedPoint.color,
+        selectedPoint.intensity,
+        selectedPoint.invRangeSquared,
+        selectedPoint.shadowAtlasLayer ?? -1,
+        selectedPoint.shadowNear ?? 0,
+        selectedPoint.shadowFar ?? 0
+      ],
+      ...selectedSpot === void 0 ? [] : [
+        ...selectedSpot.position,
+        ...selectedSpot.direction,
+        ...selectedSpot.color,
+        selectedSpot.intensity,
+        selectedSpot.invRangeSquared,
+        selectedSpot.cosInner,
+        selectedSpot.cosOuter,
+        selectedSpot.depthBias ?? 5e-3,
+        selectedSpot.normalBias ?? 0.05,
+        selectedSpot.pcfKernelSize ?? 3,
+        selectedSpot.shadowAtlasTile,
+        ...selectedSpot.lightViewProj === void 0 ? [] : [...selectedSpot.lightViewProj]
+      ]
+    ]
+  );
+  return {
+    cameraRevision,
+    fogRevision,
+    lightRevision,
+    densityGeneration: prepared.densityGeneration,
+    width,
+    height,
+    ...fog.lightKind === void 0 ? {} : { lightKind: fog.lightKind },
+    ...fog.lightEntity === void 0 ? {} : { lightEntity: fog.lightEntity },
+    ...fog.pointLightEntity === void 0 ? {} : { pointLightEntity: fog.pointLightEntity },
+    ...fog.spotLightEntity === void 0 ? {} : { spotLightEntity: fog.spotLightEntity },
+    ...fog.projector === void 0 ? {} : { projector: fog.projector },
+    lightShadowRevision: lightRevision
+  };
+}
+function resolveVolumetricFogHistoryContext(frameState, graph, fog, prepared, camera, lights, width, height) {
+  const signature = volumeTemporalSignature(fog, prepared, camera, lights, width, height);
+  const acceptedGraph = frameState.volumetricFogHistoryGraph;
+  const acceptedSlot = frameState.volumetricFogHistorySlot;
+  const previousSignature = frameState.volumetricFogHistorySignature;
+  let reset = acceptedGraph !== graph || acceptedSlot === null || previousSignature === null;
+  if (!reset && previousSignature !== null) {
+    const temporal = frameState.temporalFrame;
+    const previousResetReason = temporal?.resetReason;
+    const reprojection = previousResetReason === "out-of-screen" ? "out-of-screen" : previousResetReason === "depth-discontinuity" ? "depth-discontinuity" : void 0;
+    reset = resolveVolumeTemporalReset(previousSignature, signature, {
+      taaEnabled: camera.antialias === "taa",
+      ...reprojection === void 0 ? {} : { reprojection }
+    }).reset;
+  }
+  const historyReadSlot = reset ? null : acceptedSlot;
+  const historyWriteSlot = reset || acceptedSlot === null ? 0 : acceptedSlot === 0 ? 1 : 0;
+  return {
+    context: {
+      ...prepared,
+      historyReadSlot,
+      historyWriteSlot,
+      historyValid: historyReadSlot !== null
+    },
+    signature
+  };
+}
+function prepareVolumetricFogFrame(internals, frameState, world, worlds, fog, lights, volumeCapability, projector) {
+  if (!volumeCapability || fog?.status !== "available" || fog.fog === void 0 || fog.densityHandle === void 0 || fog.densityAsset === void 0 || (fog.lightKind === "spot" ? lights.spot.find((light) => light.entity === fog.lightEntity) === void 0 : fog.lightKind === "point" ? lights.point.find((light) => light.entity === fog.lightEntity) === void 0 : lights.directional === void 0)) {
+    return void 0;
+  }
+  const ownerWorld = worlds[fog.worldId ?? 0] ?? world;
+  const resident = internals.gpuStore.ensureResident(
+    fog.densityHandle,
+    fog.densityAsset,
+    ownerWorld
+  );
+  if (!resident.ok || !("texture" in resident.value)) {
+    if (!resident.ok) {
+      internals.errorRegistry.fire(
+        resident.error instanceof RhiError ? resident.error : new RhiError({
+          code: "webgpu-runtime-error",
+          expected: "volumetric density residency to resolve a GPU texture",
+          hint: "repair the authored TextureAsset payload and retry the next frame",
+          detail: { error: resident.error }
+        })
+      );
+    }
+    return void 0;
+  }
+  const params = new Float32Array(32);
+  params.set(fog.fog.bounds.min, 0);
+  params.set(fog.fog.bounds.max, 4);
+  params.set(fog.fog.extinction, 8);
+  params.set(fog.fog.albedo, 12);
+  params.set(fog.fog.emission, 16);
+  const selectedPoint = fog.pointLightEntity === void 0 ? void 0 : lights.point.find((light) => light.entity === fog.pointLightEntity);
+  const selectedSpot = fog.spotLightEntity === void 0 ? fog.lightKind === "spot" ? lights.spot.find((light) => light.entity === fog.lightEntity) : void 0 : lights.spot.find((light) => light.entity === fog.spotLightEntity);
+  const lightDirection = selectedSpot?.direction ?? lights.directional?.direction ?? vec3.create(0, -1, 0);
+  const lightColor = selectedSpot?.color ?? lights.directional?.color ?? vec3.create(0, 0, 0);
+  if (lightDirection === void 0 || lightColor === void 0) return void 0;
+  params.set(lightDirection, 20);
+  params[23] = frameState.frameNumber % 1024;
+  const selectedSpotIndex = selectedSpot === void 0 ? -1 : lights.spot.findIndex((light) => light.entity === selectedSpot.entity);
+  params.set(lightColor, 24);
+  params[19] = selectedPoint === void 0 ? -1 : lights.point.findIndex((light) => light.entity === selectedPoint.entity);
+  params[27] = selectedSpotIndex;
+  params[28] = fog.fog.maxDistance;
+  params[29] = fog.fog.anisotropy;
+  params[30] = selectedPoint !== void 0 && selectedSpot !== void 0 ? 3 : selectedPoint !== void 0 ? 1 : selectedSpot !== void 0 ? 2 : 0;
+  params[31] = frameState.temporalFrame !== void 0 && frameState.temporalFrame.resetReason === "none" ? 1 : 0;
+  const paramsBuffer = stageVolumetricFogParams(internals, frameState, params);
+  if (paramsBuffer === void 0) return void 0;
+  return {
+    densityTexture: resident.value.texture.handle,
+    densityView: resident.value.view,
+    paramsBuffer,
+    densityGeneration: resident.value.receipt.generation,
+    historyReadSlot: null,
+    historyWriteSlot: 0,
+    historyValid: false,
+    ...projector === void 0 ? {} : {
+      projectorTexture: projector.texture,
+      projectorView: projector.view,
+      projectorSampler: projector.sampler
+    }
+  };
+}
+function prepareSpotLightProjectorFrame(internals, world, worlds, lights, fog) {
+  const preferred = fog?.projectorHandle === void 0 ? void 0 : lights.spot.find((light) => light.projectorHandle === fog.projectorHandle);
+  const source = preferred ?? lights.spot.find(
+    (light) => light.projectorHandle !== void 0 && light.projectorAsset !== void 0 && light.lightViewProj !== void 0
+  );
+  if (source === void 0 || source.projectorHandle === void 0 || source.projectorAsset === void 0) {
+    return void 0;
+  }
+  const ownerWorld = worlds[fog?.worldId ?? 0] ?? world;
+  const resident = internals.gpuStore.ensureResident(
+    source.projectorHandle,
+    source.projectorAsset,
+    ownerWorld
+  );
+  if (!resident.ok || !("texture" in resident.value)) {
+    if (!resident.ok) {
+      internals.errorRegistry.fire(
+        resident.error instanceof RhiError ? resident.error : new RhiError({
+          code: "webgpu-runtime-error",
+          expected: "SpotLight projector residency to resolve a GPU texture",
+          hint: "repair the authored projector TextureAsset payload and retry the next frame",
+          detail: { error: resident.error }
+        })
+      );
+    }
+    return void 0;
+  }
+  const sampler = internals.device.createSampler({
+    label: "spot-projector-linear-clamp",
+    minFilter: "linear",
+    magFilter: "linear",
+    mipmapFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge"
+  });
+  if (!sampler.ok) {
+    internals.errorRegistry.fire(sampler.error);
+    return void 0;
+  }
+  return {
+    texture: resident.value.texture.handle,
+    view: resident.value.view,
+    sampler: sampler.value
+  };
+}
+function stageAcceptedVolumetricFogFrame(internals, frameState, accepted) {
+  if (accepted === void 0) return void 0;
+  const params = frameState.volumetricFogAcceptedParams;
+  if (params === void 0) return accepted;
+  const paramsBuffer = stageVolumetricFogParams(internals, frameState, new Float32Array(params));
+  if (paramsBuffer === void 0) return accepted;
+  return { ...accepted, paramsBuffer };
+}
+function updateVolumetricFogInspection(frameState, fog, lights, prepared, submitted, volumeCapability, volumeSubmissionAttempted) {
+  const resourceFacts = frameState.compiledFrameGraph === void 0 || frameState.compiledFrameGraph === null ? void 0 : inspectVolumetricFogResources(frameState.compiledFrameGraph.inspect(), {
+    parameterBufferCount: frameState.volumetricFogParamsBuffers.filter(
+      (buffer) => buffer !== null
+    ).length
+  });
+  const graphSampleCount = resourceFacts?.sampleCount ?? 0;
+  const graphMemoryBytes = resourceFacts?.totalBytes ?? 0;
+  const previous = frameState.volumetricFogInspection;
+  const accepted = frameState.volumetricFogAccepted;
+  const acceptedLkg = accepted === void 0 ? void 0 : {
+    guid: accepted.guid ?? previous.guid,
+    generation: accepted.generation ?? previous.generation,
+    digest: accepted.digest ?? previous.digest,
+    deviceEpoch: previous.deviceEpoch,
+    format: previous.format ?? accepted.densityAsset?.format ?? fog?.densityAsset?.format,
+    passCount: previous.passCount > 0 ? previous.passCount : VOLUMETRIC_FOG_PASS_COUNT,
+    sampleCount: previous.sampleCount > 0 ? previous.sampleCount : graphSampleCount,
+    memoryBytes: previous.memoryBytes > 0 ? previous.memoryBytes : graphMemoryBytes,
+    resourceFacts: previous.resourceFacts ?? resourceFacts,
+    lightEntity: accepted.lightEntity,
+    lightKind: accepted.lightKind,
+    pointLightEntity: accepted.pointLightEntity,
+    spotLightEntity: accepted.spotLightEntity,
+    projector: accepted.projector
+  };
+  const candidateIdentity = fog?.guid === void 0 || fog.generation === void 0 ? void 0 : {
+    guid: fog.guid,
+    generation: fog.generation,
+    digest: fog.digest
+  };
+  const selectedLightAvailable = fog?.lightKind === "spot" ? lights.spot.some((light) => light.entity === fog.lightEntity) : fog?.lightKind === "point" ? lights.point.some(
+    (light) => light.entity === (fog.pointLightEntity ?? fog.lightEntity)
+  ) && (fog.spotLightEntity === void 0 || lights.spot.some((light) => light.entity === fog.spotLightEntity)) : fog?.lightKind === "directional" ? lights.directional?.entity === fog.lightEntity : lights.directional !== void 0;
+  const capability = volumeCapability && selectedLightAvailable ? "available" : "unavailable";
+  const inspectAccepted = (status, candidateFailure) => {
+    if (acceptedLkg === void 0 || acceptedLkg.guid === void 0 || acceptedLkg.generation === void 0) {
+      return false;
+    }
+    const recovery = {
+      guid: acceptedLkg.guid,
+      generation: acceptedLkg.generation,
+      deviceEpoch: acceptedLkg.deviceEpoch,
+      status,
+      ...{ lkgGeneration: acceptedLkg.generation } ,
+      ...candidateIdentity === void 0 ? {} : {
+        candidateGeneration: candidateIdentity.generation,
+        ...candidateIdentity.digest === void 0 ? {} : { candidateDigest: candidateIdentity.digest }
+      },
+      ...acceptedLkg.lightEntity === void 0 || acceptedLkg.lightKind === void 0 ? {} : {
+        selectedLight: {
+          entity: acceptedLkg.lightEntity,
+          kind: acceptedLkg.lightKind,
+          revision: 0,
+          shadowTile: -1,
+          ...acceptedLkg.pointLightEntity === void 0 ? {} : { pointLightEntity: acceptedLkg.pointLightEntity },
+          ...acceptedLkg.spotLightEntity === void 0 ? {} : { spotLightEntity: acceptedLkg.spotLightEntity },
+          ...acceptedLkg.projector === void 0 ? {} : { projector: acceptedLkg.projector }
+        }
+      },
+      ...candidateFailure === void 0 ? {} : { candidateFailure }
+    };
+    frameState.volumetricFogInspection = inspectVolumetricFog({
+      authored: true,
+      capability: "available",
+      degraded: status === "degraded",
+      recovery,
+      ...acceptedLkg.digest === void 0 ? {} : { acceptedDigest: acceptedLkg.digest },
+      ...acceptedLkg.format === void 0 ? {} : { format: acceptedLkg.format },
+      passCount: acceptedLkg.passCount,
+      sampleCount: acceptedLkg.sampleCount,
+      memoryBytes: acceptedLkg.memoryBytes,
+      ...acceptedLkg.resourceFacts === void 0 ? {} : { resourceFacts: acceptedLkg.resourceFacts }
+    });
+    return true;
+  };
+  if (fog === void 0 || fog.status === "off") {
+    if (!submitted && volumeSubmissionAttempted && inspectAccepted("degraded", "submit-failed")) {
+      return;
+    }
+    if (!submitted && volumeSubmissionAttempted) return;
+    if (!submitted) return;
+    frameState.volumetricFogInspection = inspectVolumetricFog({
+      authored: false,
+      capability: "available"
+    });
+    return;
+  }
+  const authored = fog.status === "available" || fog.status === "degraded";
+  if (submitted && fog.status === "available" && prepared !== void 0 && capability === "available") {
+    const recovery = candidateIdentity === void 0 ? void 0 : {
+      guid: candidateIdentity.guid,
+      generation: candidateIdentity.generation,
+      deviceEpoch: previous.deviceEpoch,
+      status: "accepted",
+      ...fog.lightEntity === void 0 || fog.lightKind === void 0 ? {} : {
+        selectedLight: {
+          entity: fog.lightEntity,
+          kind: fog.lightKind,
+          revision: 0,
+          shadowTile: lights.spot.find((spot) => spot.entity === fog.spotLightEntity)?.shadowAtlasTile ?? lights.spot.find((spot) => spot.entity === fog.lightEntity)?.shadowAtlasTile ?? -1,
+          ...fog.pointLightEntity === void 0 ? {} : { pointLightEntity: fog.pointLightEntity },
+          ...fog.spotLightEntity === void 0 ? {} : { spotLightEntity: fog.spotLightEntity },
+          ...fog.projector === void 0 ? {} : { projector: fog.projector }
+        }
+      }
+    };
+    frameState.volumetricFogInspection = inspectVolumetricFog({
+      authored: true,
+      capability,
+      ...recovery === void 0 ? {} : { recovery },
+      ...candidateIdentity?.digest === void 0 ? {} : { acceptedDigest: candidateIdentity.digest },
+      ...fog.densityAsset?.format === void 0 ? {} : { format: fog.densityAsset.format },
+      passCount: VOLUMETRIC_FOG_PASS_COUNT,
+      sampleCount: graphSampleCount,
+      memoryBytes: graphMemoryBytes,
+      ...resourceFacts === void 0 ? {} : { resourceFacts }
+    });
+    return;
+  }
+  if (submitted && acceptedLkg !== void 0 && (fog.status === "degraded" || prepared === void 0)) {
+    if (inspectAccepted("degraded")) return;
+  }
+  if (!submitted && volumeSubmissionAttempted && inspectAccepted("degraded", "submit-failed")) {
+    return;
+  }
+  const candidateRecovery = candidateIdentity === void 0 ? void 0 : {
+    guid: candidateIdentity.guid,
+    generation: candidateIdentity.generation,
+    deviceEpoch: previous.deviceEpoch,
+    status: "candidate",
+    candidateGeneration: candidateIdentity.generation,
+    ...candidateIdentity.digest === void 0 ? {} : { candidateDigest: candidateIdentity.digest },
+    ...!submitted && volumeSubmissionAttempted ? { candidateFailure: "submit-failed" } : {}
+  };
+  frameState.volumetricFogInspection = inspectVolumetricFog({
+    authored,
+    capability,
+    degraded: fog.status === "degraded" || capability === "unavailable",
+    ...candidateRecovery === void 0 ? {} : { recovery: candidateRecovery },
+    ...acceptedLkg?.digest === void 0 ? {} : { acceptedDigest: acceptedLkg.digest },
+    ...fog.densityAsset?.format === void 0 ? acceptedLkg?.format === void 0 ? {} : { format: acceptedLkg.format } : { format: fog.densityAsset.format },
+    passCount: 0,
+    sampleCount: 0,
+    memoryBytes: 0
+  });
+}
+function recordFrame(internals, world, cameras, lights, renderables, transparentDispatch, frameState, dispatchCounts, bindGroupCounts, skylight, skylightCount, skybox, skyboxCount, postProcessParams, fog, worlds = [world], profilePhase, gpuDriven, renderReadLeases, featureGraphCandidate, pointsLinesOwner, environmentSignature2 = "", fogSignature = "", environmentReady = true, transmissionDemand, volumetricFog, timingCapture) {
   let activeCameras = cameras;
   if (activeCameras.length === 0) {
     internals.errorRegistry.fire(
@@ -8992,6 +10501,11 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
     );
     activeCameras = [makeZeroCameraFallbackSnapshot()];
   }
+  let submitted = false;
+  let volumeInspectionReady = false;
+  let volumeSubmissionAttempted = false;
+  let preparedVolumetricFogForInspection;
+  let volumeCapabilityForInspection = false;
   try {
     if (activeCameras.length > 1) {
       internals.errorRegistry.fire(
@@ -9047,6 +10561,39 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
     const effectiveShadowMapSize = resolveShadowMapSize(internals, lights);
     const effectiveSpotShadowMapSize = resolveSpotShadowMapSize(internals, lights);
     const graphShadowMapSize = effectiveShadowMapSize ?? effectiveSpotShadowMapSize;
+    const volumeCapability = hasVolumetricFogCapability(
+      internals.device.caps,
+      internals.volumetricFogShaders
+    );
+    volumeInspectionReady = true;
+    volumeCapabilityForInspection = volumeCapability;
+    const preparedSpotLightProjector = prepareSpotLightProjectorFrame(
+      internals,
+      world,
+      worlds,
+      lights,
+      volumetricFog
+    );
+    const preparedVolumetricFog = prepareVolumetricFogFrame(
+      internals,
+      frameState,
+      world,
+      worlds,
+      volumetricFog,
+      lights,
+      volumeCapability,
+      preparedSpotLightProjector
+    );
+    preparedVolumetricFogForInspection = preparedVolumetricFog;
+    const acceptedFallback = volumeCapability && volumetricFog !== void 0 && preparedVolumetricFog === void 0 ? frameState.volumetricFogAccepted : void 0;
+    const acceptedFallbackContext = acceptedFallback === void 0 ? void 0 : stageAcceptedVolumetricFogFrame(
+      internals,
+      frameState,
+      frameState.volumetricFogAcceptedContext
+    );
+    const graphVolumetricFog = volumeCapability ? preparedVolumetricFog === void 0 ? acceptedFallback : volumetricFog : void 0;
+    const baseVolumetricFogContext = preparedVolumetricFog ?? acceptedFallbackContext;
+    const volumeTopologyCandidate = graphVolumetricFog?.status === "available" && baseVolumetricFogContext !== void 0 || graphVolumetricFog === void 0 && frameState.volumetricFogAccepted !== void 0 || volumetricFog?.status === "degraded" && acceptedFallback !== void 0;
     let preparedGpuDriven;
     if (gpuDriven !== void 0) {
       const prepared = gpuDriven.owner.prepare({
@@ -9079,7 +10626,9 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
         preparedGpuDriven,
         featureGraphCandidate,
         cameras.length === 0,
-        transmissionDemand
+        transmissionDemand,
+        graphVolumetricFog,
+        volumeTopologyCandidate
       )
     );
     if (preflightGraph === null) return false;
@@ -9151,6 +10700,35 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       })
     } : { kind: "taa", view: temporalView };
     const recordCamera = temporalView === void 0 ? camera : { ...camera, temporal: temporalView };
+    let activeVolumetricFogContext;
+    let activeVolumetricFogSignature;
+    if (graphVolumetricFog?.status === "available" && baseVolumetricFogContext !== void 0) {
+      const resolvedHistory = resolveVolumetricFogHistoryContext(
+        frameState,
+        preflightGraph,
+        graphVolumetricFog,
+        baseVolumetricFogContext,
+        camera,
+        lights,
+        targetW,
+        targetH
+      );
+      activeVolumetricFogContext = resolvedHistory.context;
+      activeVolumetricFogSignature = resolvedHistory.signature;
+      const historyFlag = new Float32Array([activeVolumetricFogContext.historyValid ? 1 : 0]);
+      if (frameState.volumetricFogPendingParams !== void 0) {
+        frameState.volumetricFogPendingParams[31] = historyFlag[0] ?? 0;
+      }
+      const historyFlagWritten = internals.device.queue.writeBuffer(
+        activeVolumetricFogContext.paramsBuffer,
+        31 * Float32Array.BYTES_PER_ELEMENT,
+        historyFlag
+      );
+      if (!historyFlagWritten.ok) {
+        internals.errorRegistry.fire(historyFlagWritten.error);
+        return false;
+      }
+    }
     const depthView = null;
     const clear = [
       camera.clearColor[0],
@@ -9227,7 +10805,13 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       }
       ldrSpritePassView = unormViewRes.value;
     }
-    if (validatedOrdered.length > 0 || skyboxActive) {
+    const currentViewProjection = mat4.create();
+    mat4.multiply(
+      currentViewProjection,
+      computeProjectionMatrix(camera),
+      computeViewMatrix(camera)
+    );
+    if (validatedOrdered.length > 0 || skyboxActive || activeVolumetricFogContext !== void 0 || preparedVolumetricFog !== void 0) {
       runRecordProfilePhase(profilePhase, "record/uploads", () => {
         writeViewUbo(
           internals.device.queue,
@@ -9341,6 +10925,9 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       geometryColorResolveView,
       ldrSpriteColorView,
       postProcessParams: framePostProcessParams,
+      ...internals.volumetricFogShaders === void 0 ? {} : { volumetricFogShaders: internals.volumetricFogShaders },
+      ...activeVolumetricFogContext === void 0 ? {} : { volumetricFog: activeVolumetricFogContext },
+      ...preparedSpotLightProjector === void 0 ? {} : { spotLightProjector: preparedSpotLightProjector },
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
@@ -9354,7 +10941,21 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...profilePhase !== void 0 ? { profilePhase } : {}
     };
-    const submitted = runRecordProfilePhase(
+    const stagedTemporalFrame = {
+      frameId: frameState.frameNumber,
+      currentViewProjection: new Float32Array(currentViewProjection),
+      jitter: [0, 0],
+      viewport: { width: targetW, height: targetH },
+      cameraPosition: [
+        camera.position[0] ?? 0,
+        camera.position[1] ?? 0,
+        camera.position[2] ?? 0
+      ]
+    };
+    frameState.temporalFrameInput = stagedTemporalFrame;
+    frameState.temporalFrameTransaction.stage(stagedTemporalFrame);
+    volumeSubmissionAttempted = volumeTopologyCandidate || activeVolumetricFogContext !== void 0;
+    submitted = runRecordProfilePhase(
       profilePhase,
       "record/graph-execute",
       () => executeCompiledFrameGraph(
@@ -9362,14 +10963,56 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
         frameState,
         passCtx,
         encoder,
-        profilePhase === void 0 ? void 0 : (pass, encode) => profilePhase(graphExecutionPhase(pass.name), encode)
+        profilePhase === void 0 ? void 0 : (pass, encode) => profilePhase(graphExecutionPhase(pass.name), encode),
+        timingCapture
       )
     );
     if (submitted && !directionalShadowCache.reuse) {
       frameState.directionalShadowCache = frameState.directionalShadowCacheRecorded ? directionalShadowCache.next : null;
     }
+    if (submitted) {
+      if (graphVolumetricFog === void 0) {
+        frameState.volumetricFogAccepted = void 0;
+        frameState.volumetricFogAcceptedContext = void 0;
+        frameState.volumetricFogHistoryGraph = null;
+        frameState.volumetricFogHistorySlot = null;
+        frameState.volumetricFogHistorySignature = null;
+        retireVolumetricFogParams(internals, frameState);
+      } else if (activeVolumetricFogContext !== void 0 && activeVolumetricFogSignature !== void 0) {
+        frameState.volumetricFogHistoryGraph = preflightGraph;
+        frameState.volumetricFogHistorySlot = activeVolumetricFogContext.historyWriteSlot;
+        frameState.volumetricFogHistorySignature = activeVolumetricFogSignature;
+        if (frameState.volumetricFogParamsPendingSlot !== null) {
+          frameState.volumetricFogParamsAcceptedSlot = frameState.volumetricFogParamsPendingSlot;
+          frameState.volumetricFogAcceptedParams = frameState.volumetricFogPendingParams === void 0 ? void 0 : new Float32Array(frameState.volumetricFogPendingParams);
+          frameState.volumetricFogParamsPendingSlot = null;
+          frameState.volumetricFogPendingParams = void 0;
+        }
+        if (volumetricFog?.status === "available" && preparedVolumetricFog !== void 0) {
+          frameState.volumetricFogAccepted = volumetricFog;
+          frameState.volumetricFogAcceptedContext = activeVolumetricFogContext;
+        } else if (acceptedFallback !== void 0) {
+          frameState.volumetricFogAcceptedContext = activeVolumetricFogContext;
+        }
+      } else if (volumetricFog?.status === "available" && preparedVolumetricFog !== void 0) {
+        frameState.volumetricFogAccepted = volumetricFog;
+        frameState.volumetricFogAcceptedContext = preparedVolumetricFog;
+      }
+    }
     return submitted;
   } finally {
+    settleVolumetricFogGraphCandidate(frameState, submitted);
+    if (volumeInspectionReady && (submitted || volumeSubmissionAttempted)) {
+      updateVolumetricFogInspection(
+        frameState,
+        volumetricFog,
+        lights,
+        preparedVolumetricFogForInspection,
+        submitted,
+        volumeCapabilityForInspection,
+        volumeSubmissionAttempted
+      );
+    }
     frameState.frameNumber += 1;
     frameState.hdrpOncePerFrameFired.clear();
   }
@@ -10728,6 +12371,131 @@ function selectFogFrame(world) {
   });
   throw fogSelection.error;
 }
+function textureDigest(texture) {
+  let hash = 2166136261;
+  for (const byte of texture.data) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+  return `fnv1a:${hash.toString(16).padStart(8, "0")}`;
+}
+function extractVolumeSnapshot(world, assets, worldInternal) {
+  const query = world.query({ read: [VolumetricFog] }).unwrap();
+  const authorings = [];
+  let selectedLight;
+  let first;
+  for (const row of query) {
+    const source = row.get(VolumetricFog);
+    if (source.light === null) continue;
+    const selected = resolveSelectedVolumetricLight(world, source.light);
+    if (selected.status === "available") {
+      const pairSpot = source.spotLight === null ? void 0 : source.spotLight;
+      selectedLight ??= {
+        entity: selected.entity,
+        kind: selected.kind,
+        ...selected.kind === "point" ? { pointLightEntity: selected.entity } : {},
+        ...pairSpot === void 0 ? {} : { spotLightEntity: pairSpot }
+      };
+    }
+    const densityHandle = toShared(Math.round(Number(source.density)));
+    const resolved2 = resolveAssetHandle(world, densityHandle);
+    if (!resolved2.ok || resolved2.value.kind !== "texture") {
+      worldInternal._routeError(
+        resolved2.ok ? new RhiError({
+          code: "asset-not-registered",
+          expected: "VolumetricFog.density resolves to a TextureAsset",
+          hint: "load a TextureAsset before assigning it to VolumetricFog.density",
+          detail: { assetHandle: Number(densityHandle) }
+        }) : resolved2.error,
+        { severity: Severity.Error, systemName: "RenderSystem.extract (volumetric-density)" }
+      );
+      return { status: "degraded" };
+    }
+    const densityAsset = resolved2.value;
+    const guid = assets?.guidOf(densityAsset) ?? `handle:${Number(densityHandle)}`;
+    const shape = densityAsset.shape;
+    const density = shape.viewDimension === "3d" ? {
+      guid,
+      generation: 1,
+      shape: {
+        viewDimension: "3d",
+        extent: {
+          width: shape.extent.width,
+          height: shape.extent.height,
+          depth: shape.extent.depth
+        }
+      },
+      format: densityAsset.format,
+      colorSpace: densityAsset.colorSpace
+    } : {
+      guid,
+      generation: 1,
+      shape: {
+        viewDimension: shape.viewDimension,
+        extent: shape.viewDimension === "2d-array" ? {
+          width: shape.extent.width,
+          height: shape.extent.height,
+          layers: shape.extent.layers
+        } : { width: shape.extent.width, height: shape.extent.height }
+      },
+      format: densityAsset.format,
+      colorSpace: densityAsset.colorSpace
+    };
+    const authoring = {
+      light: source.light,
+      density,
+      bounds: {
+        min: [source.boundsMin[0] ?? 0, source.boundsMin[1] ?? 0, source.boundsMin[2] ?? 0],
+        max: [source.boundsMax[0] ?? 0, source.boundsMax[1] ?? 0, source.boundsMax[2] ?? 0]
+      },
+      extinction: [source.extinction[0] ?? 0, source.extinction[1] ?? 0, source.extinction[2] ?? 0],
+      albedo: [source.albedo[0] ?? 0, source.albedo[1] ?? 0, source.albedo[2] ?? 0],
+      emission: [source.emission[0] ?? 0, source.emission[1] ?? 0, source.emission[2] ?? 0],
+      anisotropy: source.anisotropy,
+      maxDistance: source.maxDistance
+    };
+    authorings.push(authoring);
+    first ??= { densityHandle, densityAsset, guid };
+  }
+  if (authorings.length === 0) return void 0;
+  const extracted = extractVolumetricFog(authorings);
+  if (!extracted.ok) {
+    worldInternal._routeError(extracted.error, {
+      severity: Severity.Error,
+      systemName: "RenderSystem.extract (volumetric-fog)"
+    });
+    return {
+      status: "degraded",
+      ...first === void 0 ? {} : {
+        densityHandle: first.densityHandle,
+        densityAsset: first.densityAsset,
+        guid: first.guid,
+        generation: 1,
+        digest: textureDigest(first.densityAsset),
+        ...selectedLight === void 0 ? {} : {
+          lightEntity: selectedLight.entity,
+          lightKind: selectedLight.kind,
+          ...selectedLight.pointLightEntity === void 0 ? {} : { pointLightEntity: selectedLight.pointLightEntity },
+          ...selectedLight.spotLightEntity === void 0 ? {} : { spotLightEntity: selectedLight.spotLightEntity }
+        }
+      }
+    };
+  }
+  if (extracted.value.status === "off" || first === void 0) return { status: "off" };
+  const selectedLightFields = selectedLight === void 0 ? {} : {
+    lightEntity: selectedLight.entity,
+    lightKind: selectedLight.kind,
+    ...selectedLight.pointLightEntity === void 0 ? {} : { pointLightEntity: selectedLight.pointLightEntity },
+    ...selectedLight.spotLightEntity === void 0 ? {} : { spotLightEntity: selectedLight.spotLightEntity }
+  };
+  return {
+    status: "available",
+    fog: extracted.value.fog,
+    densityHandle: first.densityHandle,
+    densityAsset: first.densityAsset,
+    guid: first.guid,
+    generation: 1,
+    digest: textureDigest(first.densityAsset),
+    ...selectedLightFields
+  };
+}
 function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCachesByWorld, options = {}) {
   const cameraOwner = typeof owner === "number" ? owner : owner.cameraOwner;
   const resourceOwner = typeof owner === "number" ? owner : owner.resourceOwner;
@@ -10768,9 +12536,9 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
       });
       const frame = extractFrame(world, prepared);
       framesByWorld.set(wi, frame);
-    } catch (err31) {
+    } catch (err32) {
       try {
-        createWorldInternalView(world)._routeError(err31, {
+        createWorldInternalView(world)._routeError(err32, {
           severity: Severity.Error,
           systemName: `RenderSystem.extractFrames(world[${wi}])`
         });
@@ -10899,6 +12667,7 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
     directionalCsmConfig,
     directionalCsmDirection
   };
+  const volumetricFog = resourceOwnerFrame?.volumetricFog;
   const skylight = resourceOwnerFrame?.skylight;
   const skylightCount = resourceOwnerFrame?.skylightCount ?? 0;
   const skybox = resourceOwnerFrame?.skybox;
@@ -10923,6 +12692,7 @@ function extractFrames(worlds, owner, assets, pipelineState, materialSnapshotCac
   return {
     cameras,
     lights,
+    ...volumetricFog === void 0 ? {} : { volumetricFog: { ...volumetricFog, worldId: resourceOwner } },
     renderables,
     dispatch: dispatchEntries,
     skylight,
@@ -10991,6 +12761,7 @@ function extractFrame(world, context) {
   const skinPaletteAllocator = pipelineState?.skinPaletteAllocator ?? null;
   const directionalLightQuery = world.query({ read: [DirectionalLight] }).unwrap();
   const worldInternal = createWorldInternalView(world);
+  let volumetricFog = extractVolumeSnapshot(world, assets, worldInternal);
   const cameras = extractCameraSnapshots(world);
   let directional;
   let directionalCount = 0;
@@ -11002,6 +12773,7 @@ function extractFrame(world, context) {
     const intensity = l.intensity;
     const snapshot = {
       kind: "directional",
+      entity: row.entity,
       direction: vec3.create(l.direction[0] ?? 0, l.direction[1] ?? -1, l.direction[2] ?? 0),
       color: vec3.create(
         (l.color[0] ?? 1) * intensity,
@@ -11045,6 +12817,7 @@ function extractFrame(world, context) {
     const position = worldMat !== void 0 ? mat4.getTranslation(vec3.create(), worldMat) : vec3.create(0, 0, 0);
     pointSnapshots.push({
       kind: "point",
+      entity: entityId,
       position,
       color: vec3.create(
         (p.color[0] ?? 1) * intensity,
@@ -11104,9 +12877,11 @@ function extractFrame(world, context) {
     const sMapSize = s.mapSize;
     const sNearPlane = s.nearPlane;
     const sFarPlane = s.farPlane;
+    const shadowIntensity = s.shadowIntensity;
+    const hasProjector = Number(s.projector) > 0;
     let lightViewProj2;
     let shadowAtlasTile = -1;
-    if (castShadow && hasValidDirection) {
+    if ((castShadow || hasProjector) && hasValidDirection) {
       const target4 = vec3.create(
         (position[0] ?? 0) + (dirN[0] ?? 0),
         (position[1] ?? 0) + (dirN[1] ?? 0),
@@ -11119,13 +12894,36 @@ function extractFrame(world, context) {
       mat4.lookAt(view, position, target4, vec3.create(0, 1, 0));
       lightViewProj2 = new Float32Array(16);
       mat4.multiply(lightViewProj2, proj, view);
-      if (spotTileNext < 4) {
+      if (castShadow && spotTileNext < 4) {
         shadowAtlasTile = spotTileNext;
         spotTileNext += 1;
       }
     }
+    let projectorHandle;
+    let projectorAsset;
+    let projectorGuid;
+    if (hasProjector) {
+      const candidate = toShared(Math.round(Number(s.projector)));
+      const resolvedProjector = resolveAssetHandle(world, candidate);
+      if (!resolvedProjector.ok || resolvedProjector.value.kind !== "texture") {
+        worldInternal._routeError(
+          resolvedProjector.ok ? new RhiError({
+            code: "asset-not-registered",
+            expected: "SpotLight.projector resolves to a TextureAsset",
+            hint: "load the authored projector TextureAsset before assigning SpotLight.projector",
+            detail: { assetHandle: Number(candidate) }
+          }) : resolvedProjector.error,
+          { severity: Severity.Error, systemName: "RenderSystem.extract (spot-projector)" }
+        );
+      } else {
+        projectorHandle = candidate;
+        projectorAsset = resolvedProjector.value;
+        projectorGuid = assets?.guidOf(projectorAsset) ?? `handle:${Number(candidate)}`;
+      }
+    }
     spotSnapshots.push({
       kind: "spot",
+      entity: row.entity,
       // D-6: position reflects world transform; direction stays sourced
       // from SpotLight.direction (NOT rotated by the parent).
       position,
@@ -11145,9 +12943,46 @@ function extractFrame(world, context) {
       mapSize: sMapSize,
       nearPlane: sNearPlane,
       farPlane: sFarPlane,
-      shadowAtlasTile
+      shadowAtlasTile,
+      shadowIntensity,
+      depthBias: s.depthBias,
+      normalBias: s.normalBias,
+      pcfKernelSize: s.pcfKernelSize,
+      ...projectorHandle === void 0 || projectorAsset === void 0 || projectorGuid === void 0 ? {} : {
+        projectorHandle,
+        projectorAsset,
+        projectorGuid,
+        projectorGeneration: 1,
+        projectorRevision: 1
+      }
     });
   }
+  let volumeSpot;
+  const extractedFog = volumetricFog;
+  if (extractedFog !== void 0) {
+    if (extractedFog.spotLightEntity !== void 0) {
+      volumeSpot = spotSnapshots.find((light) => light.entity === extractedFog.spotLightEntity);
+    } else if (extractedFog.lightKind === "spot") {
+      volumeSpot = spotSnapshots.find((light) => light.entity === extractedFog.lightEntity);
+    }
+  }
+  if (volumetricFog !== void 0 && volumetricFog.status === "available" && volumeSpot?.projectorAsset !== void 0 && volumeSpot.projectorHandle !== void 0) {
+    const projectorHandle = volumeSpot.projectorHandle;
+    const projectorAsset = volumeSpot.projectorAsset;
+    volumetricFog = {
+      ...volumetricFog,
+      projector: {
+        guid: volumeSpot.projectorGuid ?? `handle:${Number(volumeSpot.projectorHandle)}`,
+        generation: volumeSpot.projectorGeneration ?? 1,
+        view: "2d",
+        sampler: "linear-clamp-to-edge",
+        projection: "spot-projection",
+        revision: volumeSpot.projectorRevision ?? 1
+      },
+      projectorHandle,
+      projectorAsset
+    };
+  }
   let lightViewProj;
   let splitPlanes;
   let cascadeCount;
@@ -11672,28 +13507,28 @@ function extractFrame(world, context) {
           } else {
             const resolvedResult = walkMaterialPassesOverSharedRefs(world, tagged, assets);
             if (!resolvedResult.ok) {
-              const err31 = resolvedResult.error;
-              switch (err31.code) {
+              const err32 = resolvedResult.error;
+              switch (err32.code) {
                 case "material-parent-not-found":
                 case "material-no-effective-pass":
                 case "material-value-unknown":
                 case "material-value-type-mismatch":
                 case "material-contract-program-mismatch":
-                  worldInternal._routeError(err31, {
+                  worldInternal._routeError(err32, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (${err31.code})`
+                    systemName: `RenderSystem.extract (${err32.code})`
                   });
                   break;
                 case "material-circular-inheritance":
-                  worldInternal._routeError(err31, {
+                  worldInternal._routeError(err32, {
                     severity: Severity.Error,
                     systemName: "RenderSystem.extract (material-circular-inheritance)"
                   });
                   break;
                 default:
-                  worldInternal._routeError(err31, {
+                  worldInternal._routeError(err32, {
                     severity: Severity.Error,
-                    systemName: `RenderSystem.extract (_materialWalk: ${err31.code})`
+                    systemName: `RenderSystem.extract (_materialWalk: ${err32.code})`
                   });
               }
               continue;
@@ -12281,6 +14116,7 @@ function extractFrame(world, context) {
     lights,
     environment,
     environmentReady: true,
+    ...volumetricFog === void 0 ? {} : { volumetricFog },
     renderables,
     dispatch,
     skylight,
@@ -13693,7 +15529,8 @@ var RENDER_RELEVANT_COMPONENT_IDS = /* @__PURE__ */ new Set([
   componentId(SpotLight),
   componentId(Skylight),
   componentId(SkyboxBackground),
-  componentId(PostProcessParams)
+  componentId(PostProcessParams),
+  componentId(VolumetricFog)
 ]);
 var NON_RENDERABLE_TRANSFORM_CONSUMERS = [
   Camera,
@@ -14146,6 +15983,68 @@ var PersistentRenderScene = class {
     this.options.onGpuError?.(error);
   }
 };
+function copyInput(input) {
+  return {
+    ...input,
+    currentViewProjection: new Float32Array(input.currentViewProjection),
+    jitter: [input.jitter[0], input.jitter[1]],
+    viewport: { ...input.viewport },
+    ...input.cameraPosition === void 0 ? {} : { cameraPosition: [...input.cameraPosition] }
+  };
+}
+function copyFrame(frame) {
+  return {
+    ...frame,
+    currentViewProjection: new Float32Array(frame.currentViewProjection),
+    previousViewProjection: frame.previousViewProjection === void 0 ? void 0 : new Float32Array(frame.previousViewProjection),
+    jitter: [frame.jitter[0], frame.jitter[1]],
+    viewport: { ...frame.viewport },
+    currentCameraPosition: [...frame.currentCameraPosition],
+    previousCameraPosition: frame.previousCameraPosition === void 0 ? void 0 : [...frame.previousCameraPosition]
+  };
+}
+function createTemporalFrameTransaction(options) {
+  let accepted;
+  let staged;
+  let historyEpoch = 0;
+  return {
+    stage(input) {
+      staged = copyInput(input);
+    },
+    commit(submit) {
+      if (!submit.accepted) {
+        staged = void 0;
+        return err$1(new TemporalFrameSubmitError(submit.reason ?? "queue-submit-failed"));
+      }
+      if (staged === void 0) {
+        return err$1(new TemporalFrameSubmitError("queue-submit-failed"));
+      }
+      const resetReason = submit.resetReason ?? staged.resetReason ?? "none";
+      const shouldReset = resetReason !== "none";
+      if (shouldReset) historyEpoch += 1;
+      const next = {
+        frameId: staged.frameId,
+        currentViewProjection: new Float32Array(staged.currentViewProjection),
+        previousViewProjection: accepted === void 0 || shouldReset ? void 0 : new Float32Array(accepted.currentViewProjection),
+        jitter: [staged.jitter[0], staged.jitter[1]],
+        viewport: { ...staged.viewport },
+        currentCameraPosition: staged.cameraPosition ?? [0, 0, 0],
+        previousCameraPosition: accepted === void 0 || shouldReset ? void 0 : accepted.currentCameraPosition,
+        resetReason,
+        historyEpoch,
+        deviceEpoch: options.deviceEpoch
+      };
+      accepted = next;
+      staged = void 0;
+      return ok$1(copyFrame(next));
+    },
+    snapshot() {
+      if (accepted === void 0)
+        throw new Error("TemporalFrame snapshot is unavailable before commit");
+      return copyFrame(accepted);
+    }
+  };
+}
 
 // src/temporal/inspection.ts
 function gpuBytes(state) {
@@ -14795,10 +16694,26 @@ function createRenderSystem(internals) {
     graphGeneration: 0,
     successfulTemporalFrameIndex: 0,
     lastSuccessfulBloom: "off",
+    temporalFrameTransaction: createTemporalFrameTransaction({ deviceEpoch: 0 }),
+    temporalFrameInput: void 0,
     directionalShadowCache: null,
     directionalShadowCacheRecorded: false,
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: null,
+    volumetricFogPreviousGraph: null,
+    volumetricFogPreviousGraphKey: null,
+    volumetricFogCandidateGraph: null,
+    volumetricFogParamsBuffers: [null, null],
+    volumetricFogParamsPendingSlot: null,
+    volumetricFogParamsAcceptedSlot: null,
+    volumetricFogAcceptedParams: void 0,
+    volumetricFogPendingParams: void 0,
+    volumetricFogInspection: inspectVolumetricFog({ authored: false, capability: "available" }),
+    volumetricFogAccepted: void 0,
+    volumetricFogAcceptedContext: void 0,
+    volumetricFogHistoryGraph: null,
+    volumetricFogHistorySlot: null,
+    volumetricFogHistorySignature: null,
     retiredCompiledFrameGraphs: /* @__PURE__ */ new Set(),
     currentFrameObservationSource: void 0,
     lastSuccessfulCameraAntialias: void 0,
@@ -15287,18 +17202,18 @@ function createRenderSystem(internals) {
       const camera = latestCamera;
       if (camera?.motionBlur === void 0) return void 0;
       const demanded = camera.motionBlur.shutterAngle > 0;
-      const unavailable2 = demanded && !internals.device.caps.rgba16floatRenderable;
+      const unavailable3 = demanded && !internals.device.caps.rgba16floatRenderable;
       const admitted = frameState.activeTemporalGpuState !== void 0 || frameState.temporalGpuState !== void 0;
       return {
         enabled: demanded,
-        status: !demanded ? "off" : unavailable2 || !admitted ? "reset" : "active",
+        status: !demanded ? "off" : unavailable3 || !admitted ? "reset" : "active",
         shutterAngle: camera.motionBlur.shutterAngle,
         maxRadiusPixels: camera.motionBlur.maxRadiusPixels,
         sampleCount: camera.motionBlur.sampleCount,
         temporalDemand: demanded ? "scene-data-temporal-v1" : "none",
         passName: "motion-blur",
         historyWrites: 0,
-        ...unavailable2 ? { lastFailure: "scene-data-unavailable" } : {}
+        ...unavailable3 ? { lastFailure: "scene-data-unavailable" } : {}
       };
     },
     get temporalTargetInspection() {
@@ -15359,7 +17274,7 @@ function createRenderSystem(internals) {
     detachScene(world) {
       persistentRenderScene.detach(world);
     },
-    draw(worlds, opts, renderReadLeases) {
+    draw(worlds, opts, renderReadLeases, timingCapture) {
       preparedWorlds = worlds;
       const profileSession = internals.profiler?.activeSession();
       let ownsProfileFrame = false;
@@ -15402,6 +17317,7 @@ function createRenderSystem(internals) {
           lights,
           environment,
           environmentReady,
+          volumetricFog,
           renderables,
           dispatch,
           skylight,
@@ -15573,7 +17489,9 @@ function createRenderSystem(internals) {
             environment?.environmentSignature ?? "",
             environment?.fogSignature ?? "",
             environmentReady && environment !== void 0,
-            persistentRenderScene.transmissionTopologyDemand()
+            persistentRenderScene.transmissionTopologyDemand(),
+            volumetricFog,
+            timingCapture
           )
         );
         if (submitted) {
@@ -15614,16 +17532,16 @@ function createRenderSystem(internals) {
             if (!retired.ok) internals.errorRegistry.fire(retired.error);
           }
         }
-      } catch (err31) {
+      } catch (err32) {
         if (!submitted) {
           internals.getPipelineState()?.perPassResources.discardBloomResources?.();
         }
-        const innerError = err31 instanceof PipelineSpecError ? {
-          name: err31.name,
-          code: err31.code,
-          message: err31.message,
-          detail: err31.detail
-        } : err31 instanceof RhiError ? err31 : { code: "unknown", message: String(err31), name: err31?.name };
+        const innerError = err32 instanceof PipelineSpecError ? {
+          name: err32.name,
+          code: err32.code,
+          message: err32.message,
+          detail: err32.detail
+        } : err32 instanceof RhiError ? err32 : { code: "unknown", message: String(err32), name: err32?.name };
         internals.errorRegistry.fire(
           new RhiError({
             code: "webgpu-runtime-error",
@@ -15666,6 +17584,17 @@ function createRenderSystem(internals) {
       frameState.graphTargetCapture = request;
     },
     bindGroupCounts,
+    get temporalFrame() {
+      const accepted = frameState.temporalFrame;
+      if (accepted === void 0) return void 0;
+      return {
+        ...accepted,
+        currentViewProjection: new Float32Array(accepted.currentViewProjection),
+        previousViewProjection: accepted.previousViewProjection === void 0 ? void 0 : new Float32Array(accepted.previousViewProjection),
+        jitter: [accepted.jitter[0], accepted.jitter[1]],
+        viewport: { ...accepted.viewport }
+      };
+    },
     frustumStats: lastFrustumStats,
     visibilityStats: lastVisibilityStats,
     get meshMaterialBindings() {
@@ -15680,6 +17609,9 @@ function createRenderSystem(internals) {
     get perFrameGraphInfo() {
       return frameState.compiledFrameGraph?.inspect();
     },
+    get volumetricFog() {
+      return frameState.volumetricFogInspection;
+    },
     configureStandard(config) {
       const profileConfig = internals.standardProfile;
       const resolvedConfig = profileConfig === void 0 ? config : {
@@ -15790,6 +17722,22 @@ function createRenderSystem(internals) {
         retireTemporalGpuState(retiring);
       }
       frameState.retiringTemporalGpuStates.clear();
+      settleVolumetricFogGraphCandidate(frameState, false);
+      for (const buffer of frameState.volumetricFogParamsBuffers) {
+        if (buffer === null) continue;
+        const destroyed = internals.device.destroyBuffer(buffer);
+        if (!destroyed.ok) internals.errorRegistry.fire(destroyed.error);
+      }
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = void 0;
+      frameState.volumetricFogPendingParams = void 0;
+      frameState.volumetricFogAccepted = void 0;
+      frameState.volumetricFogAcceptedContext = void 0;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
       const compiled = frameState.compiledFrameGraph;
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
@@ -15825,9 +17773,23 @@ function createRenderSystem(internals) {
       gpuDrivenProduction = new GpuDrivenProduction(internals.device, gpuDrivenShaderFactory);
       disposeFeatureGpuWork();
       internals.getPipelineState()?.perPassResources.drainBloomResources?.();
+      settleVolumetricFogGraphCandidate(frameState, false);
       frameState.compiledFrameGraph?.retire().catch(() => void 0);
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
+      frameState.volumetricFogPreviousGraph = null;
+      frameState.volumetricFogPreviousGraphKey = null;
+      frameState.volumetricFogCandidateGraph = null;
+      frameState.volumetricFogAccepted = void 0;
+      frameState.volumetricFogAcceptedContext = void 0;
+      frameState.volumetricFogHistoryGraph = null;
+      frameState.volumetricFogHistorySlot = null;
+      frameState.volumetricFogHistorySignature = null;
+      frameState.volumetricFogParamsBuffers = [null, null];
+      frameState.volumetricFogParamsPendingSlot = null;
+      frameState.volumetricFogParamsAcceptedSlot = null;
+      frameState.volumetricFogAcceptedParams = void 0;
+      frameState.volumetricFogPendingParams = void 0;
       frameState.directionalShadowCache = null;
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = void 0;
@@ -16843,19 +18805,19 @@ function toGpuVertexBufferLayouts(entries) {
     }))
   }));
 }
-function selectHdrpPbrPrewarmVariants(manifestEntry, storageBufferCapable, transmissionCapable) {
+function selectHdrpPbrPrewarmVariants(manifestEntry, storageBufferCapable, transmissionCapable, projectorAvailable = true) {
   return manifestEntry?.variants.filter(
-    (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.CLUSTER_FORWARD_AVAILABLE === true && (transmissionCapable || variant.defines.TRANSMISSION_AVAILABLE !== true)
+    (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.CLUSTER_FORWARD_AVAILABLE === true && (!("PROJECTOR_AVAILABLE" in variant.defines) || variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) && (transmissionCapable || variant.defines.TRANSMISSION_AVAILABLE !== true)
   ) ?? [];
 }
-function selectStandardPbrTransmissionPrewarmVariants(manifestEntry, storageBufferCapable) {
+function selectStandardPbrTransmissionPrewarmVariants(manifestEntry, storageBufferCapable, projectorAvailable = true) {
   if (manifestEntry === void 0) {
     throw new Error("Standard material shader manifest row is missing");
   }
   const selected = [];
   for (const transmissionAvailable of [false, true]) {
     const declared = manifestEntry.variants.find(
-      (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.CLUSTER_FORWARD_AVAILABLE === false && variant.defines.VERTEX_COLOR_AVAILABLE === false && variant.defines.TRANSMISSION_AVAILABLE === transmissionAvailable
+      (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.CLUSTER_FORWARD_AVAILABLE === false && variant.defines.VERTEX_COLOR_AVAILABLE === false && (!("PROJECTOR_AVAILABLE" in variant.defines) || variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) && variant.defines.TRANSMISSION_AVAILABLE === transmissionAvailable
     );
     if (declared === void 0) {
       throw new Error(
@@ -16872,11 +18834,11 @@ function selectStandardPbrTransmissionPrewarmVariants(manifestEntry, storageBuff
   }
   return selected;
 }
-function selectNoColorPbrVariant(manifestEntry, storageBufferCapable, variantSet) {
+function selectNoColorPbrVariant(manifestEntry, storageBufferCapable, variantSet, projectorAvailable = true) {
   const hdrpRequested = variantSet === "" || // biome-ignore lint/complexity/useOptionalChain: G-14 requires an explicit undefined guard so no variant request becomes false.
   variantSet !== void 0 && variantSet.includes("CLUSTER_FORWARD_AVAILABLE=true");
   return manifestEntry?.variants.find(
-    (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.VERTEX_COLOR_AVAILABLE === false && (!("CLUSTER_FORWARD_AVAILABLE" in variant.defines) || variant.defines.CLUSTER_FORWARD_AVAILABLE === hdrpRequested)
+    (variant) => variant.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && variant.defines.VERTEX_COLOR_AVAILABLE === false && (!("PROJECTOR_AVAILABLE" in variant.defines) || variant.defines.PROJECTOR_AVAILABLE === projectorAvailable) && (!("CLUSTER_FORWARD_AVAILABLE" in variant.defines) || variant.defines.CLUSTER_FORWARD_AVAILABLE === hdrpRequested)
   );
 }
 function resolveMaterialShaderBindingContract(source) {
@@ -16910,6 +18872,30 @@ function resolveMaterialShaderVertexInputContract(source) {
   }
   return /@vertex\s*fn[^{]*\([^)]*@location\s*\(/u.test(withoutComments) ? "render-material" : "none";
 }
+function isSharedMaterialUserRegionCompatible(paramSchema) {
+  const shared = buildPbrMaterialUserRegionEntries(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+  const candidate = buildPbrMaterialUserRegionEntries(paramSchema);
+  if (candidate.length > shared.length) return false;
+  return candidate.every((entry, index) => {
+    const canonical = shared[index];
+    if (canonical === void 0) return false;
+    return JSON.stringify({
+      binding: entry.binding,
+      visibility: entry.visibility,
+      buffer: entry.buffer ?? null,
+      sampler: entry.sampler ?? null,
+      texture: entry.texture ?? null,
+      storageTexture: entry.storageTexture ?? null
+    }) === JSON.stringify({
+      binding: canonical.binding,
+      visibility: canonical.visibility,
+      buffer: canonical.buffer ?? null,
+      sampler: canonical.sampler ?? null,
+      texture: canonical.texture ?? null,
+      storageTexture: canonical.storageTexture ?? null
+    });
+  });
+}
 function allowsUnlitPreparedFallback(depthFormatOverride, vertexLayout, materialShaderId) {
   return depthFormatOverride === null && (vertexLayout === void 0 || !materialShaderId?.startsWith("forgeax::"));
 }
@@ -16937,9 +18923,9 @@ function selectPipelineLayoutForVariant(state, variantSet, layoutKind) {
   }
   return state.pbrPipelineLayout;
 }
-function resolveMaterialShaderVariantSet(requestedVariantSet, variants, backendKind, storageBuffer) {
+function resolveMaterialShaderVariantSet(requestedVariantSet, variants, backendKind, storageBuffer, projectorAvailable = true) {
   const declaredAxes = new Set(variants.flatMap((variant) => Object.keys(variant.defines)));
-  const declaresCapabilityVariants = declaredAxes.has("WEBGL2_COMPAT") || declaredAxes.has("STORAGE_BUFFER_AVAILABLE");
+  const declaresCapabilityVariants = declaredAxes.has("WEBGL2_COMPAT") || declaredAxes.has("STORAGE_BUFFER_AVAILABLE") || declaredAxes.has("PROJECTOR_AVAILABLE");
   if (!declaresCapabilityVariants) return requestedVariantSet;
   const requested = {};
   for (const part of requestedVariantSet?.split("+") ?? []) {
@@ -16948,7 +18934,7 @@ function resolveMaterialShaderVariantSet(requestedVariantSet, variants, backendK
   }
   const filtered = {};
   for (const axis of declaredAxes) {
-    filtered[axis] = axis === "WEBGL2_COMPAT" ? backendKind === "wgpu-webgl2" : axis === "STORAGE_BUFFER_AVAILABLE" ? backendKind !== "wgpu-webgl2" && storageBuffer : axis === "SKINNING_DISABLED" ? requested[axis] ?? true : axis === "CLUSTER_FORWARD_AVAILABLE" ? backendKind !== "wgpu-webgl2" && (requested[axis] ?? false) : axis === "PER_INSTANCE_REGION" ? requestedVariantSet === "" || (requested[axis] ?? false) : axis === "VERTEX_COLOR_AVAILABLE" ? requestedVariantSet === "" || (requested[axis] ?? false) : axis === "TRANSMISSION_AVAILABLE" ? requested[axis] ?? false : requested[axis] ?? true;
+    filtered[axis] = axis === "WEBGL2_COMPAT" ? backendKind === "wgpu-webgl2" : axis === "STORAGE_BUFFER_AVAILABLE" ? backendKind !== "wgpu-webgl2" && storageBuffer : axis === "SKINNING_DISABLED" ? requested[axis] ?? true : axis === "CLUSTER_FORWARD_AVAILABLE" ? backendKind !== "wgpu-webgl2" && (requested[axis] ?? false) : axis === "PER_INSTANCE_REGION" ? requestedVariantSet === "" || (requested[axis] ?? false) : axis === "VERTEX_COLOR_AVAILABLE" ? requestedVariantSet === "" || (requested[axis] ?? false) : axis === "TRANSMISSION_AVAILABLE" ? requested[axis] ?? false : axis === "PROJECTOR_AVAILABLE" ? projectorAvailable : requested[axis] ?? true;
   }
   const sorted2 = Object.entries(filtered).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
   return sorted2.every(([, value]) => value) ? requestedVariantSet === "" ? "" : void 0 : sorted2.map(([name, value]) => `${name}=${value}`).join("+");
@@ -17006,20 +18992,20 @@ function attachDeviceLostFanout(device, pack, registries) {
         );
       }
     }
-  }).catch((err31) => {
+  }).catch((err32) => {
     pack.instrumentation?.onDeviceLost?.();
-    onDeviceLost?.(`device.lost rejected: ${String(err31)}`);
-    lostRegistry.fire({ reason: "unknown", message: String(err31) });
+    onDeviceLost?.(`device.lost rejected: ${String(err32)}`);
+    lostRegistry.fire({ reason: "unknown", message: String(err32) });
     healthRegistry.fire({
       reason: "device-lost",
-      detail: { lostReason: "unknown", message: String(err31) },
+      detail: { lostReason: "unknown", message: String(err32) },
       recoverable: true
     });
     errorRegistry.fire(
       new RhiError({
         code: "device-lost",
         expected: "device.lost Promise resolves with GPUDeviceLostInfo",
-        hint: `device.lost Promise rejected unexpectedly: ${String(err31)}`
+        hint: `device.lost Promise rejected unexpectedly: ${String(err32)}`
       })
     );
   });
@@ -17030,9 +19016,12 @@ var COMPRESSION_FEATURES = [
   "texture-compression-astc"
 ];
 var STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES = 17;
-function deviceOptionsForAdapter(adapter) {
+function deviceOptionsForAdapter(adapter, options) {
   const requiredFeatures = COMPRESSION_FEATURES.filter((feature) => adapter.features.has(feature));
   const supportsTransmission = (adapter.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
+  if (options?.captureGpuTimings === true && adapter.features.has("timestamp-query")) {
+    requiredFeatures.push("timestamp-query");
+  }
   return {
     ...requiredFeatures.length > 0 ? { requiredFeatures } : {},
     ...supportsTransmission ? {
@@ -17050,7 +19039,7 @@ async function tryCreateWebGPURenderer(canvas, options, pack, bundler) {
     return { kind: "rhi-err", error: adapterResult.error };
   }
   const adapter = adapterResult.value;
-  const deviceOpts = deviceOptionsForAdapter(adapter);
+  const deviceOpts = deviceOptionsForAdapter(adapter, options);
   const result = await adapter.requestDevice(deviceOpts);
   if (!result.ok) {
     return { kind: "rhi-err", error: result.error };
@@ -17328,6 +19317,14 @@ async function makeWebGPURenderer(internals) {
     }
     if (pipelineState === null) return null;
     const paramSchema = lookup.value.paramSchema;
+    if (isSharedMaterialUserRegionCompatible(paramSchema)) {
+      perShaderMaterialLayoutCache.set(materialShaderId, {
+        source: lookup.value.source,
+        paramSchema,
+        layout: null
+      });
+      return null;
+    }
     const spec = {
       shader: { id: materialShaderId, passKind: "forward", variantSet: void 0 },
       attachments: { colorFormats: [], depthFormat: void 0, sampleCount: 1 },
@@ -17370,7 +19367,8 @@ async function makeWebGPURenderer(internals) {
         requestedVariantSet,
         [],
         internals.device.caps.backendKind,
-        internals.device.caps.storageBuffer
+        internals.device.caps.storageBuffer,
+        (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES
       );
     }
     const variants = manifestEntry.variants;
@@ -17379,13 +19377,15 @@ async function makeWebGPURenderer(internals) {
       byRequest = /* @__PURE__ */ new Map();
       materialShaderVariantResolutionCache.set(variants, byRequest);
     }
-    const cacheKey = `${requestedVariantSet ?? "\0"}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? "1" : "0"}`;
+    const projectorAvailable = (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
+    const cacheKey = `${requestedVariantSet ?? "\0"}|${internals.device.caps.backendKind}|${internals.device.caps.storageBuffer ? "1" : "0"}|${projectorAvailable ? "1" : "0"}`;
     if (byRequest.has(cacheKey)) return byRequest.get(cacheKey);
     const resolved2 = resolveMaterialShaderVariantSet(
       requestedVariantSet,
       variants,
       internals.device.caps.backendKind,
-      internals.device.caps.storageBuffer
+      internals.device.caps.storageBuffer,
+      projectorAvailable
     );
     byRequest.set(cacheKey, resolved2);
     return resolved2;
@@ -17468,6 +19468,9 @@ async function makeWebGPURenderer(internals) {
         });
       }
       temporalPostProcessesRegistered = true;
+    },
+    (sources) => {
+      internals.volumetricFogShaders = sources;
     }
   );
   const ready = buildPipeline().then(
@@ -17504,7 +19507,8 @@ async function makeWebGPURenderer(internals) {
     const noColorVariant = selectNoColorPbrVariant(
       pbrManifestEntry,
       internals.device.caps.storageBuffer,
-      variantSet
+      variantSet,
+      (internals.device.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES
     );
     if (noColorVariant !== void 0 && noColorVariant.composedWgsl !== standardEntry.wgsl) {
       return { ...standardEntry, wgsl: noColorVariant.composedWgsl };
@@ -17975,6 +19979,9 @@ async function makeWebGPURenderer(internals) {
     },
     get meshSsboState() {
       return internals.meshSsboState;
+    },
+    get volumetricFogShaders() {
+      return internals.volumetricFogShaders;
     }
   });
   if (internals.device.caps.backendKind === "null" && Array.from(getShader().entries()).length === 0) {
@@ -17993,7 +20000,8 @@ async function makeWebGPURenderer(internals) {
   const transformReleases = /* @__PURE__ */ new Map();
   const attachmentOwner = {};
   let frameId = 0;
-  let latestReceipt;
+  const issuedReceipts = /* @__PURE__ */ new WeakSet();
+  const receiptTimings = /* @__PURE__ */ new WeakMap();
   let surfaceReleased = false;
   const renderer = {
     attach(world) {
@@ -18046,6 +20054,7 @@ async function makeWebGPURenderer(internals) {
         rgba16floatRenderable: internals.device.caps.rgba16floatRenderable,
         ...internals.context?.presentationProof === void 0 ? {} : { presentationProof: internals.context.presentationProof }
       });
+      const volumetricFog = renderSystem.volumetricFog;
       return Object.freeze({
         state,
         surface: surfaceReleased ? "released" : "available",
@@ -18059,6 +20068,7 @@ async function makeWebGPURenderer(internals) {
           (internals.featureHost?.features ?? []).map((feature) => feature.identity)
         ),
         featureDiagnostics: internals.featureHost?.diagnostics() ?? Object.freeze([]),
+        volumetricFog,
         frustumStats: Object.freeze({ ...renderSystem.frustumStats }),
         visibilityStats: Object.freeze({ ...renderSystem.visibilityStats }),
         renderScene: renderSystem.renderScene,
@@ -18402,8 +20412,18 @@ async function makeWebGPURenderer(internals) {
       );
       if (!contextConfigured.ok) return contextConfigured;
       try {
-        const submitted = renderSystem.draw(worlds, drawOptions, renderReadLeases);
+        const timingRequested = isFrameRequest && (frameRequest?.profileFrame !== void 0 || internals.options?.captureGpuTimings === true);
+        let timingCapture;
+        let timingUnavailableReason = timingRequested ? "timestamp capture is unavailable on this device" : "timestamp capture was not requested for this frame";
+        if (timingRequested) {
+          const createdTiming = GpuTimingCapture.create(internals.device);
+          if (createdTiming.ok) timingCapture = createdTiming.value;
+          else
+            timingUnavailableReason = `timestamp capture setup failed: ${createdTiming.error.code}`;
+        }
+        const submitted = renderSystem.draw(worlds, drawOptions, renderReadLeases, timingCapture);
         if (!submitted) {
+          timingCapture?.discard();
           return err(
             new RendererContractFailureError(
               "draw",
@@ -18430,7 +20450,14 @@ async function makeWebGPURenderer(internals) {
             deviceGeneration: receiptGeneration,
             completed
           });
-          latestReceipt = receipt;
+          receiptTimings.set(
+            receipt,
+            timingCapture?.observation() ?? Promise.resolve({
+              status: "unavailable",
+              reason: timingUnavailableReason
+            })
+          );
+          issuedReceipts.add(receipt);
           return ok(receipt);
         }
         return ok(void 0);
@@ -18447,7 +20474,7 @@ async function makeWebGPURenderer(internals) {
       }
     },
     async observe(receipt, request) {
-      if (latestReceipt === void 0 || latestReceipt !== receipt || latestReceipt.frameId !== receipt.frameId || latestReceipt.deviceGeneration !== receipt.deviceGeneration) {
+      if (!issuedReceipts.has(receipt) || receipt.deviceGeneration !== activeDeviceScope.generation) {
         const currentGeneration2 = activeDeviceScope.generation;
         return err(
           new FrameReceiptStaleError({
@@ -18469,11 +20496,16 @@ async function makeWebGPURenderer(internals) {
           })
         );
       }
+      const timings = request.include.includes("timings") ? await (receiptTimings.get(receipt) ?? Promise.resolve({
+        status: "unavailable",
+        reason: "timing receipt was not retained"
+      })) : void 0;
       return ok(
         Object.freeze({
           frameId: receipt.frameId,
           deviceGeneration: receipt.deviceGeneration,
-          include: Object.freeze([...request.include])
+          include: Object.freeze([...request.include]),
+          ...timings === void 0 ? {} : { timings }
         })
       );
     },
@@ -18684,7 +20716,7 @@ async function makeWebGPURenderer(internals) {
         let device;
         try {
           const deviceResult = await adapterResult.value.requestDevice(
-            deviceOptionsForAdapter(adapterResult.value)
+            deviceOptionsForAdapter(adapterResult.value, internals.options)
           );
           if (!deviceResult.ok) {
             return err(new RecoverError("recover-device-unavailable"));
@@ -18979,6 +21011,11 @@ var RENDER_PROFILE_KEYS = /* @__PURE__ */ new Set([
   "pbr",
   "ibl",
   "ssao",
+  "bloom",
+  "tone",
+  "antialias",
+  "sky",
+  "volumetricFog",
   "fallback",
   "postStages"
 ]);
@@ -19004,6 +21041,24 @@ function validateRenderProfile(profile) {
   for (const field of ["pbr", "ibl", "ssao"]) {
     if (typeof profile[field] !== "boolean") return `RenderProfile.${field} must be boolean`;
   }
+  if (profile.volumetricFog !== void 0) {
+    if (profile.volumetricFog.quality !== "low" && profile.volumetricFog.quality !== "high")
+      return "RenderProfile.volumetricFog.quality must be 'low' or 'high'";
+    if (profile.volumetricFog.depth !== 48 && profile.volumetricFog.depth !== 64) {
+      return "RenderProfile.volumetricFog.depth must be 48 or 64";
+    }
+    if (profile.volumetricFog.tileSize !== 4 && profile.volumetricFog.tileSize !== 16) {
+      return "RenderProfile.volumetricFog.tileSize must be 4 or 16";
+    }
+    if (profile.volumetricFog.quality === "low" && profile.volumetricFog.depth !== 48)
+      return "RenderProfile.volumetricFog.low must use depth 48";
+    if (profile.volumetricFog.quality === "high" && profile.volumetricFog.depth !== 64)
+      return "RenderProfile.volumetricFog.high must use depth 64";
+    if (profile.volumetricFog.quality === "low" && profile.volumetricFog.tileSize !== 16)
+      return "RenderProfile.volumetricFog.low must use tileSize 16";
+    if (profile.volumetricFog.quality === "high" && profile.volumetricFog.tileSize !== 4)
+      return "RenderProfile.volumetricFog.high must use tileSize 4";
+  }
   const stages = STANDARD_POST_STAGE_NAMES;
   if (!Array.isArray(profile.postStages) || profile.postStages.length !== stages.length || stages.some((stage, index) => profile.postStages[index] !== stage)) {
     return "RenderProfile.postStages must preserve the Standard post stage order";
@@ -19249,6 +21304,7 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
     if (!capCheck.ok) throw capCheck.error;
     storageBufferCapable = !webgl2Downlevel && capCheck.value;
   }
+  const projectorAvailable = (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
   const registry = getShader();
   const loaded = await registry.loadManifest();
   if (!loaded.ok) {
@@ -19269,6 +21325,9 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
     if (msEntry.variants.some((v) => "VERTEX_COLOR_AVAILABLE" in v.defines)) {
       variantDefines.VERTEX_COLOR_AVAILABLE = false;
     }
+    if (msEntry.identifier === "forgeax::default-standard-pbr" && msEntry.variants.some((v) => "PROJECTOR_AVAILABLE" in v.defines)) {
+      variantDefines.PROJECTOR_AVAILABLE = projectorAvailable;
+    }
     if (msEntry.identifier === "forgeax::default-standard-pbr" && msEntry.variants.some((v) => "TRANSMISSION_AVAILABLE" in v.defines)) {
       variantDefines.TRANSMISSION_AVAILABLE = false;
     }
@@ -19340,7 +21399,7 @@ async function prepareMaterialShaders(rhiDevice, getShader, assets, materialShad
     }
   }
 }
-async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinTemporalPostProcesses) {
+async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinTemporalPostProcesses, setVolumetricFogShaderSources) {
   const capValue = rhiDevice.limits.maxStorageBuffersPerShaderStage;
   const webgl2Downlevel = rhiDevice.caps.backendKind === "wgpu-webgl2";
   let storageBufferCapable = !webgl2Downlevel;
@@ -19348,6 +21407,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     const capCheck = assertStorageBufferCap(capValue);
     storageBufferCapable = capCheck.ok ? !webgl2Downlevel && capCheck.value : !webgl2Downlevel;
   }
+  const projectorAvailable = (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
   const surfaceViewFormats = rhiDevice.surfaceViewFormats ?? !webgl2Downlevel;
   const swapChainFormats = selectSwapChainFormat(storageBufferCapable, surfaceViewFormats);
   if (swapChainFormats.fallbackReason !== void 0 && rhiDevice.caps.backendKind !== "null") {
@@ -19489,7 +21549,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       const idToVariantWgsl = /* @__PURE__ */ new Map();
       for (const ms of registry.materialShaderManifestEntries()) {
         const exact = ms.variants.find(
-          (v2) => v2.defines.STORAGE_BUFFER_AVAILABLE === false && (!("CLUSTER_FORWARD_AVAILABLE" in v2.defines) || v2.defines.CLUSTER_FORWARD_AVAILABLE === false) && (!("VERTEX_COLOR_AVAILABLE" in v2.defines) || v2.defines.VERTEX_COLOR_AVAILABLE === false) && (!("SKINNING_DISABLED" in v2.defines) || v2.defines.SKINNING_DISABLED === true)
+          (v2) => v2.defines.STORAGE_BUFFER_AVAILABLE === false && (!("CLUSTER_FORWARD_AVAILABLE" in v2.defines) || v2.defines.CLUSTER_FORWARD_AVAILABLE === false) && (!("VERTEX_COLOR_AVAILABLE" in v2.defines) || v2.defines.VERTEX_COLOR_AVAILABLE === false) && (!("PROJECTOR_AVAILABLE" in v2.defines) || v2.defines.PROJECTOR_AVAILABLE === projectorAvailable) && (!("SKINNING_DISABLED" in v2.defines) || v2.defines.SKINNING_DISABLED === true)
         );
         const v = exact === void 0 ? void 0 : findVariantByKey(ms, exact.definesKey);
         if (v !== void 0) {
@@ -19515,7 +21575,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     const idToRuntimeVariantWgsl = /* @__PURE__ */ new Map();
     for (const ms of registry.materialShaderManifestEntries()) {
       const exact = ms.variants.find(
-        (variant2) => variant2.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && (!("CLUSTER_FORWARD_AVAILABLE" in variant2.defines) || variant2.defines.CLUSTER_FORWARD_AVAILABLE === false) && (!("VERTEX_COLOR_AVAILABLE" in variant2.defines) || variant2.defines.VERTEX_COLOR_AVAILABLE === false) && (!("SKINNING_DISABLED" in variant2.defines) || variant2.defines.SKINNING_DISABLED === true) && (!("TRANSMISSION_AVAILABLE" in variant2.defines) || variant2.defines.TRANSMISSION_AVAILABLE === false)
+        (variant2) => variant2.defines.STORAGE_BUFFER_AVAILABLE === storageBufferCapable && (!("CLUSTER_FORWARD_AVAILABLE" in variant2.defines) || variant2.defines.CLUSTER_FORWARD_AVAILABLE === false) && (!("VERTEX_COLOR_AVAILABLE" in variant2.defines) || variant2.defines.VERTEX_COLOR_AVAILABLE === false) && (!("PROJECTOR_AVAILABLE" in variant2.defines) || variant2.defines.PROJECTOR_AVAILABLE === projectorAvailable) && (!("SKINNING_DISABLED" in variant2.defines) || variant2.defines.SKINNING_DISABLED === true) && (!("TRANSMISSION_AVAILABLE" in variant2.defines) || variant2.defines.TRANSMISSION_AVAILABLE === false)
       );
       const variant = exact === void 0 ? void 0 : findVariantByKey(ms, exact.definesKey);
       if (variant !== void 0) {
@@ -19595,6 +21655,52 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       if (!shaderResult.ok) throw shaderResult.error;
       seedShaderModule(label, shaderResult.value);
     }
+    if (rhiDevice.caps.compute && rhiDevice.caps.storageTexture) {
+      const volumeSources = [
+        ["inject", "volume_inject", (source) => source.includes("fn volume_inject(")],
+        ["temporal", "volume_temporal", (source) => source.includes("fn volume_temporal(")],
+        [
+          "integrate",
+          "volume_integrate",
+          (source) => source.includes("fn volume_integrate(")
+        ],
+        ["composite", "volume_composite", (source) => source.includes("fn volume_fs(")]
+      ];
+      const resolved2 = volumeSources.map(([stage, label, matches]) => {
+        const entry = manifestEntries.find((candidate) => matches(candidate.wgsl));
+        return { stage, label, entry };
+      });
+      const present = resolved2.filter((candidate) => candidate.entry !== void 0).length;
+      if (present === 0) ; else {
+        const missing2 = resolved2.find((candidate) => candidate.entry === void 0);
+        if (missing2 !== void 0) {
+          throw new RhiError({
+            code: "shader-compile-failed",
+            expected: "shader manifest contains all four volumetric fog utility entries",
+            hint: `add the package-owned WGSL entry for '${missing2.label}' to the engine shader manifest`
+          });
+        }
+        const compiled = [];
+        for (const { stage, label, entry } of resolved2) {
+          if (entry === void 0) throw new Error(`missing volumetric shader ${label}`);
+          const shaderResult = await runShimStep(
+            () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, { code: entry.wgsl, label }) : invokeDeviceCreateShaderModule(rhiDevice, { code: entry.wgsl, label }),
+            "shader-compile-failed",
+            `volumetric fog shader module '${label}' compiled`,
+            `inspect manifest WGSL for '${label}' and check device.features`
+          );
+          if (!shaderResult.ok) throw shaderResult.error;
+          compiled.push({ stage, label, source: entry.wgsl, module: shaderResult.value });
+        }
+        for (const { label, module } of compiled) seedShaderModule(label, module);
+        setVolumetricFogShaderSources({
+          inject: compiled.find((candidate) => candidate.stage === "inject")?.source,
+          temporal: compiled.find((candidate) => candidate.stage === "temporal")?.source,
+          integrate: compiled.find((candidate) => candidate.stage === "integrate")?.source,
+          composite: compiled.find((candidate) => candidate.stage === "composite")?.source
+        });
+      }
+    }
     const pbrShaderResult = await runShimStep(
       () => asyncCreateShaderModule ? asyncCreateShaderModule(rhiDevice, { code: pbrEntry.wgsl, label: "pbr" }) : invokeDeviceCreateShaderModule(rhiDevice, { code: pbrEntry.wgsl, label: "pbr" }),
       "shader-compile-failed",
@@ -19614,7 +21720,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       seedShaderModule(`module-forgeax::default-standard-pbr#${pbrVariant.definesKey}`, pbrModule);
     }
     const transmissionCapable = (rhiDevice.limits.maxSampledTexturesPerShaderStage ?? 0) >= STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES;
-    const transmissionVariants = transmissionCapable ? selectStandardPbrTransmissionPrewarmVariants(pbrManifestEntry, storageBufferCapable) : [];
+    const transmissionVariants = transmissionCapable ? selectStandardPbrTransmissionPrewarmVariants(
+      pbrManifestEntry,
+      storageBufferCapable,
+      projectorAvailable
+    ) : [];
     const prewarmedHdrpModules = /* @__PURE__ */ new Map([[pbrEntry.wgsl, pbrModule]]);
     for (const transmissionVariant of transmissionVariants) {
       const moduleLabel = `module-forgeax::default-standard-pbr#${transmissionVariant.definesKey}`;
@@ -19641,7 +21751,8 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     for (const hdrpVariant of selectHdrpPbrPrewarmVariants(
       pbrManifestEntry,
       storageBufferCapable,
-      transmissionCapable
+      transmissionCapable,
+      projectorAvailable
     )) {
       const moduleLabel = `module-forgeax::default-standard-pbr#${hdrpVariant.definesKey}`;
       let hdrpModule = prewarmedHdrpModules.get(hdrpVariant.composedWgsl);
@@ -19951,7 +22062,12 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     }
   }
   const pbrLayouts = runShimSyncStep(
-    () => ok(buildPbrPipelineLayouts(rhiDevice, { storageBuffer: storageBufferCapable })),
+    () => ok(
+      buildPbrPipelineLayouts(rhiDevice, {
+        storageBuffer: storageBufferCapable,
+        projectorAvailable
+      })
+    ),
     "webgpu-runtime-error",
     "buildPbrPipelineLayouts succeeded",
     "check device.limits.maxBindingsPerBindGroup (need >=14) and maxBindGroupsPerPipelineLayout"
@@ -20631,11 +22747,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       }
       try {
         getOrBuildPipeline(spec, pipelineDeviceProvider, pipelineCache, modules);
-      } catch (err31) {
-        if (err31 instanceof PipelineSpecError) throw err31;
+      } catch (err32) {
+        if (err32 instanceof PipelineSpecError) throw err32;
         throw new PipelineSpecError({
           code: "pipeline-build-failed",
-          detail: { cause: err31 },
+          detail: { cause: err32 },
           hint: `Boot-time SPEC_CONST pre-warm failed for shader '${spec.shader.id}'; inspect gpuMessage on the cause`
         });
       }
@@ -20799,11 +22915,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
             pipelineCache,
             modules
           );
-        } catch (err31) {
-          if (err31 instanceof PipelineSpecError) throw err31;
+        } catch (err32) {
+          if (err32 instanceof PipelineSpecError) throw err32;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err31 },
+            detail: { cause: err32 },
             hint: "createRenderPipeline (fxaa fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -21057,11 +23173,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomBrightPipelineHandle,
                 () => void 0
               );
-            } catch (err31) {
-              if (err31 instanceof PipelineSpecError) throw err31;
+            } catch (err32) {
+              if (err32 instanceof PipelineSpecError) throw err32;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err31 },
+                detail: { cause: err32 },
                 hint: "createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -21158,11 +23274,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomBlurHPipelineHandle,
                 () => void 0
               );
-            } catch (err31) {
-              if (err31 instanceof PipelineSpecError) throw err31;
+            } catch (err32) {
+              if (err32 instanceof PipelineSpecError) throw err32;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err31 },
+                detail: { cause: err32 },
                 hint: "createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -21279,11 +23395,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomCompositePipelineHandle,
                 () => void 0
               );
-            } catch (err31) {
-              if (err31 instanceof PipelineSpecError) throw err31;
+            } catch (err32) {
+              if (err32 instanceof PipelineSpecError) throw err32;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err31 },
+                detail: { cause: err32 },
                 hint: "createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -21573,11 +23689,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_calc" }
             );
-          } catch (err31) {
-            if (err31 instanceof PipelineSpecError) throw err31;
+          } catch (err32) {
+            if (err32 instanceof PipelineSpecError) throw err32;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err31 },
+              detail: { cause: err32 },
               hint: "createRenderPipeline (ssao-calc fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -21608,11 +23724,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_blur" }
             );
-          } catch (err31) {
-            if (err31 instanceof PipelineSpecError) throw err31;
+          } catch (err32) {
+            if (err32 instanceof PipelineSpecError) throw err32;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err31 },
+              detail: { cause: err32 },
               hint: "createRenderPipeline (ssao-blur fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -21704,6 +23820,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     colorAttachmentFormat: swapChainFormats.view,
     surfaceProfile: surfaceViewFormats ? "dual-view" : "raw-only",
     viewBindGroupLayout: viewBglResult.value,
+    projectorAvailable,
     materialBindGroupLayout: materialBglResult.value,
     meshBindGroupLayout: meshArrayBglResult.value,
     viewUniformBuffer: viewUboResult.value,