@forgeax/engine-render 0.1.31 → 0.1.32

package/dist/construct-renderer.mjs

@@ -1,14 +1,14 @@
-import { inspectVolumetricFog, resolveSsrAdmissionGeneration, inspectLodOcclusion, zeroSsrAdmissionWork, projectSsrSpatialInspection, createDynamicGeometryLifecycle, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, projectSsrDependencies, admitSsrSpatial, inspectPointShadow, DynamicGeometryError, sameCandidateCredential } from './chunk-7MQ3XBSP.mjs';
-import { createExtendedLightingState, promoteExtendedLightingCandidate, glyphTextLayoutSystem, projectExtendedLightingInspection, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, InstanceBoundsCache, fingerprintNumericArray, buildShadowFrusta, createSsrHistoryOwner, createSsrSpatialResources, createCookieProjectionMatrixData } from './chunk-C3DDSXYK.mjs';
+import { inspectVolumetricFog, resolveSsrAdmissionGeneration, inspectLodOcclusion, zeroSsrAdmissionWork, projectSsrSpatialInspection, createDynamicGeometryLifecycle, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, admitPointsLines, projectSsrDependencies, admitSsrSpatial, inspectPointShadow, DynamicGeometryError, sameCandidateCredential } from './chunk-LULCA3OF.mjs';
+import { createExtendedLightingState, promoteExtendedLightingCandidate, glyphTextLayoutSystem, projectExtendedLightingInspection, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, SKYLIGHT_RECOVERY_FALLBACK, InstanceBoundsCache, fingerprintNumericArray, buildShadowFrusta, createSsrHistoryOwner, createSsrSpatialResources, createCookieProjectionMatrixData } from './chunk-4NNZQCL3.mjs';
 import './chunk-ILQ5MEZF.mjs';
-import { MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, projectMeshMaterialBindingObservation, buildCubeCameraFaceViews, hasVolumetricFogCapability, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, CUBE_CAMERA_FACE_ORDER } from './chunk-S5UE2T5P.mjs';
+import { DEFAULT_DEPTH_OF_FIELD_PARAMS, MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, projectMeshMaterialBindingObservation, resolveDepthOfFieldFrameParams, buildCubeCameraFaceViews, hasVolumetricFogCapability, packDepthOfFieldParams, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, CUBE_CAMERA_FACE_ORDER } from './chunk-GWCEMDVR.mjs';
 import { SpriteInstances, SpriteRegionOverride, TileLayer, decodeSortScope, Tilemap } from './chunk-PA5DRJNI.mjs';
-import { GPU_SCENE_LAYOUTS, deviceOptionsForAdapter, PipelineSpecError, assertStorageBufferCap, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, createClusterBinScratch, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, resolveMaterialSkylight, postProcessShaderEntrySignature, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, selectStandardPbrTransmissionPrewarmVariants, selectHdrpPbrPrewarmVariants, prewarmMaterialShaderVariants, selectProbePrewarmVariants, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, configureSurface, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE, getOrCreateIblCache, decideVisibility, BatchTopology, postProcessShaderPipelineLabel, createPointsLinesLaneAdapter, computeViewMatrix, computeProjectionMatrix, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, warnZeroLightStandard, writeShadowParamsBuffer, deriveRenderExtent, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, GPU_DRIVEN_VIEW_WGSL, selectGpuDrivenSceneIndexVariant, selectSkinPrewarmVariants, transmissionBackdropAvailable, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, getIblProbeBackgroundSource, OcclusionConfidenceScheduler, shouldIssueRetest, selectGpuLodLane, ShadowViewStatePool, GpuDrivenView, MATERIAL_PER_ENTITY_STRIDE, shadowViewIdentityKey, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, resolveReflectionProbeBinding, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, detectNineSliceScaleTooSmall, PREFILTER_SIZE, gpuSceneFieldOffset, projectedHeightForCandidate, geometryRenderStateForTopology, packInstanceStorageBuffer, MESH_SSBO_BYTES, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, TEMPORAL_HISTORY_FORMATS, resolveSurfaceFormatPair, resolveSurfaceProfile, createRenderPipelineTarget, encodeMainPass, STANDARD_PBR_UBO_SIZE, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, renderExtentSize, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, addTypedSkyboxPass, createStandardSceneDataTarget, addStandardSceneDataPass, VIEW_UNIFORM_BYTES, addTypedFrameObservationPass, addReflectionFallbackObservationPass, selectLod, temporalReadIndex, temporalWriteIndex, prepareMaterialSkylight, BYTES_PER_DIRECT_LIGHT_SLOT, shadowViewRasterAccesses, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateFromChain, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, standardTopologyVariantSet, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, variantSetFromVertexLayoutProjection, createStandardSurfaceLightingBindGroup, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSchemaDefaultsToUbo, defaultViewForUserRegionField, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-PSEQ6QPH.mjs';
+import { GPU_SCENE_LAYOUTS, deviceOptionsForAdapter, PipelineSpecError, assertStorageBufferCap, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, createClusterBinScratch, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, resolveMaterialSkylight, postProcessShaderEntrySignature, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, selectStandardPbrTransmissionPrewarmVariants, selectHdrpPbrPrewarmVariants, prewarmMaterialShaderVariants, selectProbePrewarmVariants, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, configureSurface, CAPTURE_VIEW_PROJS, PREFILTER_MIP_LEVELS, REFLECTION_PROBE_VIEW_SLOT_BASE, VIEW_UNIFORM_SLOT_STRIDE, getOrCreateIblCache, decideVisibility, BatchTopology, postProcessShaderPipelineLabel, createPointsLinesLaneAdapter, computeViewMatrix, computeProjectionMatrix, prepareFrameLighting, warnMultiSkylight, warnMultiSkybox, selectLazyEquirectHandle, driveLazyEquirectProjection, warnZeroLightStandard, writeShadowParamsBuffer, deriveRenderExtent, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, GPU_DRIVEN_VIEW_WGSL, selectGpuDrivenSceneIndexVariant, selectSkinPrewarmVariants, transmissionBackdropAvailable, VIEW_UNIFORM_BUFFER_SIZE, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, getIblProbeBackgroundSource, OcclusionConfidenceScheduler, shouldIssueRetest, selectGpuLodLane, ShadowViewStatePool, GpuDrivenView, MATERIAL_PER_ENTITY_STRIDE, shadowViewIdentityKey, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, resolveReflectionProbeBinding, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, detectNineSliceScaleTooSmall, PREFILTER_SIZE, gpuSceneFieldOffset, projectedHeightForCandidate, geometryRenderStateForTopology, packInstanceStorageBuffer, MESH_SSBO_BYTES, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, TEMPORAL_HISTORY_FORMATS, resolveSurfaceFormatPair, resolveSurfaceProfile, createRenderPipelineTarget, encodeMainPass, STANDARD_PBR_UBO_SIZE, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, renderExtentSize, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, addTypedSkyboxPass, createStandardSceneDataTarget, addStandardSceneDataPass, VIEW_UNIFORM_BYTES, addTypedFrameObservationPass, addReflectionFallbackObservationPass, selectLod, temporalReadIndex, temporalWriteIndex, prepareMaterialSkylight, BYTES_PER_DIRECT_LIGHT_SLOT, shadowViewRasterAccesses, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateFromChain, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedFullscreenPass, addTypedCompositePostEffects, standardTopologyVariantSet, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, variantSetFromVertexLayoutProjection, createStandardSurfaceLightingBindGroup, isTemporalFullscreenBinding, createFullscreenBindGroup, applyParamSchemaDefaultsToUbo, defaultViewForUserRegionField, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-JRIPCMYC.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 { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, createSceneDataCatalog, resolveVolumetricFogProfile, isSceneDataTarget } from './chunk-NO4WZCAH.mjs';
+import { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, createSceneDataCatalog, resolveVolumetricFogProfile, isSceneDataTarget } from './chunk-S665NJNF.mjs';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-BLXGONR2.mjs';
-import { DeviceScope, SKIN_MATERIAL_SHADER_ID, EXTENDED_LIGHTING_TOPOLOGY, getTextureIdentity, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, deriveExtendedLightingCapability, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_INDEX, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, GPU_BUFFER_USAGE_UNIFORM, worldEntityKey, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, gpuDrivenShadowDrawKey, makeZeroCameraFallbackSnapshot, buildPbrPipelineLayouts, buildPbrSkinLayouts, buildGpuDrivenPbrInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, createTemporalCoverage, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, gpuDrivenMaterialArtifactKey, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, GPU_SHADER_STAGE_COMPUTE, LifecycleTransaction } from './chunk-FUUO4UND.mjs';
-import { RendererContractFailureError, RendererOperationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, RENDER_PHASE_CATALOG, InstanceCollectionStore, createAutoExposureInspection, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, createVisibilityBudget, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, SHADOW_ATLAS_DEFAULT_LAYERS, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GpuDrivenPreparationError, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, AutoExposureInvalidParameterError, PointsLinesPrepareFailedError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, SkinPaletteOverflowError, GPU_TEXTURE_USAGE_STORAGE_BINDING, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, RenderFeaturePreparedStateMismatchError, FXAA_POST_PROCESS_ID } from './chunk-JRBDO2KB.mjs';
+import { DeviceScope, SKIN_MATERIAL_SHADER_ID, EXTENDED_LIGHTING_TOPOLOGY, getTextureIdentity, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ, resolveRenderTargetMaterialSource, createRenderTargetMaterialSource, deriveExtendedLightingCapability, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_INDEX, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, GPU_BUFFER_USAGE_UNIFORM, worldEntityKey, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, gpuDrivenShadowDrawKey, makeZeroCameraFallbackSnapshot, buildPbrPipelineLayouts, buildPbrSkinLayouts, buildGpuDrivenPbrInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, createTemporalCoverage, isCanonicalStandardPbrMaterialShader, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, gpuDrivenMaterialArtifactKey, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, GPU_SHADER_STAGE_COMPUTE, LifecycleTransaction } from './chunk-DRR7D3KX.mjs';
+import { RendererContractFailureError, RendererOperationError, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, FrameReceiptStaleError, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, RenderTargetStateInvalidError, RenderTargetOperationFailedError, RenderTargetCapabilityMissingError, RenderTargetDescriptorInvalidError, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, RENDER_PHASE_CATALOG, InstanceCollectionStore, createAutoExposureInspection, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, createVisibilityBudget, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, SHADOW_ATLAS_DEFAULT_LAYERS, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GpuDrivenPreparationError, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, AutoExposureInvalidParameterError, PointsLinesPrepareFailedError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, SkinPaletteOverflowError, GPU_TEXTURE_USAGE_STORAGE_BINDING, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, RenderFeaturePreparedStateMismatchError, FXAA_POST_PROCESS_ID } from './chunk-6TFBXLRJ.mjs';
 import { ok, err, RhiError, validateDrawArgs } from '@forgeax/engine-rhi';
 import { AssetRegistry, DynamicTextureStore, adaptDynamicTextureDevice, getOrCreateMipmapPipeline, prepareMipmaps, blitMipmapsSync, HANDLE_CUBE, HANDLE_TRIANGLE, HANDLE_QUAD, HANDLE_SPHERE, HANDLE_NINESLICE_QUAD, BuiltinAssetRegistry, resolveAssetHandle, numMipLevels, encodeMipmapLevel, resolveTilesetRuntime, MeshSsboCeilingReachedError, MeshSsboCapacityExceededError } from '@forgeax/engine-assets-runtime';
 import { audioLoader } from '@forgeax/engine-audio-webaudio';
@@ -294,10 +294,10 @@ function exposeRenderer(renderer) {
     cancelDynamicGeometry: (candidate) => renderer.cancelDynamicGeometry(candidate),
     retireDynamicGeometry: (candidate) => renderer.retireDynamicGeometry(candidate),
     createRenderTarget: (descriptor) => renderer.createRenderTarget(descriptor),
-    resizeRenderTarget: (target4, descriptor) => renderer.resizeRenderTarget(target4, descriptor),
-    createRenderTargetTextureSource: (target4, options) => renderer.createRenderTargetTextureSource(target4, options),
-    requestTargetReadback: (target4, request) => renderer.requestTargetReadback(target4, request),
-    destroyRenderTarget: (target4) => renderer.destroyRenderTarget(target4),
+    resizeRenderTarget: (target5, descriptor) => renderer.resizeRenderTarget(target5, descriptor),
+    createRenderTargetTextureSource: (target5, options) => renderer.createRenderTargetTextureSource(target5, options),
+    requestTargetReadback: (target5, request) => renderer.requestTargetReadback(target5, request),
+    destroyRenderTarget: (target5) => renderer.destroyRenderTarget(target5),
     setProfile: (profile) => {
       const state = lifecycle.state();
       if (!isRendererStateOperational(state)) {
@@ -2131,6 +2131,277 @@ var EngineMetricsImpl = class {
 function createEngineMetrics() {
   return new EngineMetricsImpl();
 }
+var DEPTH_OF_FIELD_COC_ID = "forgeax.dof.coc";
+var DEPTH_OF_FIELD_PREFILTER_ID = "forgeax.dof.prefilter";
+var DEPTH_OF_FIELD_PREFILTER_METADATA_ID = "forgeax.dof.prefilter.metadata";
+var DEPTH_OF_FIELD_GATHER_ID = "forgeax.dof.gather";
+var DEPTH_OF_FIELD_BACKGROUND_ID = "forgeax.dof.background";
+var DEPTH_OF_FIELD_COMPOSITE_ID = "forgeax.dof.composite";
+var DEPTH_OF_FIELD_POST_PROCESS_IDS = Object.freeze([
+  DEPTH_OF_FIELD_COC_ID,
+  DEPTH_OF_FIELD_PREFILTER_ID,
+  DEPTH_OF_FIELD_PREFILTER_METADATA_ID,
+  DEPTH_OF_FIELD_GATHER_ID,
+  DEPTH_OF_FIELD_BACKGROUND_ID,
+  DEPTH_OF_FIELD_COMPOSITE_ID
+]);
+var DEPTH_OF_FIELD_MSAA_POST_PROCESS_IDS = Object.freeze(
+  DEPTH_OF_FIELD_POST_PROCESS_IDS.map((id) => `${id}.msaa`)
+);
+function depthOfFieldPostProcessId(id, multisampled) {
+  return multisampled ? `${id}.msaa` : id;
+}
+function depthOfFieldTopology(params) {
+  if (params === void 0 || params.maxRadiusPixels <= 0) return void 0;
+  return {
+    blurSide: params.blurSide,
+    useNear: params.blurSide === "near" || params.blurSide === "both",
+    useFar: params.blurSide === "far" || params.blurSide === "both"
+  };
+}
+function target(graph, label, descriptor) {
+  return createRenderPipelineTarget(graph, label, descriptor);
+}
+function addPass(graph, options) {
+  return addTypedFullscreenPass(graph, options);
+}
+function addDepthOfFieldPasses(context, input, depth, temporal) {
+  const params = context.camera.depthOfField;
+  const topology = depthOfFieldTopology(params);
+  if (params === void 0 || topology === void 0) return ok$1(input);
+  const multisampled = depth.sampleCount === 4;
+  const graph = context.graph;
+  const extentSize = context.extent === void 0 ? void 0 : renderExtentSize(context.extent, context.temporalTaa ? "output" : "internal");
+  const fullSize = extentSize ?? "surface";
+  const halfSize = extentSize === void 0 ? "half-surface" : {
+    width: Math.max(1, Math.ceil(extentSize.width / 2)),
+    height: Math.max(1, Math.ceil(extentSize.height / 2))
+  };
+  const coc = target(graph, "dof-coc", {
+    format: "rgba16float",
+    size: fullSize,
+    domain: "linear-hdr"
+  });
+  if (!coc.ok) return coc;
+  const cocPass = addPass(graph, {
+    name: "dof-coc",
+    shader: depthOfFieldPostProcessId(DEPTH_OF_FIELD_COC_ID, multisampled),
+    fragmentEntryPoint: "fs_coc",
+    input,
+    depth,
+    output: coc.value,
+    additionalReads: [
+      {
+        key: "scene-temporal",
+        // No-TAA DoF deliberately aliases this optional input to current color;
+        // only the TAA route consumes the matching resolved temporal attachment.
+        target: context.temporalTaa && temporal !== void 0 ? temporal : input
+      }
+    ]
+  });
+  if (!cocPass.ok) return cocPass;
+  const near = topology.useNear ? target(graph, "dof-near", { format: "rgba16float", size: halfSize }) : void 0;
+  if (near !== void 0 && !near.ok) return near;
+  const far = topology.useFar ? target(graph, "dof-far", { format: "rgba16float", size: halfSize }) : void 0;
+  if (far !== void 0 && !far.ok) return far;
+  const background = topology.useNear ? target(graph, "dof-background", { format: "rgba16float", size: halfSize }) : void 0;
+  if (background !== void 0 && !background.ok) return background;
+  for (const side of ["near", "far"]) {
+    const enabled = side === "near" ? topology.useNear : topology.useFar;
+    if (!enabled) continue;
+    const prefilter = target(graph, `dof-prefilter-${side}`, {
+      format: "rgba16float",
+      size: halfSize
+    });
+    if (!prefilter.ok) return prefilter;
+    const blur = side === "near" ? near : far;
+    if (blur === void 0 || !blur.ok) {
+      return err$1(
+        new RenderGraphError({
+          code: "resource-resolution-failed",
+          expected: `${side} DoF target is declared before its gather pass`,
+          hint: "retain the last-known-good Standard graph and retry DoF admission",
+          detail: { resourceLabel: `dof-${side}` }
+        })
+      );
+    }
+    const prefilterPass = addPass(graph, {
+      name: `dof-prefilter-${side}`,
+      shader: depthOfFieldPostProcessId(DEPTH_OF_FIELD_PREFILTER_ID, multisampled),
+      fragmentEntryPoint: side === "near" ? "fs_prefilter_near" : "fs_prefilter_far",
+      input,
+      depth,
+      output: prefilter.value,
+      additionalReads: [{ key: "dof-coc", target: coc.value }]
+    });
+    if (!prefilterPass.ok) return prefilterPass;
+    const prefilterMetadata = target(graph, `dof-prefilter-${side}-metadata`, {
+      format: "rgba16float",
+      size: halfSize
+    });
+    if (!prefilterMetadata.ok) return prefilterMetadata;
+    const metadataPass = addPass(graph, {
+      name: `dof-prefilter-${side}-metadata`,
+      shader: depthOfFieldPostProcessId(DEPTH_OF_FIELD_PREFILTER_METADATA_ID, multisampled),
+      fragmentEntryPoint: side === "near" ? "fs_prefilter_metadata_near" : "fs_prefilter_metadata_far",
+      input,
+      depth,
+      output: prefilterMetadata.value,
+      additionalReads: [
+        {
+          key: "scene-temporal",
+          target: context.temporalTaa && temporal !== void 0 ? temporal : input
+        },
+        { key: "dof-coc", target: coc.value }
+      ]
+    });
+    if (!metadataPass.ok) return metadataPass;
+    const gatherPass = addPass(graph, {
+      name: `dof-gather-${side}`,
+      shader: depthOfFieldPostProcessId(DEPTH_OF_FIELD_GATHER_ID, multisampled),
+      fragmentEntryPoint: side === "near" ? "fs_gather_near" : "fs_gather_far",
+      input: prefilter.value,
+      depth,
+      output: blur.value,
+      additionalReads: [
+        {
+          key: "scene-temporal",
+          target: context.temporalTaa && temporal !== void 0 ? temporal : input
+        },
+        { key: "dof-coc", target: coc.value },
+        { key: "dof-prefilter-metadata", target: prefilterMetadata.value }
+      ]
+    });
+    if (!gatherPass.ok) return gatherPass;
+  }
+  if (background?.ok) {
+    const backgroundPass = addPass(graph, {
+      name: "dof-fill-background",
+      shader: depthOfFieldPostProcessId(DEPTH_OF_FIELD_BACKGROUND_ID, multisampled),
+      fragmentEntryPoint: "fs_background",
+      input,
+      depth,
+      output: background.value,
+      additionalReads: [
+        {
+          key: "scene-temporal",
+          target: context.temporalTaa && temporal !== void 0 ? temporal : input
+        },
+        { key: "dof-coc", target: coc.value }
+      ]
+    });
+    if (!backgroundPass.ok) return backgroundPass;
+  }
+  const composite = target(graph, "dof-composite", {
+    format: input.format,
+    size: fullSize,
+    domain: input.domain
+  });
+  if (!composite.ok) return composite;
+  const nearInput = near?.ok === true ? near.value : input;
+  const farInput = far?.ok === true ? far.value : input;
+  const backgroundInput = background?.ok === true ? background.value : input;
+  const compositePass = addPass(graph, {
+    name: "dof-composite",
+    shader: depthOfFieldPostProcessId(DEPTH_OF_FIELD_COMPOSITE_ID, multisampled),
+    fragmentEntryPoint: "fs_composite",
+    input,
+    depth,
+    output: composite.value,
+    additionalReads: [
+      {
+        key: "scene-temporal",
+        // The composite shader always owns the temporal-depth slot. Without
+        // TAA, the current input is the explicit alias for that slot.
+        target: context.temporalTaa && temporal !== void 0 ? temporal : input
+      },
+      { key: "dof-coc", target: coc.value },
+      // Disabled sides alias the original input so their resources and gathers
+      // are absent while the fixed composite binding contract stays valid.
+      { key: "dof-near", target: nearInput },
+      { key: "dof-far", target: farInput },
+      { key: "dof-background", target: backgroundInput }
+    ]
+  });
+  if (!compositePass.ok) return compositePass;
+  return ok$1(composite.value);
+}
+function depthOfFieldPassNames(topology) {
+  const names = ["dof-coc"];
+  if (topology.useNear)
+    names.push(
+      "dof-prefilter-near",
+      "dof-prefilter-near-metadata",
+      "dof-gather-near",
+      "dof-fill-background"
+    );
+  if (topology.useFar)
+    names.push("dof-prefilter-far", "dof-prefilter-far-metadata", "dof-gather-far");
+  names.push("dof-composite");
+  return Object.freeze(names);
+}
+
+// src/features/depth-of-field/depth-of-field-assembly.ts
+function dofInspection(inspection) {
+  return inspection === void 0 ? {} : { depthOfField: Object.freeze(inspection) };
+}
+var DEPTH_READ = { key: "scene-depth", sampleType: "depth" };
+var DEPTH_OF_FIELD_READS = {
+  "forgeax.dof.coc": ["scene-color", "scene-temporal", DEPTH_READ],
+  "forgeax.dof.prefilter": ["scene-color", "dof-coc", DEPTH_READ],
+  "forgeax.dof.prefilter.metadata": ["scene-color", "scene-temporal", "dof-coc", DEPTH_READ],
+  "forgeax.dof.gather": [
+    "dof-prefilter",
+    "scene-temporal",
+    "dof-coc",
+    "dof-prefilter-metadata",
+    DEPTH_READ
+  ],
+  "forgeax.dof.background": ["scene-color", "scene-temporal", "dof-coc", DEPTH_READ],
+  "forgeax.dof.composite": [
+    "scene-color",
+    "scene-temporal",
+    "dof-coc",
+    "dof-near",
+    "dof-far",
+    "dof-background",
+    DEPTH_READ
+  ]
+};
+function registerDepthOfFieldBuiltins(renderSystem, entries) {
+  const register = (baseId, source, suffix) => {
+    const id = `${baseId}${suffix}`;
+    renderSystem.registerBuiltinPostProcess(id, {
+      source,
+      params: { byteSize: 64, defaultValue: new Uint8Array(64) },
+      reads: DEPTH_OF_FIELD_READS[baseId]
+    });
+  };
+  if (entries.singleSample !== void 0) {
+    for (const id of DEPTH_OF_FIELD_POST_PROCESS_IDS) register(id, entries.singleSample, "");
+  }
+  if (entries.multisampled !== void 0) {
+    for (const id of DEPTH_OF_FIELD_POST_PROCESS_IDS) register(id, entries.multisampled, ".msaa");
+  }
+}
+async function prewarmDepthOfField(manifestEntries, prewarm, register) {
+  let singleSample;
+  let multisampled;
+  for (const entry of manifestEntries) {
+    if (!entry.wgsl.includes("DepthOfFieldParams")) continue;
+    if (entry.wgsl.includes("texture_depth_multisampled_2d")) {
+      multisampled ??= entry;
+    } else {
+      singleSample ??= entry;
+    }
+  }
+  for (const id of DEPTH_OF_FIELD_POST_PROCESS_IDS) await prewarm(singleSample, id);
+  for (const id of DEPTH_OF_FIELD_POST_PROCESS_IDS) await prewarm(multisampled, `${id}.msaa`);
+  register({
+    ...singleSample === void 0 ? {} : { singleSample: singleSample.wgsl },
+    ...multisampled === void 0 ? {} : { multisampled: multisampled.wgsl }
+  });
+}
 function stageFailure(identity) {
   return {
     code: "render-feature-stage-failed",
@@ -2464,7 +2735,7 @@ function validPositiveInteger(value) {
 }
 function freezeRenderFeaturePlan(identity, plan, logicalTargets2 = []) {
   const resources = /* @__PURE__ */ new Map();
-  const targets = /* @__PURE__ */ new Set(["swapchain", ...logicalTargets2.map((target4) => target4.name)]);
+  const targets = /* @__PURE__ */ new Set(["swapchain", ...logicalTargets2.map((target5) => target5.name)]);
   for (const resource of plan.resources) {
     if (!validName(resource.name) || resources.has(resource.name))
       return err$1(stageFailure(identity));
@@ -2513,7 +2784,7 @@ function freezeRenderFeaturePlan(identity, plan, logicalTargets2 = []) {
       continue;
     }
     if (pass.draws.length === 0 || pass.kind === "raster" && (pass.colorAttachments.some((attachment) => !targets.has(attachment.target)) || pass.depthStencilAttachment !== void 0 && !targets.has(pass.depthStencilAttachment.target) || pass.sampledTargets?.some(
-      (target4) => typeof target4 === "string" && !targets.has(target4)
+      (target5) => typeof target5 === "string" && !targets.has(target5)
     ) === true)) {
       return err$1(stageFailure(identity));
     }
@@ -3186,11 +3457,11 @@ function recordFailure(slot, stage, failure5, errors) {
 }
 function logicalTargets(targets) {
   return Object.freeze(
-    targets.map((target4) => ({
-      name: target4.name ?? (target4.kind === "scene-color" ? "color" : "depth"),
-      kind: target4.kind === "scene-color" ? "color" : "depth",
-      format: target4.format,
-      sampleCount: target4.sampleCount
+    targets.map((target5) => ({
+      name: target5.name ?? (target5.kind === "scene-color" ? "color" : "depth"),
+      kind: target5.kind === "scene-color" ? "color" : "depth",
+      format: target5.format,
+      sampleCount: target5.sampleCount
     }))
   );
 }
@@ -3201,12 +3472,12 @@ function targetHandle(name, targets) {
   if (name === "swapchain") return "swapchain";
   if (typeof name !== "string") return name;
   return targets.find(
-    (target4) => target4.name === name || target4.name === void 0 && (name === "color" && target4.kind === "scene-color" || name === "depth" && target4.kind === "scene-depth")
+    (target5) => target5.name === name || target5.name === void 0 && (name === "color" && target5.kind === "scene-color" || name === "depth" && target5.kind === "scene-depth")
   );
 }
 function targetFormat(name, targets, fallback) {
-  const target4 = targets.find((candidate) => candidate.name === name);
-  return target4?.format ?? fallback;
+  const target5 = targets.find((candidate) => candidate.name === name);
+  return target5?.format ?? fallback;
 }
 function preparePlanResources(slot, plan, graphics, gpu, targets) {
   const computePrograms = /* @__PURE__ */ new Map();
@@ -3304,9 +3575,9 @@ function preparePlanResources(slot, plan, graphics, gpu, targets) {
     if (program === void 0) return err$1(planFailure(slot));
     const values = { ...resource.values };
     for (const [key, targetName] of Object.entries(resource.logicalTargets ?? {})) {
-      const target4 = targetHandle(targetName, targets);
-      if (target4 === void 0 || typeof target4 === "string") return err$1(planFailure(slot));
-      values[key] = target4;
+      const target5 = targetHandle(targetName, targets);
+      if (target5 === void 0 || typeof target5 === "string") return err$1(planFailure(slot));
+      values[key] = target5;
     }
     const prepared = graphics.prepareBindings(resource.name, { pipeline: program, values });
     if (!prepared.ok) return prepared;
@@ -3503,7 +3774,7 @@ function projectPlanPasses(slot, plan, prepared, gpu, targets, validateGraphics,
     );
     if (colors.some(
       (attachment) => attachment.resource === void 0 || attachment.format === void 0
-    ) || depth !== void 0 && (depth.resource === void 0 || depth.format === void 0) || sampledTargets.some((target4) => target4 === void 0 || typeof target4 === "string")) {
+    ) || depth !== void 0 && (depth.resource === void 0 || depth.format === void 0) || sampledTargets.some((target5) => target5 === void 0 || typeof target5 === "string")) {
       return err$1(planFailure(slot));
     }
     const attachments = depth === void 0 ? { colors } : {
@@ -4017,7 +4288,7 @@ function runRenderFeatureFrame(host, input) {
       submissionSensitivePlans.add(plannedFrame);
       submissionAcknowledgments.set(
         plannedFrame,
-        () => feature.onFrameSubmitted?.(extracted.value)
+        () => feature.onFrameSubmitted?.(extracted.value, projected.value)
       );
     }
     plans.push(plannedFrame);
@@ -4318,22 +4589,22 @@ function addAtmosphereIbl(graph, sky, vertices, dirty) {
   for (const product of ["irradiance", "prefilter"]) {
     for (let mip = 0; mip < (product === "irradiance" ? 1 : 5); mip++)
       for (let face = 0; face < 6; face++) {
-        const target4 = graph.view(product === "irradiance" ? irradiance.value : prefilter.value, {
+        const target5 = graph.view(product === "irradiance" ? irradiance.value : prefilter.value, {
           dimension: "2d",
           baseArrayLayer: face,
           arrayLayerCount: 1,
           baseMipLevel: mip,
           mipLevelCount: 1
         });
-        if (!target4.ok) return target4;
+        if (!target5.ok) return target5;
         const pass = graph.addRasterPass(`atmosphere-${product}-${mip}-${face}`, {
           accesses: [
             { resource: sky, usage: "sampled-read" },
             { resource: parameters.value, usage: "uniform-read" },
             { resource: vertices, usage: "vertex-read" },
-            { resource: target4.value, usage: "color-attachment" }
+            { resource: target5.value, usage: "color-attachment" }
           ],
-          colorAttachments: [{ view: target4.value, loadOp: "clear", storeOp: "store" }],
+          colorAttachments: [{ view: target5.value, loadOp: "clear", storeOp: "store" }],
           executeIf: dirty,
           encode: ({ frame, resources, pass: pass2 }) => {
             const current = ensureState(frame);
@@ -4797,7 +5068,7 @@ function resolvedBuffer(resources, buffer) {
   if (!resolved2.ok) throw resolved2.error;
   return resolved2.value;
 }
-function addPass(graph, name, accesses, encode = () => void 0) {
+function addPass2(graph, name, accesses, encode = () => void 0) {
   return graph.addComputePass(name, { accesses, encode });
 }
 function addSsrSpatialPasses(graph, input) {
@@ -5008,7 +5279,7 @@ function addSsrSpatialPasses(graph, input) {
       }
     ]
   };
-  let added = addPass(
+  let added = addPass2(
     graph,
     "ssr-hiz-seed",
     [
@@ -5048,7 +5319,7 @@ function addSsrSpatialPasses(graph, input) {
   if (added.ok) passNames.push("ssr-hiz-seed");
   if (!added.ok) return added;
   if (hiz.levels.length > 1) {
-    added = addPass(
+    added = addPass2(
       graph,
       "ssr-hiz-reduce-chain",
       hiz.levels.map((resource, level) => ({
@@ -5068,9 +5339,9 @@ function addSsrSpatialPasses(graph, input) {
         pass.setPipeline(hizReduceState.pipeline);
         for (let level = 1; level < hiz.levels.length; level++) {
           const source = hiz.levels[level - 1];
-          const target4 = hiz.levels[level];
+          const target5 = hiz.levels[level];
           const extent = hiz.plan.levels[level];
-          if (source === void 0 || target4 === void 0 || extent === void 0)
+          if (source === void 0 || target5 === void 0 || extent === void 0)
             throw pipelineError("Hi-Z mip chain");
           pass.setBindGroup(
             0,
@@ -5081,7 +5352,7 @@ function addSsrSpatialPasses(graph, input) {
               },
               {
                 binding: 1,
-                resource: { kind: "textureView", value: resolvedView(resolver, target4) }
+                resource: { kind: "textureView", value: resolvedView(resolver, target5) }
               }
             ])
           );
@@ -5092,7 +5363,7 @@ function addSsrSpatialPasses(graph, input) {
     if (!added.ok) return added;
     passNames.push("ssr-hiz-reduce-chain");
   }
-  added = addPass(
+  added = addPass2(
     graph,
     "ssr-trace",
     [
@@ -5149,7 +5420,7 @@ function addSsrSpatialPasses(graph, input) {
   if (!added.ok) return added;
   passNames.push("ssr-trace");
   if (temporal !== void 0) {
-    added = addPass(
+    added = addPass2(
       graph,
       "ssr-temporal",
       [
@@ -5263,7 +5534,7 @@ function addSsrSpatialPasses(graph, input) {
   if (reflectionLevels.length > 1 && resolved2 !== void 0) {
     const output = resolved2;
     const name = "ssr-reflection-mip-chain";
-    const added2 = addPass(
+    const added2 = addPass2(
       graph,
       name,
       reflectionLevels.map((resource, level) => ({
@@ -5294,8 +5565,8 @@ function addSsrSpatialPasses(graph, input) {
         pass.setPipeline(reflectionMipState.pipeline);
         for (let level = 1; level < reflectionLevels.length; level++) {
           const previous = reflectionLevels[level - 1];
-          const target4 = reflectionLevels[level];
-          if (previous === void 0 || target4 === void 0)
+          const target5 = reflectionLevels[level];
+          if (previous === void 0 || target5 === void 0)
             throw pipelineError("reflection mip chain");
           pass.setBindGroup(
             0,
@@ -5311,7 +5582,7 @@ function addSsrSpatialPasses(graph, input) {
                 binding: 7,
                 resource: {
                   kind: "textureView",
-                  value: resolvedView(resolver, target4)
+                  value: resolvedView(resolver, target5)
                 }
               }
             ])
@@ -5367,12 +5638,12 @@ function createTargetCoverageAttachment(graph, extent) {
     outputHeight: extent.outputHeight
   });
 }
-function addTargetCoveragePass(graph, target4) {
+function addTargetCoveragePass(graph, target5) {
   return addTypedScenePass(graph, {
     name: "standard-scene-coverage",
-    color: target4.coverage,
-    colorTargets: [target4.coverage],
-    depth: target4.depth,
+    color: target5.coverage,
+    colorTargets: [target5.coverage],
+    depth: target5.depth,
     selector: { LightMode: ["Deferred", "Forward"] },
     passKind: "temporal",
     clearColor: [0, 0, 0, 0],
@@ -5619,12 +5890,12 @@ function addTransmissionBackdropPasses(input) {
     ],
     encode: ({ encoder, resources }) => {
       const source = resources.texture(input.source.texture);
-      const target4 = resources.texture(backdrop.value.texture);
+      const target5 = resources.texture(backdrop.value.texture);
       if (!source.ok) throw source.error;
-      if (!target4.ok) throw target4.error;
+      if (!target5.ok) throw target5.error;
       encoder.copyTextureToTexture(
         { texture: source.value, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
-        { texture: target4.value, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
+        { texture: target5.value, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
         { ...input.copySize, depthOrArrayLayers: 1 }
       );
     }
@@ -5726,12 +5997,12 @@ function shadowViewCacheReuse(frame, identity) {
   const key = `${identity.kind}:${identity.index}:${identity.face ?? ""}`;
   return state.shadowViewCacheReuse?.get(key) === true;
 }
-function recordShadowPass(graph, name, target4, loadOp, encode, executeIf, extraAccesses = []) {
+function recordShadowPass(graph, name, target5, loadOp, encode, executeIf, extraAccesses = []) {
   return graph.addRasterPass(name, {
-    accesses: [{ resource: target4.view, usage: "depth-stencil-write" }, ...extraAccesses],
+    accesses: [{ resource: target5.view, usage: "depth-stencil-write" }, ...extraAccesses],
     colorAttachments: [],
     depthStencilAttachment: {
-      view: target4.view,
+      view: target5.view,
       depthLoadOp: loadOp,
       depthStoreOp: "store",
       ...loadOp === "clear" ? { depthClearValue: 1 } : {}
@@ -5747,15 +6018,15 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
   if (topology.shadow.directional !== "disabled") {
     const { mapSize, cascadeCount } = topology.shadow.directional;
     const atlasGrid = resolveDirectionalShadowAtlasGrid(cascadeCount);
-    const target4 = createRenderPipelineTarget(graph, "directional-shadow-depth", {
+    const target5 = createRenderPipelineTarget(graph, "directional-shadow-depth", {
       format: "depth32float",
       size: {
         width: mapSize * atlasGrid.columns,
         height: mapSize * atlasGrid.rows
       }
     });
-    if (!target4.ok) return target4;
-    const directionalTarget = target4.value;
+    if (!target5.ok) return target5;
+    const directionalTarget = target5.value;
     directional = directionalTarget;
     for (let cascade = 0; cascade < cascadeCount; cascade += 1) {
       const col = cascade % atlasGrid.columns;
@@ -7153,6 +7424,7 @@ function requestedStages(input) {
   const stages = [];
   if (input.temporal) stages.push("temporal");
   if (input.meter) stages.push("meter");
+  if (input.dof === true) stages.push("dof");
   if (input.bloom) stages.push("bloom");
   if (input.exposure || input.whiteBalance) stages.push("exposure-white-balance");
   stages.push("tone");
@@ -7167,6 +7439,7 @@ function physicalStages(logicalStages) {
       case "temporal":
       case "meter":
       case "bloom":
+      case "dof":
       case "exposure-white-balance":
         return { name, input: LINEAR_HDR_DOMAIN, output: LINEAR_HDR_DOMAIN };
       case "tone":
@@ -7191,6 +7464,7 @@ function createStandardOutputPlan(input) {
       temporal: input.temporal,
       meter: input.meter,
       bloom: input.bloom,
+      dof: input.dof === true,
       exposure: input.exposure,
       whiteBalance: input.whiteBalance,
       lut: input.lut,
@@ -7610,13 +7884,13 @@ function inspectStandardBloomGraph(graph) {
     status: "valid",
     targetCount: targets.length,
     targetBytes: targets.reduce(
-      (bytes2, target4) => bytes2 + textureBytes(target4.resource, target4.expected),
+      (bytes2, target5) => bytes2 + textureBytes(target5.resource, target5.expected),
       0
     ),
     passCount: passes.length
   };
 }
-function target(context, label, descriptor) {
+function target2(context, label, descriptor) {
   return createRenderPipelineTarget(context.graph, label, descriptor);
 }
 function missingTemporalContributor(topology, contributorId) {
@@ -7637,6 +7911,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
     temporal: !clearOnly && topology.camera.antialias === "taa",
     meter: topology.output?.autoExposure === true,
     bloom: !clearOnly && topology.camera.bloom === "on" && topology.camera.tonemap !== "none",
+    dof: !clearOnly && topology.camera.depthOfField !== void 0,
     exposure: topology.output?.autoExposure === true,
     whiteBalance: topology.output?.whiteBalance === true,
     lut: topology.output?.colorLut === true,
@@ -7651,7 +7926,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
   const outputDither = resolveOutputDither(topology.config);
   const motionBlur = !clearOnly && topology.temporal?.motionBlur === true;
   const postEffects = clearOnly ? [] : topology.config?.postEffects ?? [];
-  const rawOnlyPostInput = rawOnly && topology.lane.storageBuffer && postEffects.length > 0 ? target(context, "standard-post-effects-input", {
+  const rawOnlyPostInput = rawOnly && topology.lane.storageBuffer && postEffects.length > 0 ? target2(context, "standard-post-effects-input", {
     format: "rgba16float",
     size: "surface",
     usage: GPU_TEXTURE_USAGE_COPY_SRC,
@@ -7722,7 +7997,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
           new Error("Motion Blur requires the Standard scene-data producer")
         );
       }
-      const blurred = target(context, "motion-blurred-color", {
+      const blurred = target2(context, "motion-blurred-color", {
         format: "rgba16float",
         size: "surface",
         domain: hdr ? "linear-hdr" : "linear-ldr"
@@ -7757,26 +8032,42 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
     });
     if (!added.ok) return added;
   }
+  if (outputPlan.features.dof) {
+    const dof = addDepthOfFieldPasses(
+      {
+        graph: context.graph,
+        camera: context.camera ?? {},
+        temporalTaa: topology.temporal?.taa === true,
+        msaaActive: depth.sampleCount === 4,
+        ...topology.extent === void 0 ? {} : { extent: topology.extent }
+      },
+      postInput,
+      depth,
+      topology.temporal?.taa === true ? postTemporal : void 0
+    );
+    if (!dof.ok) return dof;
+    postInput = dof.value;
+  }
   if (bloomActive) {
-    const composited = target(
+    const composited = target2(
       context,
       STANDARD_BLOOM_TARGET_SPEC.composited.label,
       STANDARD_BLOOM_TARGET_SPEC.composited
     );
     if (!composited.ok) return composited;
-    const bright = target(
+    const bright = target2(
       context,
       STANDARD_BLOOM_TARGET_SPEC.bright.label,
       STANDARD_BLOOM_TARGET_SPEC.bright
     );
     if (!bright.ok) return bright;
-    const blurH = target(
+    const blurH = target2(
       context,
       STANDARD_BLOOM_TARGET_SPEC.blurH.label,
       STANDARD_BLOOM_TARGET_SPEC.blurH
     );
     if (!blurH.ok) return blurH;
-    const blurV = target(
+    const blurV = target2(
       context,
       STANDARD_BLOOM_TARGET_SPEC.blurV.label,
       STANDARD_BLOOM_TARGET_SPEC.blurV
@@ -7793,7 +8084,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
     postInput = composited.value;
   }
   if (outputPlan.features.exposure || outputPlan.features.whiteBalance) {
-    const exposureOutput = target(context, "standard-exposure-white-balance", {
+    const exposureOutput = target2(context, "standard-exposure-white-balance", {
       format: "rgba16float",
       size: "surface",
       domain: "linear-hdr"
@@ -7818,7 +8109,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
   // that the LUT and auto-exposure routes already use so the graph can
   // capture it without changing unobserved frames.
   context.observationCaptureDomains?.includes("linear-ldr") === true;
-  const toneOutput = splitOutput ? target(context, "standard-tone-output", {
+  const toneOutput = splitOutput ? target2(context, "standard-tone-output", {
     format: "rgba16float",
     size: "surface",
     domain: "linear-ldr"
@@ -7845,7 +8136,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
         })
       );
     }
-    const lutOutput = target(context, "standard-color-lut", {
+    const lutOutput = target2(context, "standard-color-lut", {
       format: "rgba16float",
       size: "surface",
       domain: "linear-ldr"
@@ -7861,11 +8152,11 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
   }
   if (hdr || linearLdr || fxaa || rawOnly || motionBlur) {
     if (fxaa) {
-      const output = splitOutput ? target(context, "standard-fxaa-output", {
+      const output = splitOutput ? target2(context, "standard-fxaa-output", {
         format: "rgba16float",
         size: "surface",
         domain: "linear-ldr"
-      }) : target(context, "standard-output-color", {
+      }) : target2(context, "standard-output-color", {
         format: "rgba16float",
         size: "surface",
         usage: GPU_TEXTURE_USAGE_COPY_SRC,
@@ -7955,7 +8246,7 @@ function addStandardPost(context, topology, scene, depth, surface, sceneTemporal
 }
 
 // src/pipeline/standard-forward-lane.ts
-function target2(graph, label, descriptor) {
+function target3(graph, label, descriptor) {
   return createRenderPipelineTarget(graph, label, descriptor);
 }
 function buildUrp(context, topology, lighting) {
@@ -7976,31 +8267,31 @@ function buildUrp(context, topology, lighting) {
   });
   const needsTemporalIntermediate = temporalDemand.targetCount === 1;
   const sceneFormat = hdr || linearLdr || rawOnly || needsTemporalIntermediate ? "rgba16float" : topology.surface.storageFormat;
-  const depth = target2(graph, "scene-depth", {
+  const depth = target3(graph, "scene-depth", {
     format: "depth24plus-stencil8",
     size: internalSize,
     sampleCount: msaa ? 4 : 1
   });
   if (!depth.ok) return depth;
-  const sceneResolved = clearOnly ? surface.value.display === void 0 ? target2(graph, "scene-color", {
+  const sceneResolved = clearOnly ? surface.value.display === void 0 ? target3(graph, "scene-color", {
     format: topology.surface.storageFormat,
     size: "surface",
     sampleCount: 1,
     domain: "display-encoded"
-  }) : ok$1(surface.value.display) : hdr || fxaa || linearLdr || msaa || rawOnly || needsTemporalIntermediate ? target2(graph, "scene-color", {
+  }) : ok$1(surface.value.display) : hdr || fxaa || linearLdr || msaa || rawOnly || needsTemporalIntermediate ? target3(graph, "scene-color", {
     format: sceneFormat,
     size: internalSize,
     sampleCount: 1,
     domain: "linear-ldr",
     ...sceneFormat === topology.surface.storageFormat && topology.surface.storageFormat !== topology.surface.viewFormat ? { viewFormats: [topology.surface.viewFormat] } : {}
-  }) : surface.value.display === void 0 ? target2(graph, "scene-color", {
+  }) : surface.value.display === void 0 ? target3(graph, "scene-color", {
     format: topology.surface.storageFormat,
     size: "surface",
     sampleCount: 1,
     domain: "display-encoded"
   }) : ok$1(surface.value.display);
   if (!sceneResolved.ok) return sceneResolved;
-  const scene = msaa ? target2(graph, "scene-color-msaa", {
+  const scene = msaa ? target3(graph, "scene-color-msaa", {
     format: sceneFormat,
     size: internalSize,
     sampleCount: 4,
@@ -8008,7 +8299,7 @@ function buildUrp(context, topology, lighting) {
     ...sceneFormat === topology.surface.storageFormat && topology.surface.storageFormat !== topology.surface.viewFormat ? { viewFormats: [topology.surface.viewFormat] } : {}
   }) : sceneResolved;
   if (!scene.ok) return scene;
-  const reflectionFallback = topology.reflectionFallback?.enabled ? target2(graph, "reflection-fallback-linear-hdr", {
+  const reflectionFallback = topology.reflectionFallback?.enabled ? target3(graph, "reflection-fallback-linear-hdr", {
     format: "rgba16float",
     size: internalSize,
     sampleCount: scene.value.sampleCount,
@@ -8221,7 +8512,7 @@ function buildUrp(context, topology, lighting) {
     [
       ...clusterReads,
       ...[shadows.value.directional, shadows.value.spot, shadows.value.point].flatMap(
-        (target4) => target4 === void 0 ? [] : [{ resource: target4.view, usage: "sampled-read" }]
+        (target5) => target5 === void 0 ? [] : [{ resource: target5.view, usage: "sampled-read" }]
       )
     ]
   );
@@ -8380,7 +8671,7 @@ function validateClusterGrid(grid) {
     )
   );
 }
-function target3(graph, label, descriptor) {
+function target4(graph, label, descriptor) {
   return createRenderPipelineTarget(graph, label, descriptor);
 }
 function buildStandardDeferredLane(context, topology, lighting) {
@@ -8401,7 +8692,7 @@ function buildStandardDeferredLane(context, topology, lighting) {
     featureShadows?.value
   );
   if (!shadows.ok) return shadows;
-  const depth = target3(graph, "hdrp-depth", {
+  const depth = target4(graph, "hdrp-depth", {
     format: "depth24plus-stencil8",
     size: internalSize
   });
@@ -8412,24 +8703,24 @@ function buildStandardDeferredLane(context, topology, lighting) {
     aspect: "depth-only"
   });
   if (!depthSample.ok) return depthSample;
-  const gbuffer0 = target3(graph, "gbuffer-normal-roughness", {
+  const gbuffer0 = target4(graph, "gbuffer-normal-roughness", {
     format: DEFERRED_COLOR_FORMATS[0] ?? "rgba16float",
     size: internalSize
   });
   if (!gbuffer0.ok) return gbuffer0;
-  const gbuffer1 = target3(graph, "gbuffer-albedo-metallic", {
+  const gbuffer1 = target4(graph, "gbuffer-albedo-metallic", {
     format: DEFERRED_COLOR_FORMATS[1] ?? "rgba8unorm",
     size: internalSize
   });
   if (!gbuffer1.ok) return gbuffer1;
-  const gbuffer2 = target3(graph, "gbuffer-specular-response-ao", {
+  const gbuffer2 = target4(graph, "gbuffer-specular-response-ao", {
     format: DEFERRED_COLOR_FORMATS[2] ?? "rgba16float",
     size: internalSize
   });
   if (!gbuffer2.ok) return gbuffer2;
-  const scene = target3(graph, "hdrp-scene-color", { format: "rgba16float", size: internalSize });
+  const scene = target4(graph, "hdrp-scene-color", { format: "rgba16float", size: internalSize });
   if (!scene.ok) return scene;
-  const reflectionFallback = topology.reflectionFallback?.enabled === true || topology.ssr?.status === "admitted" ? target3(graph, "reflection-fallback-linear-hdr", {
+  const reflectionFallback = topology.reflectionFallback?.enabled === true || topology.ssr?.status === "admitted" ? target4(graph, "reflection-fallback-linear-hdr", {
     format: "rgba16float",
     size: internalSize,
     domain: "linear-hdr"
@@ -8483,9 +8774,9 @@ function buildStandardDeferredLane(context, topology, lighting) {
   if (!gbuffer.ok) return gbuffer;
   let ssao;
   if (topology.config?.ssao?.enabled === true) {
-    const raw = target3(graph, "ssao-raw", { format: "r8unorm", size: "half-surface" });
+    const raw = target4(graph, "ssao-raw", { format: "r8unorm", size: "half-surface" });
     if (!raw.ok) return raw;
-    const blurred = target3(graph, "ssao-blurred", { format: "r8unorm", size: "half-surface" });
+    const blurred = target4(graph, "ssao-blurred", { format: "r8unorm", size: "half-surface" });
     if (!blurred.ok) return blurred;
     const passes = addTypedSsaoPasses(graph, {
       normal: gbuffer0.value,
@@ -8732,7 +9023,7 @@ function buildStandardDeferredLane(context, topology, lighting) {
     [
       ...forwardExtraAccesses,
       ...[shadows.value.directional, shadows.value.spot, shadows.value.point].flatMap(
-        (target4) => target4 === void 0 ? [] : [{ resource: target4.view, usage: "sampled-read" }]
+        (target5) => target5 === void 0 ? [] : [{ resource: target5.view, usage: "sampled-read" }]
       ),
       ...ssao === void 0 ? [] : [{ resource: ssao.view, usage: "sampled-read" }]
     ]
@@ -10196,10 +10487,10 @@ function projectStandardPbrScene(input) {
     const normalMatrix = mat3.normalMatrix(normal, world);
     for (let column = 0; column < 3; column += 1) {
       const source = column * 3;
-      const target4 = base + 16 + column * 4;
-      rows[target4] = normalMatrix[source] ?? 0;
-      rows[target4 + 1] = normalMatrix[source + 1] ?? 0;
-      rows[target4 + 2] = normalMatrix[source + 2] ?? 0;
+      const target5 = base + 16 + column * 4;
+      rows[target5] = normalMatrix[source] ?? 0;
+      rows[target5 + 1] = normalMatrix[source + 1] ?? 0;
+      rows[target5 + 2] = normalMatrix[source + 2] ?? 0;
     }
     rows[base + 47] = candidate.materialIndex ?? 0;
   }
@@ -13130,7 +13421,7 @@ var EnvironmentLifecycle = class _EnvironmentLifecycle {
     const generation = (value) => {
       if (value === void 0) return void 0;
       const resourceCount = value.resourceCount;
-      const resourceBytes = value.resourceBytes;
+      const resourceBytes2 = value.resourceBytes;
       const source = this.frames.get(value.signature)?.source.kind ?? "none";
       return Object.freeze({
         signature: value.signature,
@@ -13138,8 +13429,8 @@ var EnvironmentLifecycle = class _EnvironmentLifecycle {
         lane: value.lane,
         source,
         resourceCount,
-        bytes: resourceBytes,
-        residentBytes: value.retired ? 0 : resourceBytes,
+        bytes: resourceBytes2,
+        residentBytes: value.retired ? 0 : resourceBytes2,
         retiringBytes: 0
       });
     };
@@ -13188,6 +13479,121 @@ var EnvironmentLifecycle = class _EnvironmentLifecycle {
     return { ...generation, lane };
   }
 };
+
+// src/features/depth-of-field/depth-of-field-inspection.ts
+var DOF_FORMAT_BYTES = Object.freeze({
+  rgba16float: 8,
+  rgba8unorm: 4
+});
+function resourceBytes(resource) {
+  if (resource.byteSize !== void 0) return resource.byteSize;
+  const descriptor = resource.descriptor;
+  if (descriptor.kind !== "texture") return 0;
+  const texelBytes = DOF_FORMAT_BYTES[descriptor.format] ?? 0;
+  if (texelBytes === 0) return 0;
+  let bytes2 = 0;
+  for (let level = 0; level < descriptor.mipLevelCount; level += 1) {
+    bytes2 += Math.max(1, descriptor.width >> level) * Math.max(1, descriptor.height >> level) * descriptor.depthOrArrayLayers * texelBytes;
+  }
+  return bytes2 * descriptor.sampleCount;
+}
+function textureExtent(graph, label) {
+  const resource = graph.resources.find(
+    (candidate) => candidate.kind === "texture" && candidate.label === label
+  );
+  if (resource?.descriptor.kind !== "texture") return void 0;
+  return { width: resource.descriptor.width, height: resource.descriptor.height };
+}
+var emptyExtent = Object.freeze({ width: 0, height: 0 });
+var OFF_PARAMS = Object.freeze({ ...DEFAULT_DEPTH_OF_FIELD_PARAMS, maxRadiusPixels: 0 });
+function inspectDepthOfFieldGraph(graph, params) {
+  const topology = depthOfFieldTopology(params);
+  if (graph === void 0 || topology === void 0) {
+    return {
+      status: "empty",
+      outputExtent: emptyExtent,
+      workExtent: emptyExtent,
+      passCount: 0,
+      textureBytes: 0,
+      graphGeneration: graph?.generation ?? 0
+    };
+  }
+  const expectedPasses = new Set(depthOfFieldPassNames(topology));
+  const passes = graph.passes.filter((pass) => expectedPasses.has(pass.name));
+  const dofResources = graph.resources.filter(
+    (resource) => resource.kind === "texture" && resource.label.startsWith("dof-")
+  );
+  const expectedResourceLabels = [
+    "dof-coc",
+    ...topology.useNear ? ["dof-near", "dof-prefilter-near", "dof-prefilter-near-metadata", "dof-background"] : [],
+    ...topology.useFar ? ["dof-far", "dof-prefilter-far", "dof-prefilter-far-metadata"] : [],
+    "dof-composite"
+  ];
+  const resourceLabels = new Set(dofResources.map((resource) => resource.label));
+  const completePasses = passes.length === expectedPasses.size && passes.every((pass) => expectedPasses.has(pass.name));
+  const completeResources = dofResources.length === expectedResourceLabels.length && expectedResourceLabels.every((label) => resourceLabels.has(label)) && dofResources.every((resource) => resourceBytes(resource) > 0);
+  const outputExtent = textureExtent(graph, "dof-composite") ?? emptyExtent;
+  const workExtent = textureExtent(graph, topology.useNear ? "dof-near" : "dof-far") ?? emptyExtent;
+  return {
+    status: completePasses && completeResources ? "active" : "invalid",
+    outputExtent,
+    workExtent,
+    passCount: completePasses ? passes.length : 0,
+    textureBytes: completeResources ? dofResources.reduce((bytes2, resource) => bytes2 + resourceBytes(resource), 0) : 0,
+    graphGeneration: graph.generation
+  };
+}
+function projectDepthOfFieldInspection(input) {
+  const params = input.params ?? OFF_PARAMS;
+  const topology = input.error === void 0 ? depthOfFieldTopology(input.params) : void 0;
+  const requested = {
+    focusDistance: params.focusDistance,
+    fStop: params.fStop,
+    sensorHeight: params.sensorHeight,
+    maxRadiusPixels: params.maxRadiusPixels,
+    quality: params.quality,
+    blurSide: params.blurSide
+  };
+  const enabled = input.error !== void 0 || topology !== void 0;
+  const transactionBound = "accepted" in input;
+  const accepted = input.accepted;
+  const acceptedTopology = depthOfFieldTopology(accepted?.params);
+  const acceptedGraph = accepted === void 0 ? void 0 : inspectDepthOfFieldGraph(accepted.graph, accepted.params);
+  const acceptedValid = accepted !== void 0 && accepted.deviceGeneration === input.deviceGeneration && acceptedTopology !== void 0 && acceptedGraph?.status === "active";
+  const candidateGraph = inspectDepthOfFieldGraph(input.graph, input.params);
+  const graph = transactionBound ? acceptedValid ? acceptedGraph ?? candidateGraph : candidateGraph : candidateGraph;
+  const status = input.error?.code === "depth-of-field-orthographic-unsupported" ? "unsupported" : input.error !== void 0 ? "invalid" : !enabled ? "off" : transactionBound ? acceptedValid && !input.lastSubmitFailed && requestedEqual(requested, accepted.params) ? "active" : input.lastSubmitFailed ? "invalid" : candidateGraph.status === "invalid" ? "invalid" : "reset" : graph.status === "active" ? "active" : graph.status === "invalid" ? "invalid" : "reset";
+  const effective = acceptedValid ? {
+    focusDistance: accepted.params.focusDistance,
+    fStop: accepted.params.fStop,
+    sensorHeight: accepted.params.sensorHeight,
+    maxRadiusPixels: accepted.params.maxRadiusPixels,
+    quality: accepted.params.quality,
+    blurSide: accepted.params.blurSide
+  } : status === "active" ? requested : void 0;
+  const effectiveParams = acceptedValid ? accepted.params : status === "active" ? params : void 0;
+  return Object.freeze({
+    enabled,
+    status,
+    requested,
+    ...effective === void 0 ? {} : { effective },
+    focalLength: effectiveParams?.focalLength ?? params.focalLength,
+    outputExtent: graph.outputExtent,
+    workExtent: graph.workExtent,
+    tapCount: effectiveParams !== void 0 ? effectiveParams.quality === "low" ? 16 : effectiveParams.quality === "medium" ? 32 : 64 : 0,
+    passCount: graph.passCount,
+    textureBytes: graph.textureBytes,
+    transparentPolicy: "opaque-depth-approximation",
+    graphGeneration: graph.graphGeneration,
+    deviceGeneration: input.deviceGeneration,
+    lastKnownGood: acceptedValid || status === "active",
+    ...input.error === void 0 ? {} : { error: input.error },
+    ...input.error?.code === "depth-of-field-orthographic-unsupported" ? { fallbackReason: "orthographic-unsupported" } : input.error !== void 0 ? { fallbackReason: "invalid-params" } : status === "off" ? { fallbackReason: "zero-radius" } : status === "reset" ? { fallbackReason: "shader-not-ready" } : status === "invalid" ? { fallbackReason: "candidate-failed" } : {}
+  });
+}
+function requestedEqual(requested, params) {
+  return requested.focusDistance === params.focusDistance && requested.fStop === params.fStop && requested.sensorHeight === params.sensorHeight && requested.maxRadiusPixels === params.maxRadiusPixels && requested.quality === params.quality && requested.blurSide === params.blurSide;
+}
 function createFeatureNoisePixels() {
   const pixels = new Uint8Array(64 * 64 * 4);
   let state = 1831565813;
@@ -15332,7 +15738,7 @@ function collectGpuDrivenMaterialArtifacts({
       entry.materialShaderId
     );
   }
-  const collectArtifacts = (rows2, pass, target4) => {
+  const collectArtifacts = (rows2, pass, target5) => {
     if (resolve === void 0) return;
     for (const row of rows2) {
       for (const draw of row.source.gpuDrivenDraws ?? []) {
@@ -15382,7 +15788,7 @@ function collectGpuDrivenMaterialArtifacts({
         if (selectedIdentityArtifact === void 0 || receipt === void 0 || !shadowVertexInputsMatch || pass !== "shadow" && (receipt.receiptIdentity !== prepared.receiptIdentity || receipt.generation !== prepared.receiptGeneration)) {
           continue;
         }
-        target4.set(
+        target5.set(
           gpuDrivenMaterialArtifactKey({
             material: prepared.identity.material,
             deformation: prepared.identity.deformation,
@@ -15926,18 +16332,18 @@ var RenderFeatureComputeGraphProjection = class {
     const accesses = [];
     const targets = /* @__PURE__ */ new Map();
     for (const handle of work.sampledTargets ?? []) {
-      let target4 = this.resolveTarget?.(handle);
-      if (target4 === void 0)
+      let target5 = this.resolveTarget?.(handle);
+      if (target5 === void 0)
         return err$1(
           new RenderFeatureStageFailedError(featureIdentity, order, "record", "renderer-recover")
         );
       if (handle.kind === "scene-depth") {
-        const view = this.builder.view(target4.texture, { aspect: "depth-only" });
+        const view = this.builder.view(target5.texture, { aspect: "depth-only" });
         if (!view.ok) return view;
-        target4 = { ...target4, view: view.value };
+        target5 = { ...target5, view: view.value };
       }
-      targets.set(handle, target4);
-      accesses.push({ resource: target4.view, usage: "sampled-read" });
+      targets.set(handle, target5);
+      accesses.push({ resource: target5.view, usage: "sampled-read" });
     }
     for (const resource of work.buffers) {
       const imported = importRenderFeatureGraphBuffer(
@@ -15954,9 +16360,9 @@ var RenderFeatureComputeGraphProjection = class {
       encode: ({ pass, resources }) => {
         try {
           encodeRenderFeatureGpuComputePass(pass, work, (name2) => {
-            const target4 = targets.get(name2);
-            if (target4 === void 0) throw new Error(`Missing sampled graph target: ${name2}`);
-            const view = resources.textureView(target4.view);
+            const target5 = targets.get(name2);
+            if (target5 === void 0) throw new Error(`Missing sampled graph target: ${name2}`);
+            const view = resources.textureView(target5.view);
             if (!view.ok) throw view.error;
             return view.value;
           });
@@ -16076,15 +16482,15 @@ var RenderFeatureRasterGraphProjection = class {
       accesses.push(...this.standardSurfaceAccesses);
     const colors = [];
     for (const attachment of descriptor.attachments.colors) {
-      const target4 = this.resolveTarget(attachment.resource);
-      if (target4 === void 0) return err$1(missing(featureIdentity, order));
-      accesses.push({ resource: target4.view, usage: "color-attachment" });
-      if (target4.resolveTarget !== void 0) {
-        accesses.push({ resource: target4.resolveTarget, usage: "color-attachment" });
+      const target5 = this.resolveTarget(attachment.resource);
+      if (target5 === void 0) return err$1(missing(featureIdentity, order));
+      accesses.push({ resource: target5.view, usage: "color-attachment" });
+      if (target5.resolveTarget !== void 0) {
+        accesses.push({ resource: target5.resolveTarget, usage: "color-attachment" });
       }
       colors.push({
-        view: target4.view,
-        ...target4.resolveTarget === void 0 ? {} : { resolveTarget: target4.resolveTarget },
+        view: target5.view,
+        ...target5.resolveTarget === void 0 ? {} : { resolveTarget: target5.resolveTarget },
         loadOp: attachment.loadOp,
         storeOp: attachment.storeOp
       });
@@ -16092,17 +16498,17 @@ var RenderFeatureRasterGraphProjection = class {
     let depthStencilAttachment;
     const depth = descriptor.attachments.depthStencil;
     if (depth !== void 0) {
-      const target4 = this.resolveTarget(depth.resource);
-      if (target4 === void 0) return err$1(missing(featureIdentity, order));
+      const target5 = this.resolveTarget(depth.resource);
+      if (target5 === void 0) return err$1(missing(featureIdentity, order));
       const sampled = (descriptor.sampledTargets ?? []).some(
         (candidate) => typeof depth.resource !== "string" && candidate.kind === depth.resource.kind && candidate.format === depth.resource.format && candidate.sampleCount === depth.resource.sampleCount
       );
       accesses.push({
-        resource: target4.view,
+        resource: target5.view,
         usage: sampled ? "depth-stencil-read" : "depth-stencil-write"
       });
-      depthStencilAttachment = sampled ? { view: target4.view, depthReadOnly: true, stencilReadOnly: true } : {
-        view: target4.view,
+      depthStencilAttachment = sampled ? { view: target5.view, depthReadOnly: true, stencilReadOnly: true } : {
+        view: target5.view,
         depthLoadOp: depth.depthLoadOp,
         depthStoreOp: depth.depthStoreOp,
         stencilLoadOp: depth.depthLoadOp,
@@ -16110,9 +16516,9 @@ var RenderFeatureRasterGraphProjection = class {
       };
     }
     for (const sampled of descriptor.sampledTargets ?? []) {
-      const target4 = this.resolveTarget(sampled);
-      if (target4 === void 0) return err$1(missing(featureIdentity, order));
-      accesses.push({ resource: target4.view, usage: "sampled-read" });
+      const target5 = this.resolveTarget(sampled);
+      if (target5 === void 0) return err$1(missing(featureIdentity, order));
+      accesses.push({ resource: target5.view, usage: "sampled-read" });
     }
     const drawBuffers = this.importDrawBuffers(name, featureIdentity, order, descriptor, snapshot);
     if (!drawBuffers.ok) return drawBuffers;
@@ -17273,6 +17679,7 @@ function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lig
   );
   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;
   const preparedLut = frameState.pendingStandardLutGpuResources ?? frameState.standardLutGpuResources;
+  const depthOfField = depthOfFieldTopology(camera.depthOfField);
   return ok$1({
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: internals.standardProfile,
@@ -17291,7 +17698,8 @@ function topologyOf(internals, frameState, pipelineState, camera, clearOnly, lig
     camera: {
       tonemap: camera.tonemap,
       antialias: camera.antialias,
-      bloom: camera.bloom
+      bloom: camera.bloom,
+      ...depthOfField === void 0 ? {} : { depthOfField }
     },
     atmosphere: !clearOnly && frameState.environmentFrame?.source.kind === "atmosphere",
     output: {
@@ -17391,13 +17799,13 @@ function targetResolver(targets, semanticTargets = [], namedTargets = {}) {
       return semantic === void 0 ? void 0 : { texture: semantic.texture, view: semantic.view };
     }
     if (!isRenderFeatureTargetHandle(resource)) return void 0;
-    const target4 = targets.find(
+    const target5 = targets.find(
       (candidate) => candidate.kind === resource.kind && candidate.format === resource.format && candidate.sampleCount === resource.sampleCount
     );
-    return target4 === void 0 ? void 0 : {
-      texture: target4.texture,
-      view: target4.view,
-      ...target4.resolveTarget === void 0 ? {} : { resolveTarget: target4.resolveTarget }
+    return target5 === void 0 ? void 0 : {
+      texture: target5.texture,
+      view: target5.view,
+      ...target5.resolveTarget === void 0 ? {} : { resolveTarget: target5.resolveTarget }
     };
   };
 }
@@ -17452,9 +17860,9 @@ function resolveTargetBindings(input, featurePostProcessEntries) {
     ) ?? void 0;
   }
   if (sceneDepthBinding === 1) {
-    const target5 = sceneDepth === void 0 ? void 0 : input.resolveTarget(sceneDepth);
-    const depthView2 = target5 === void 0 ? frame.pipelineState.shadowFallbackTextureView : (() => {
-      const texture2 = input.resources.texture(target5.texture);
+    const target6 = sceneDepth === void 0 ? void 0 : input.resolveTarget(sceneDepth);
+    const depthView2 = target6 === void 0 ? frame.pipelineState.shadowFallbackTextureView : (() => {
+      const texture2 = input.resources.texture(target6.texture);
       if (!texture2.ok) throw texture2.error;
       const created3 = frame.runtime.device.createTextureView(texture2.value, {
         aspect: "depth-only",
@@ -17499,9 +17907,9 @@ function resolveTargetBindings(input, featurePostProcessEntries) {
     ).viewBindGroup;
     return viewBindGroup === null ? void 0 : { handle: viewBindGroup, dynamicOffsets: [0, 0] };
   }
-  const target4 = input.resolveTarget(sceneDepth);
-  if (target4 === void 0) return void 0;
-  const texture = input.resources.texture(target4.texture);
+  const target5 = input.resolveTarget(sceneDepth);
+  if (target5 === void 0) return void 0;
+  const texture = input.resources.texture(target5.texture);
   if (!texture.ok) throw texture.error;
   const depthView = frame.runtime.device.createTextureView(texture.value, {
     aspect: "depth-only",
@@ -17527,21 +17935,57 @@ function settleVolumetricFogGraphCandidate(frameState, submitted) {
   if (candidate === null) return;
   const previous = frameState.volumetricFogPreviousGraph ?? null;
   const previousKey = frameState.volumetricFogPreviousGraphKey ?? null;
+  const sharedWithDepthOfField = frameState.depthOfFieldCandidateGraph === candidate;
   if (submitted) {
-    if (previous !== null && previous !== candidate) retire(frameState, previous);
+    if (!sharedWithDepthOfField && previous !== null && previous !== candidate) {
+      retire(frameState, previous);
+    }
   } else {
-    if (candidate !== previous) retire(frameState, candidate);
-    frameState.compiledFrameGraph = previous;
-    frameState.compiledFrameGraphTopologyKey = previousKey;
+    if (!sharedWithDepthOfField) {
+      if (candidate !== previous) retire(frameState, candidate);
+      frameState.compiledFrameGraph = previous;
+      frameState.compiledFrameGraphTopologyKey = previousKey;
+    }
   }
   frameState.volumetricFogPreviousGraph = null;
   frameState.volumetricFogPreviousGraphKey = null;
   frameState.volumetricFogCandidateGraph = null;
 }
+function settleDepthOfFieldGraphCandidate(frameState, submitted) {
+  const candidate = frameState.depthOfFieldCandidateGraph;
+  if (candidate === null || candidate === void 0) return;
+  const previous = frameState.depthOfFieldPreviousGraph ?? null;
+  if (submitted) {
+    if (previous !== null && previous !== candidate) retire(frameState, previous);
+  } else {
+    if (candidate !== previous) retire(frameState, candidate);
+    frameState.compiledFrameGraph = previous;
+    frameState.compiledFrameGraphTopologyKey = frameState.depthOfFieldPreviousGraphKey ?? null;
+    if (frameState.depthOfFieldPreviousPerFrameGraph === void 0) {
+      delete frameState.perFrameGraph;
+    } else {
+      frameState.perFrameGraph = frameState.depthOfFieldPreviousPerFrameGraph;
+    }
+    frameState.graphGeneration = frameState.depthOfFieldPreviousGraphGeneration ?? 0;
+    frameState.standardLightingGraphSignature = frameState.depthOfFieldPreviousStandardLightingGraphSignature ?? "";
+  }
+  frameState.depthOfFieldPreviousGraph = null;
+  frameState.depthOfFieldPreviousGraphKey = null;
+  frameState.depthOfFieldPreviousPerFrameGraph = void 0;
+  frameState.depthOfFieldPreviousGraphGeneration = 0;
+  frameState.depthOfFieldPreviousStandardLightingGraphSignature = "";
+  frameState.depthOfFieldCandidateGraph = null;
+}
 function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera, lights, width, height, shadowMapSize, gpuDriven, featureGraphCandidate, cubeCaptureState, clearOnly = false, transmissionDemand, occlusion, volumetricFog, volumeTopologyCandidate = false, standardLighting, onRecoveryError, ssr, renderExtent) {
   const featureMetrics = mutableFeatureGraphInspection(internals);
   featureMetrics.ensureCalls += 1;
   const requestedStandardLightingSignature = standardLightingTopologySignature(standardLighting);
+  const frameDepthOfField = resolveDepthOfFieldFrameParams(
+    camera.depthOfField,
+    camera.depthOfFieldError,
+    frameState.depthOfFieldAccepted?.params
+  );
+  const graphCamera = frameDepthOfField === void 0 || frameDepthOfField === camera.depthOfField ? camera : { ...camera, depthOfField: frameDepthOfField };
   const lastKnownGood = () => frameState.compiledFrameGraph !== null && !hasSubmissionSensitiveFeatures(getRenderFeatureGraphState(internals).plans) && frameState.standardLightingGraphSignature === requestedStandardLightingSignature ? frameState.compiledFrameGraph : null;
   const surfaceWidth = Math.max(1, width);
   const surfaceHeight = Math.max(1, height);
@@ -17569,7 +18013,7 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     internals,
     frameState,
     pipelineState,
-    camera,
+    graphCamera,
     clearOnly,
     lights,
     surfaceWidth,
@@ -17737,6 +18181,7 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   const built = frameState.activePipeline.build(
     {
       graph: builder,
+      camera: { depthOfField: graphCamera.depthOfField },
       observationCaptureDomains: internals.observationCaptureDomains,
       ...autoExposureResources?.ok === true ? { standardOutput: { autoExposure: autoExposureResources.value } } : {},
       ...lutResources?.ok === true ? {
@@ -17763,14 +18208,14 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
         const encoded = encodeMipmapLevel(internals.device, pass, sourceView.value, "rgba16float");
         if (!encoded.ok) throw encoded.error;
       },
-      projectGpuDriven: (target4) => {
+      projectGpuDriven: (target5) => {
         if (projectedGpuDriven || gpuDriven === void 0) return ok$1(void 0);
         projectedGpuDriven = true;
         return gpuDriven.project(
           builder,
-          target4.format,
-          target4.sampleCount,
-          target4.additionalColorFormats
+          target5.format,
+          target5.sampleCount,
+          target5.additionalColorFormats
         );
       },
       ...gpuDriven?.projectShadow === void 0 ? {} : {
@@ -17850,10 +18295,26 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     return lastKnownGood();
   }
   const previous = frameState.compiledFrameGraph;
+  const depthOfFieldReplacement = (frameState.depthOfFieldCandidateGraph === null || frameState.depthOfFieldCandidateGraph === void 0) && (topologyResult.value.camera.depthOfField !== void 0 || frameState.depthOfFieldAccepted !== void 0);
   if (volumeTopologyCandidate) {
     frameState.volumetricFogPreviousGraph = previous;
     frameState.volumetricFogPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
     frameState.volumetricFogCandidateGraph = compiled.value;
+    if (depthOfFieldReplacement) {
+      frameState.depthOfFieldPreviousGraph = previous;
+      frameState.depthOfFieldPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+      frameState.depthOfFieldPreviousPerFrameGraph = frameState.perFrameGraph;
+      frameState.depthOfFieldPreviousGraphGeneration = frameState.graphGeneration;
+      frameState.depthOfFieldPreviousStandardLightingGraphSignature = frameState.standardLightingGraphSignature;
+      frameState.depthOfFieldCandidateGraph = compiled.value;
+    }
+  } else if (depthOfFieldReplacement) {
+    frameState.depthOfFieldPreviousGraph = previous;
+    frameState.depthOfFieldPreviousGraphKey = frameState.compiledFrameGraphTopologyKey;
+    frameState.depthOfFieldPreviousPerFrameGraph = frameState.perFrameGraph;
+    frameState.depthOfFieldPreviousGraphGeneration = frameState.graphGeneration;
+    frameState.depthOfFieldPreviousStandardLightingGraphSignature = frameState.standardLightingGraphSignature;
+    frameState.depthOfFieldCandidateGraph = compiled.value;
   }
   frameState.compiledFrameGraph = compiled.value;
   frameState.compiledFrameGraphTopologyKey = key;
@@ -17882,7 +18343,9 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
   } else if (featureGraphCandidate !== void 0) {
     recordRenderFeatureCandidateEvent(internals, featureGraphCandidate, "abandoned");
   }
-  if (!volumeTopologyCandidate && previous !== null) retire(frameState, previous);
+  if (!volumeTopologyCandidate && !depthOfFieldReplacement && previous !== null) {
+    retire(frameState, previous);
+  }
   return compiled.value;
 }
 function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPass, frameHooks, readbackFaces, onSubmitted, timingCapture) {
@@ -17899,6 +18362,7 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
     frameState.pendingAutoExposureState = void 0;
     frameState.pendingStandardLutState = void 0;
     settleVolumetricFogGraphCandidate(frameState, false);
+    settleDepthOfFieldGraphCandidate(frameState, false);
     rejectTemporalFrame();
     return false;
   }
@@ -17935,6 +18399,8 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
         }
       })
     );
+    settleVolumetricFogGraphCandidate(frameState, false);
+    settleDepthOfFieldGraphCandidate(frameState, false);
     return false;
   }
   const capturedGeneration = deviceScope?.generation;
@@ -18100,8 +18566,8 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
                 replayFailure(`pass-replay-depth-attachment-missing:${pass.name}`);
                 return;
               }
-              const target5 = replayTarget;
-              if (target5 === void 0 || depthView !== target5.view) {
+              const target6 = replayTarget;
+              if (target6 === void 0 || depthView !== target6.view) {
                 replayFailure(`pass-replay-attachment-target-mismatch:${pass.name}`);
                 return;
               }
@@ -18123,9 +18589,9 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
               encode();
               encoded2 = true;
               if (replayValidationFailed || pass.name !== observeAfterPassName) return;
-              const target5 = replayTarget;
+              const target6 = replayTarget;
               const anchor = depthAnchorReceipt;
-              if (target5 === void 0 || anchor === void 0) {
+              if (target6 === void 0 || anchor === void 0) {
                 replayFailure("pass-replay-depth-attachment-anchor-missing-at-boundary");
                 return;
               }
@@ -18133,11 +18599,11 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
                 passName: pass.name,
                 executionIndex: pass.executionIndex,
                 resolvedDepthStencilAttachmentView: anchor.view,
-                graphGeneration: target5.graphGeneration,
-                targetName: target5.name,
-                targetView: target5.view,
-                targetTexture: target5.texture,
-                targetTextureIdentity: target5.textureIdentity,
+                graphGeneration: target6.graphGeneration,
+                targetName: target6.name,
+                targetView: target6.view,
+                targetTexture: target6.texture,
+                targetTextureIdentity: target6.textureIdentity,
                 replayPassNames: [...selectedReplayPassNames],
                 depthAttachmentPassName: anchor.pass.name,
                 observeAfterPassName: pass.name,
@@ -18164,12 +18630,12 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
             else runPass(pass, encode);
             return;
           }
-          const target4 = replayTarget;
-          if (target4 === void 0 || depthView === void 0) {
+          const target5 = replayTarget;
+          if (target5 === void 0 || depthView === void 0) {
             replayFailure(`pass-replay-depth-attachment-missing:${pass.name}`);
             return;
           }
-          if (depthView !== target4.view) {
+          if (depthView !== target5.view) {
             replayFailure(`pass-replay-attachment-target-mismatch:${pass.name}`);
             return;
           }
@@ -18186,11 +18652,11 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
               passName: pass.name,
               executionIndex: pass.executionIndex,
               resolvedDepthStencilAttachmentView: depthView,
-              graphGeneration: target4.graphGeneration,
-              targetName: target4.name,
-              targetView: target4.view,
-              targetTexture: target4.texture,
-              targetTextureIdentity: target4.textureIdentity
+              graphGeneration: target5.graphGeneration,
+              targetName: target5.name,
+              targetView: target5.view,
+              targetTexture: target5.texture,
+              targetTextureIdentity: target5.textureIdentity
             };
             try {
               onPassEncoded(receipt);
@@ -18547,6 +19013,8 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
       frameState.pendingAtmospherePublish?.();
       frameState.pendingAtmospherePublish = void 0;
       onSubmitted?.(internals.device.queue.onSubmittedWorkDone());
+      settleVolumetricFogGraphCandidate(frameState, true);
+      settleDepthOfFieldGraphCandidate(frameState, true);
     },
     abort: (failure5) => {
       frameState.pendingAtmospherePublish = void 0;
@@ -18585,9 +19053,12 @@ function executeCompiledFrameGraph(internals, frameState, frame, encoder, runPas
         frameState.environmentLifecycle?.discard(frameState.environmentGeneration);
         frameState.environmentGeneration = void 0;
       }
+      settleVolumetricFogGraphCandidate(frameState, false);
+      settleDepthOfFieldGraphCandidate(frameState, false);
     }
   });
   settleVolumetricFogGraphCandidate(frameState, transaction.ok);
+  settleDepthOfFieldGraphCandidate(frameState, transaction.ok);
   if (!transaction.ok) rejectTemporalFrame();
   return transaction.ok;
 }
@@ -18733,12 +19204,12 @@ function gpuDrivenRenderableConsumed(entry, drawKeys) {
     );
   });
 }
-function projectValidatedRows(validated, target4) {
+function projectValidatedRows(validated, target5) {
   const byIdentity = /* @__PURE__ */ new Map();
   for (const row of validated) byIdentity.set(renderableIdentity(row.source), row);
   const projected = [];
-  for (let index = 0; index < target4.length; index += 1) {
-    const snapshot = target4[index];
+  for (let index = 0; index < target5.length; index += 1) {
+    const snapshot = target5[index];
     if (snapshot === void 0) continue;
     const row = byIdentity.get(renderableIdentity(snapshot));
     if (row === void 0) continue;
@@ -19639,8 +20110,14 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
         })
       );
     }
-    const camera = activeCameras[0];
-    if (!camera) return false;
+    const requestedCamera = activeCameras[0];
+    if (!requestedCamera) return false;
+    const frameDepthOfField = resolveDepthOfFieldFrameParams(
+      requestedCamera.depthOfField,
+      requestedCamera.depthOfFieldError,
+      frameState.depthOfFieldAccepted?.params
+    );
+    const camera = frameDepthOfField === void 0 || frameDepthOfField === requestedCamera.depthOfField ? requestedCamera : { ...requestedCamera, depthOfField: frameDepthOfField };
     frameState.ssrRequested = camera.screenSpaceReflection !== void 0;
     const pipelineState = internals.getPipelineState();
     if (pipelineState === null) return false;
@@ -20291,6 +20768,20 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       motionBlurView.setUint32(12, temporalView?.historyValid === true ? 0 : 1, true);
       framePostProcessParams.set("forgeax.motion-blur", motionBlurParams);
     }
+    if (camera.depthOfField !== void 0) {
+      const dofParams = packDepthOfFieldParams(camera.depthOfField, {
+        outputHeight: targetH,
+        near: camera.near,
+        far: camera.far,
+        useTemporalDepth: camera.antialias === "taa" && temporalView !== void 0
+      });
+      for (const id of [
+        ...DEPTH_OF_FIELD_POST_PROCESS_IDS,
+        ...DEPTH_OF_FIELD_MSAA_POST_PROCESS_IDS
+      ]) {
+        framePostProcessParams.set(id, dofParams);
+      }
+    }
     const passCtx = {
       assets: internals.assets,
       world,
@@ -20516,6 +21007,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       frameState.ssrHistoryCandidate = void 0;
     }
     settleVolumetricFogGraphCandidate(frameState, submitted);
+    settleDepthOfFieldGraphCandidate(frameState, submitted);
     if (volumeInspectionReady && (submitted || volumeSubmissionAttempted)) {
       updateVolumetricFogInspection(
         frameState,
@@ -21561,6 +22053,12 @@ function createRenderSystemRecovery(deps) {
       directionalShadowCacheRecorded: false,
       compiledFrameGraph: null,
       compiledFrameGraphTopologyKey: null,
+      depthOfFieldPreviousGraph: null,
+      depthOfFieldPreviousGraphKey: null,
+      depthOfFieldPreviousPerFrameGraph: void 0,
+      depthOfFieldPreviousGraphGeneration: 0,
+      depthOfFieldPreviousStandardLightingGraphSignature: "",
+      depthOfFieldCandidateGraph: null,
       volumetricFogPreviousGraph: null,
       volumetricFogPreviousGraphKey: null,
       volumetricFogCandidateGraph: null,
@@ -23392,17 +23890,17 @@ function createCubeCaptureScheduler(options = {}) {
   const states = /* @__PURE__ */ new WeakMap();
   let activeCapture;
   let frameOpen = false;
-  const stateFor = (target4) => {
-    const existing = states.get(target4);
+  const stateFor = (target5) => {
+    const existing = states.get(target5);
     if (existing !== void 0) return existing;
     const created = {
-      target: target4,
+      target: target5,
       activeGeneration: 0,
       completedVersion: 0,
       pending: void 0,
       nestedRejections: 0
     };
-    states.set(target4, created);
+    states.set(target5, created);
     return created;
   };
   return {
@@ -23481,8 +23979,8 @@ function createCubeCaptureScheduler(options = {}) {
         });
       return { ok: true, value: void 0 };
     },
-    inspect(target4) {
-      const state = stateFor(target4);
+    inspect(target5) {
+      const state = stateFor(target5);
       const pending = state.pending;
       const pendingFaces = pending === void 0 ? [] : pending.views.filter(
         (view) => !pending.written.has(view.face) && !pending.inFlight.some((work) => work.face === view.face)
@@ -25365,12 +25863,12 @@ function ownPointsLinesSnapshot(snapshot) {
 function intersects(left, right) {
   return left.min[0] <= right.max[0] && left.max[0] >= right.min[0] && left.min[1] <= right.max[1] && left.max[1] >= right.min[1] && left.min[2] <= right.max[2] && left.max[2] >= right.min[2];
 }
-function worldBounds(snapshot, target4) {
+function worldBounds(snapshot, target5) {
   const local = snapshot.localAabb;
   if (local === void 0 || local.length < 6) return void 0;
   const world = snapshot.transform.world;
-  const min = target4?.min ?? [0, 0, 0];
-  const max = target4?.max ?? [0, 0, 0];
+  const min = target5?.min ?? [0, 0, 0];
+  const max = target5?.max ?? [0, 0, 0];
   const centerX = ((local[0] ?? 0) + (local[3] ?? 0)) * 0.5;
   const centerY = ((local[1] ?? 0) + (local[4] ?? 0)) * 0.5;
   const centerZ = ((local[2] ?? 0) + (local[5] ?? 0)) * 0.5;
@@ -25389,7 +25887,7 @@ function worldBounds(snapshot, target4) {
   max[0] = worldCenterX + worldExtentX;
   max[1] = worldCenterY + worldExtentY;
   max[2] = worldCenterZ + worldExtentZ;
-  return target4 ?? { min, max };
+  return target5 ?? { min, max };
 }
 function boundsFromArray(bounds) {
   if (bounds.length < 6) return void 0;
@@ -25472,12 +25970,12 @@ var RenderScene = class {
       return pending;
     };
     const updateWorld = (pending, source, offset2) => {
-      const target4 = pending.current?.transform.world;
-      if (target4 === void 0) return;
+      const target5 = pending.current?.transform.world;
+      if (target5 === void 0) return;
       for (let lane = 0; lane < 16; lane += 1) {
         const value = source[offset2 + lane] ?? 0;
-        if (target4[lane] !== value) {
-          target4[lane] = value;
+        if (target5[lane] !== value) {
+          target5[lane] = value;
           pending.transformChanged = true;
         }
       }
@@ -25869,11 +26367,11 @@ var RenderScene = class {
     if (orderIndex >= 0) this.orderedSlots.splice(orderIndex, 1);
     this.freeSlots.push(record.slot);
   }
-  addSharedRefConsumers(worldId, handle, target4) {
+  addSharedRefConsumers(worldId, handle, target5) {
     for (const index of [this.slotsByAsset, this.slotsByMaterial]) {
       for (const slot of index.get(handle) ?? []) {
         const record = this.slots[slot];
-        if (record?.worldId === worldId) target4.add(record.entityKey);
+        if (record?.worldId === worldId) target5.add(record.entityKey);
       }
     }
   }
@@ -28193,6 +28691,14 @@ function createRenderSystem(internals) {
     compiledFrameGraph: null,
     compiledFrameGraphTopologyKey: null,
     compiledFrameGraphGeneration: 0,
+    depthOfFieldPreviousGraph: null,
+    depthOfFieldPreviousGraphKey: null,
+    depthOfFieldPreviousPerFrameGraph: void 0,
+    depthOfFieldPreviousGraphGeneration: 0,
+    depthOfFieldPreviousStandardLightingGraphSignature: "",
+    depthOfFieldCandidateGraph: null,
+    depthOfFieldAccepted: void 0,
+    depthOfFieldLastSubmitFailed: false,
     volumetricFogPreviousGraph: null,
     volumetricFogPreviousGraphKey: null,
     volumetricFogCandidateGraph: null,
@@ -29021,8 +29527,8 @@ function createRenderSystem(internals) {
     get reflectionFallbackCompletion() {
       return frameState.reflectionFallbackCompletion;
     },
-    isCubeCapturePending(target4) {
-      return cubeCaptureScheduler.inspect(target4).candidateGeneration !== void 0;
+    isCubeCapturePending(target5) {
+      return cubeCaptureScheduler.inspect(target5).candidateGeneration !== void 0;
     },
     get environment() {
       return environmentLifecycle.inspect();
@@ -29073,17 +29579,37 @@ function createRenderSystem(internals) {
         ...unavailable3 ? { lastFailure: "scene-data-unavailable" } : {}
       };
     },
+    get depthOfFieldInspection() {
+      const camera = latestCamera;
+      if (camera === void 0) return void 0;
+      const graph = frameState.compiledFrameGraph?.inspect();
+      return projectDepthOfFieldInspection({
+        ...camera.depthOfField === void 0 ? {} : { params: camera.depthOfField },
+        ...camera.depthOfFieldError === void 0 ? {} : { error: camera.depthOfFieldError },
+        ...graph === void 0 ? {} : { graph },
+        // The explicit property keeps the inspector on the submit-bound
+        // transaction path even before the first accepted frame. A missing
+        // property remains supported for direct structural callers/tests.
+        accepted: frameState.depthOfFieldAccepted,
+        ...frameState.depthOfFieldLastSubmitFailed === true ? { lastSubmitFailed: true } : {},
+        // Inspection can be queried while the renderer is being assembled,
+        // before a device scope has been published. Keep that observation
+        // bounded instead of turning a not-yet-ready renderer into a getter
+        // exception.
+        deviceGeneration: internals.deviceScope?.generation ?? 0
+      });
+    },
     get temporalTargetInspection() {
       const graph = frameState.compiledFrameGraph?.inspect();
       if (graph === void 0) return void 0;
       const producer = graph.passes.find((pass) => pass.name === "standard-scene-data");
-      const target4 = graph.resources.find(
+      const target5 = graph.resources.find(
         (resource) => resource.kind === "texture" && resource.label === "standard-scene-temporal"
       );
-      if (producer === void 0 || target4 === void 0) {
+      if (producer === void 0 || target5 === void 0) {
         return void 0;
       }
-      const descriptor = target4.descriptor.kind === "texture" ? target4.descriptor : void 0;
+      const descriptor = target5.descriptor.kind === "texture" ? target5.descriptor : void 0;
       const width = descriptor?.width ?? Math.max(1, internals.canvas.width);
       const height = descriptor?.height ?? Math.max(1, internals.canvas.height);
       return Object.freeze({
@@ -29580,6 +30106,7 @@ function createRenderSystem(internals) {
             const materialWorld = preparedWorlds[renderable.worldId];
             return projectMeshMaterialBindingObservation({
               worldId: renderable.worldId,
+              ...materialWorld === void 0 ? {} : { worldIdentity: materialWorld.identity },
               entityKey: renderable.entityKey,
               bindings: renderable.materials.map((material, slotIndex) => ({
                 handle: material.materialHandle ?? 0,
@@ -29885,6 +30412,26 @@ function createRenderSystem(internals) {
             internals.errorRegistry.fire(temporalCommit.error);
           }
           frameState.lastSuccessfulCameraAntialias = cameras[0]?.antialias;
+          const submittedCamera = cameras[0];
+          const submittedDepthOfField = submittedCamera === void 0 ? void 0 : resolveDepthOfFieldFrameParams(
+            submittedCamera.depthOfField,
+            submittedCamera.depthOfFieldError,
+            frameState.depthOfFieldAccepted?.params
+          );
+          const submittedDepthOfFieldGraph = frameState.compiledFrameGraph?.inspect();
+          if (submittedDepthOfField !== void 0 && submittedDepthOfFieldGraph !== void 0) {
+            frameState.depthOfFieldAccepted = {
+              params: submittedDepthOfField,
+              graph: submittedDepthOfFieldGraph,
+              deviceGeneration: internals.deviceScope.generation
+            };
+            frameState.depthOfFieldLastSubmitFailed = false;
+          } else if (submittedDepthOfField === void 0) {
+            frameState.depthOfFieldAccepted = void 0;
+            frameState.depthOfFieldLastSubmitFailed = false;
+          } else {
+            frameState.depthOfFieldLastSubmitFailed = true;
+          }
           internals.getPipelineState()?.perPassResources.commitBloomResources?.();
           const nextBloom = cameras[0]?.bloom ?? "off";
           if (frameState.lastSuccessfulBloom === "on" && nextBloom !== "on") {
@@ -29894,6 +30441,9 @@ function createRenderSystem(internals) {
           }
           frameState.lastSuccessfulBloom = nextBloom;
         } else {
+          if (cameras[0]?.depthOfField !== void 0) {
+            frameState.depthOfFieldLastSubmitFailed = true;
+          }
           internals.getPipelineState()?.perPassResources.discardBloomResources?.();
         }
         if (!submitted && frameState.environmentGeneration !== void 0) {
@@ -29917,20 +30467,20 @@ function createRenderSystem(internals) {
             if (!retired.ok) internals.errorRegistry.fire(retired.error);
           }
         }
-      } catch (err53) {
+      } catch (err54) {
         discardLiveFeatureState();
         if (!submitted) {
           internals.getPipelineState()?.perPassResources.discardBloomResources?.();
         }
-        const innerError = err53 instanceof PipelineSpecError ? {
-          name: err53.name,
-          code: err53.code,
-          message: err53.message,
-          detail: err53.detail
-        } : err53 instanceof RhiError ? err53 : {
+        const innerError = err54 instanceof PipelineSpecError ? {
+          name: err54.name,
+          code: err54.code,
+          message: err54.message,
+          detail: err54.detail
+        } : err54 instanceof RhiError ? err54 : {
           code: "unknown",
-          message: String(err53),
-          name: err53?.name
+          message: String(err54),
+          name: err54?.name
         };
         internals.errorRegistry.fire(
           new RhiError({
@@ -30207,6 +30757,7 @@ function createRenderSystem(internals) {
       frameState.volumetricFogHistorySlot = null;
       frameState.volumetricFogHistorySignature = null;
       frameState.hdrpClusterMembership = null;
+      settleDepthOfFieldGraphCandidate(frameState, false);
       const compiled = frameState.compiledFrameGraph;
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
@@ -30214,6 +30765,14 @@ function createRenderSystem(internals) {
       frameState.standardLightingGraphSignature = "";
       frameState.standardLightingInspection = void 0;
       frameState.pointShadowInspection = void 0;
+      frameState.depthOfFieldPreviousGraph = null;
+      frameState.depthOfFieldPreviousGraphKey = null;
+      frameState.depthOfFieldPreviousPerFrameGraph = void 0;
+      frameState.depthOfFieldPreviousGraphGeneration = 0;
+      frameState.depthOfFieldPreviousStandardLightingGraphSignature = "";
+      frameState.depthOfFieldCandidateGraph = null;
+      frameState.depthOfFieldAccepted = void 0;
+      frameState.depthOfFieldLastSubmitFailed = false;
       if (compiled !== null) compiled.retire().catch(() => void 0);
       for (const retired of frameState.retiredCompiledFrameGraphs) {
         retired.retire().catch(() => void 0);
@@ -30283,12 +30842,19 @@ function createRenderSystem(internals) {
       frameState.ssrLastHistoryVersion = void 0;
       (retiringPipelineState ?? internals.getPipelineState())?.perPassResources.drainBloomResources?.();
       settleVolumetricFogGraphCandidate(frameState, false);
+      settleDepthOfFieldGraphCandidate(frameState, false);
       frameState.compiledFrameGraph?.retire().catch(() => void 0);
       frameState.compiledFrameGraph = null;
       frameState.compiledFrameGraphTopologyKey = null;
       frameState.volumetricFogPreviousGraph = null;
       frameState.volumetricFogPreviousGraphKey = null;
       frameState.volumetricFogCandidateGraph = null;
+      frameState.depthOfFieldPreviousGraph = null;
+      frameState.depthOfFieldPreviousGraphKey = null;
+      frameState.depthOfFieldPreviousPerFrameGraph = void 0;
+      frameState.depthOfFieldPreviousGraphGeneration = 0;
+      frameState.depthOfFieldPreviousStandardLightingGraphSignature = "";
+      frameState.depthOfFieldCandidateGraph = null;
       frameState.volumetricFogAccepted = void 0;
       frameState.volumetricFogAcceptedContext = void 0;
       frameState.volumetricFogHistoryGraph = null;
@@ -30303,6 +30869,8 @@ function createRenderSystem(internals) {
       frameState.standardLightingGraphSignature = "";
       frameState.standardLightingInspection = void 0;
       frameState.pointShadowInspection = void 0;
+      frameState.depthOfFieldAccepted = void 0;
+      frameState.depthOfFieldLastSubmitFailed = false;
       frameState.directionalShadowCache = null;
       frameState.directionalShadowCacheRecorded = false;
       frameState.currentFrameObservationSource = void 0;
@@ -32923,7 +33491,7 @@ async function probeCandidateDeviceExecution(device) {
   }
   return outcome;
 }
-async function probeCandidateGraphTarget(device, target4, encode) {
+async function probeCandidateGraphTarget(device, target5, encode) {
   let readback;
   let mapped;
   let outcome = err(
@@ -32969,7 +33537,7 @@ async function probeCandidateGraphTarget(device, target4, encode) {
         label: "renderer-recovery-graph-probe.pass",
         colorAttachments: [
           {
-            view: target4.view,
+            view: target5.view,
             loadOp: "clear",
             storeOp: "store",
             clearValue: {
@@ -32995,7 +33563,7 @@ async function probeCandidateGraphTarget(device, target4, encode) {
       return outcome;
     }
     encoder.copyTextureToBuffer(
-      { texture: target4.texture },
+      { texture: target5.texture },
       {
         buffer: readback,
         bytesPerRow: PROBE_READBACK_BYTES_PER_ROW,
@@ -33038,7 +33606,7 @@ async function probeCandidateGraphTarget(device, target4, encode) {
       return outcome;
     }
     mapped = mappedResult.value;
-    const rangeResult = mapped.getMappedRange(0, target4.format === "rgba16float" ? 8 : 4);
+    const rangeResult = mapped.getMappedRange(0, target5.format === "rgba16float" ? 8 : 4);
     if (!rangeResult.ok) {
       outcome = err(
         recoveryDeviceProbeFailure(
@@ -33050,8 +33618,8 @@ async function probeCandidateGraphTarget(device, target4, encode) {
       return outcome;
     }
     const view = new DataView(rangeResult.value);
-    const actual = target4.format === "rgba16float" ? [0, 1, 2, 3].map((channel) => halfToFloat(view.getUint16(channel * 2, true))) : [0, 1, 2, 3].map((channel) => (view.getUint8(channel) ?? 0) / 255);
-    const epsilon = target4.format === "rgba16float" ? 0.02 : 2 / 255;
+    const actual = target5.format === "rgba16float" ? [0, 1, 2, 3].map((channel) => halfToFloat(view.getUint16(channel * 2, true))) : [0, 1, 2, 3].map((channel) => (view.getUint8(channel) ?? 0) / 255);
+    const epsilon = target5.format === "rgba16float" ? 0.02 : 2 / 255;
     if (!actual.every((value, index) => Math.abs(value - (PROBE_CLEAR[index] ?? 0)) <= epsilon)) {
       outcome = err(
         recoveryDeviceProbeFailure(
@@ -33091,18 +33659,18 @@ async function probeCandidateGraphTarget(device, target4, encode) {
   }
   return outcome;
 }
-async function probeCandidateGraphExecution(device, target4) {
+async function probeCandidateGraphExecution(device, target5) {
   if (device.caps.backendKind === "null") return ok$1(void 0);
   const builder = new RenderGraphBuilder();
   const texture = builder.importTexture(
     "renderer-recovery-graph-execution-probe.texture",
     {
-      format: target4.format,
+      format: target5.format,
       size: { width: 1, height: 1 },
       usage: PROBE_TEXTURE_USAGE_RENDER_ATTACHMENT | PROBE_TEXTURE_USAGE_COPY_SRC,
       dimension: "2d"
     },
-    () => target4.texture
+    () => target5.texture
   );
   if (!texture.ok) {
     return err(
@@ -33116,7 +33684,7 @@ async function probeCandidateGraphExecution(device, target4) {
   const view = builder.importView(
     texture.value,
     { label: "renderer-recovery-graph-execution-probe.view", dimension: "2d" },
-    () => target4.view
+    () => target5.view
   );
   if (!view.ok) {
     return err(
@@ -33164,7 +33732,7 @@ async function probeCandidateGraphExecution(device, target4) {
     );
   }
   try {
-    return await probeCandidateGraphTarget(device, target4, (encoder) => {
+    return await probeCandidateGraphTarget(device, target5, (encoder) => {
       const executed = compiled.value.execute({ encoder });
       return executed.ok ? ok$1(void 0) : err(
         recoveryDeviceProbeFailure(
@@ -34037,8 +34605,8 @@ function token() {
 }
 function createRenderTargetOwner(options) {
   const targets = /* @__PURE__ */ new WeakMap();
-  const requireTarget = (target4, operation) => {
-    const state = targets.get(target4);
+  const requireTarget = (target5, operation) => {
+    const state = targets.get(target5);
     if (state === void 0) return invalid5(operation, "foreign-renderer", "destroyed", 0);
     if (state.rendererId !== options.rendererId) {
       return invalid5(operation, "foreign-renderer", state.state, state.generation);
@@ -34050,9 +34618,9 @@ function createRenderTargetOwner(options) {
   };
   return {
     create(descriptor) {
-      const target4 = token();
-      targets.set(target4, {
-        target: target4,
+      const target5 = token();
+      targets.set(target5, {
+        target: target5,
         rendererId: options.rendererId,
         state: "uninitialized",
         generation: 0,
@@ -34060,10 +34628,10 @@ function createRenderTargetOwner(options) {
         candidate: void 0,
         retiredGenerations: /* @__PURE__ */ new Set()
       });
-      return { ok: true, value: target4 };
+      return { ok: true, value: target5 };
     },
-    stage(target4, descriptor) {
-      const found = requireTarget(target4, "resize");
+    stage(target5, descriptor) {
+      const found = requireTarget(target5, "resize");
       if (!found.ok) return found;
       const state = found.value;
       if (state.state === "rebuilding") {
@@ -34077,8 +34645,8 @@ function createRenderTargetOwner(options) {
       state.state = "candidate";
       return { ok: true, value: candidate };
     },
-    promote(target4, generation) {
-      const found = requireTarget(target4, "resize");
+    promote(target5, generation) {
+      const found = requireTarget(target5, "resize");
       if (!found.ok) return found;
       const state = found.value;
       if (state.candidate?.generation !== generation) {
@@ -34090,8 +34658,8 @@ function createRenderTargetOwner(options) {
       state.state = "active";
       return { ok: true, value: void 0 };
     },
-    rejectCandidate(target4, generation, stage) {
-      const found = requireTarget(target4, "resize");
+    rejectCandidate(target5, generation, stage) {
+      const found = requireTarget(target5, "resize");
       if (!found.ok) return found;
       const state = found.value;
       if (state.candidate?.generation !== generation) {
@@ -34110,8 +34678,8 @@ function createRenderTargetOwner(options) {
         })
       };
     },
-    beginRecovery(target4, generation) {
-      const found = requireTarget(target4, "resize");
+    beginRecovery(target5, generation) {
+      const found = requireTarget(target5, "resize");
       if (!found.ok) return found;
       const state = found.value;
       if (state.state !== "active" || generation <= state.generation) {
@@ -34122,8 +34690,8 @@ function createRenderTargetOwner(options) {
       state.state = "rebuilding";
       return { ok: true, value: void 0 };
     },
-    finishRecovery(target4) {
-      const found = requireTarget(target4, "resize");
+    finishRecovery(target5) {
+      const found = requireTarget(target5, "resize");
       if (!found.ok) return found;
       const state = found.value;
       if (state.state !== "rebuilding") {
@@ -34132,14 +34700,14 @@ function createRenderTargetOwner(options) {
       state.state = "uninitialized";
       return { ok: true, value: void 0 };
     },
-    retire(target4, generation) {
-      const found = requireTarget(target4, "destroy");
+    retire(target5, generation) {
+      const found = requireTarget(target5, "destroy");
       if (!found.ok) return found;
       found.value.retiredGenerations.add(generation);
       return { ok: true, value: void 0 };
     },
-    destroy(target4) {
-      const state = targets.get(target4);
+    destroy(target5) {
+      const state = targets.get(target5);
       if (state === void 0) return invalid5("destroy", "foreign-renderer", "destroyed", 0);
       if (state.rendererId !== options.rendererId) {
         return invalid5("destroy", "foreign-renderer", state.state, state.generation);
@@ -34149,8 +34717,8 @@ function createRenderTargetOwner(options) {
       state.state = "destroyed";
       return { ok: true, value: void 0 };
     },
-    inspect(target4) {
-      const found = requireTarget(target4, "inspect");
+    inspect(target5) {
+      const found = requireTarget(target5, "inspect");
       if (!found.ok) return found;
       const state = found.value;
       return {
@@ -34188,7 +34756,7 @@ function bindRenderTargetReadbackTicket(ticket, receipt) {
   ticket.deviceGeneration = receipt.deviceGeneration;
   return { ok: true, value: void 0 };
 }
-function createRenderTargetReadbackTicket(target4, input) {
+function createRenderTargetReadbackTicket(target5, input) {
   if (input.frameId !== void 0 && (!Number.isInteger(input.frameId) || input.frameId < 0) || !Number.isInteger(input.deviceGeneration) || input.deviceGeneration < 0 || !Number.isInteger(input.mipLevel) || input.mipLevel < 0 || !Number.isInteger(input.width) || input.width < 1 || !Number.isInteger(input.height) || input.height < 1 || !Number.isInteger(input.bytesPerPixel) || input.bytesPerPixel < 1) {
     return {
       ok: false,
@@ -34206,7 +34774,7 @@ function createRenderTargetReadbackTicket(target4, input) {
   return {
     ok: true,
     value: {
-      target: target4,
+      target: target5,
       frameId: input.frameId,
       deviceGeneration: input.deviceGeneration,
       mipLevel: input.mipLevel,
@@ -34502,12 +35070,12 @@ function createRenderTargetHost(options = {}) {
   const readbacks = /* @__PURE__ */ new WeakMap();
   const readbackRecords = /* @__PURE__ */ new Set();
   const currentGeneration = () => options.getGeneration?.() ?? options.initialGeneration ?? 0;
-  const stagePhysical = (target4, descriptor) => {
-    const stagedTarget = owner.stage(target4, descriptor);
+  const stagePhysical = (target5, descriptor) => {
+    const stagedTarget = owner.stage(target5, descriptor);
     if (!stagedTarget.ok) return stagedTarget;
     const device = options.getDevice?.();
     if (device === void 0) {
-      staged.add(target4);
+      staged.add(target5);
       return { ok: true, value: void 0 };
     }
     const physical = makePhysical(
@@ -34516,11 +35084,11 @@ function createRenderTargetHost(options = {}) {
       stagedTarget.value.generation
     );
     if (!physical.ok) {
-      owner.rejectCandidate(target4, stagedTarget.value.generation, "allocation");
+      owner.rejectCandidate(target5, stagedTarget.value.generation, "allocation");
       return physical;
     }
-    candidatePhysical.set(target4, physical.value);
-    staged.add(target4);
+    candidatePhysical.set(target5, physical.value);
+    staged.add(target5);
     return { ok: true, value: void 0 };
   };
   return Object.freeze({
@@ -34543,13 +35111,13 @@ function createRenderTargetHost(options = {}) {
       if (created.ok) targets.add(created.value);
       return created;
     },
-    resizeRenderTarget(target4, descriptor) {
+    resizeRenderTarget(target5, descriptor) {
       const admitted = admitRenderTargetDescriptor(descriptor, limits);
       if (!admitted.ok) return admitted;
-      return stagePhysical(target4, admitted.value);
+      return stagePhysical(target5, admitted.value);
     },
-    createRenderTargetTextureSource(target4, sourceOptions) {
-      const inspected = owner.inspect(target4);
+    createRenderTargetTextureSource(target5, sourceOptions) {
+      const inspected = owner.inspect(target5);
       if (!inspected.ok) return inspected;
       if (!inspected.value.descriptor.sampled) {
         return {
@@ -34582,7 +35150,7 @@ function createRenderTargetHost(options = {}) {
           })
         };
       }
-      const binding = createRenderTargetMaterialSource(target4, inspected.value.descriptor, {
+      const binding = createRenderTargetMaterialSource(target5, inspected.value.descriptor, {
         ...sourceOptions,
         generation: inspected.value.generation
       });
@@ -34599,8 +35167,8 @@ function createRenderTargetHost(options = {}) {
       if (binding.generation !== physical.generation) return binding;
       return { ...binding, textureView: view };
     },
-    requestTargetReadback(target4, request) {
-      const inspected = owner.inspect(target4);
+    requestTargetReadback(target5, request) {
+      const inspected = owner.inspect(target5);
       if (!inspected.ok) return inspected;
       if (!inspected.value.descriptor.readback) {
         return {
@@ -34668,7 +35236,7 @@ function createRenderTargetHost(options = {}) {
           })
         };
       }
-      const internalTicket = createRenderTargetReadbackTicket(target4, {
+      const internalTicket = createRenderTargetReadbackTicket(target5, {
         deviceGeneration: inspected.value.generation,
         mipLevel: request.mipLevel,
         ...request.face === void 0 ? {} : { face: request.face },
@@ -34678,7 +35246,7 @@ function createRenderTargetHost(options = {}) {
       });
       if (!internalTicket.ok) return internalTicket;
       const record = {
-        target: target4,
+        target: target5,
         request,
         ticket: internalTicket.value,
         ...buffer === void 0 ? {} : { buffer: buffer.value },
@@ -34775,31 +35343,31 @@ function createRenderTargetHost(options = {}) {
       }
       return { ok: true, value: Object.freeze(results) };
     },
-    destroyRenderTarget(target4) {
-      const destroyed = owner.destroy(target4);
+    destroyRenderTarget(target5) {
+      const destroyed = owner.destroy(target5);
       if (destroyed.ok) {
-        destroyPhysical(options.getDevice?.(), activePhysical.get(target4));
-        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target4));
-        activePhysical.delete(target4);
-        candidatePhysical.delete(target4);
+        destroyPhysical(options.getDevice?.(), activePhysical.get(target5));
+        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target5));
+        activePhysical.delete(target5);
+        candidatePhysical.delete(target5);
         for (const record of readbackRecords) {
-          if (record.target !== target4) continue;
+          if (record.target !== target5) continue;
           if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
           readbacks.delete(record.ticket);
           readbackRecords.delete(record);
         }
-        targets.delete(target4);
+        targets.delete(target5);
       }
       return destroyed;
     },
     beginFrame() {
       if (disposed) return;
-      for (const target4 of targets) {
-        const inspected = owner.inspect(target4);
+      for (const target5 of targets) {
+        const inspected = owner.inspect(target5);
         if (!inspected.ok || inspected.value.state === "active" || inspected.value.state === "candidate") {
           continue;
         }
-        stagePhysical(target4);
+        stagePhysical(target5);
       }
     },
     onFrameSubmitted(completed = Promise.resolve({ ok: true, value: void 0 })) {
@@ -34807,40 +35375,40 @@ function createRenderTargetHost(options = {}) {
       const submittedTargets = [...staged];
       staged.clear();
       void completed.then((result) => {
-        for (const target4 of submittedTargets) {
-          const candidate = owner.inspect(target4);
+        for (const target5 of submittedTargets) {
+          const candidate = owner.inspect(target5);
           if (!candidate.ok || candidate.value.candidate === void 0) continue;
           if (!result.ok) {
-            owner.rejectCandidate(target4, candidate.value.candidate.generation, "submit");
-            destroyPhysical(options.getDevice?.(), candidatePhysical.get(target4));
-            candidatePhysical.delete(target4);
+            owner.rejectCandidate(target5, candidate.value.candidate.generation, "submit");
+            destroyPhysical(options.getDevice?.(), candidatePhysical.get(target5));
+            candidatePhysical.delete(target5);
             continue;
           }
-          if (options.canPromoteTarget?.(target4) === false) {
-            staged.add(target4);
+          if (options.canPromoteTarget?.(target5) === false) {
+            staged.add(target5);
             continue;
           }
           const generation = candidate.value.candidate.generation;
-          const physical = candidatePhysical.get(target4);
+          const physical = candidatePhysical.get(target5);
           if (physical === void 0) {
-            owner.rejectCandidate(target4, generation, "submit");
+            owner.rejectCandidate(target5, generation, "submit");
             continue;
           }
-          const promoted = owner.promote(target4, generation);
+          const promoted = owner.promote(target5, generation);
           if (!promoted.ok) {
             destroyPhysical(options.getDevice?.(), physical);
-            candidatePhysical.delete(target4);
+            candidatePhysical.delete(target5);
             continue;
           }
-          const previous = activePhysical.get(target4);
-          activePhysical.set(target4, physical);
-          candidatePhysical.delete(target4);
+          const previous = activePhysical.get(target5);
+          activePhysical.set(target5, physical);
+          candidatePhysical.delete(target5);
           destroyPhysical(options.getDevice?.(), previous);
         }
       });
     },
-    getPhysicalTarget(target4) {
-      return candidatePhysical.get(target4) ?? activePhysical.get(target4);
+    getPhysicalTarget(target5) {
+      return candidatePhysical.get(target5) ?? activePhysical.get(target5);
     },
     encodePendingReadbacks(encoder, faces) {
       for (const record of readbackRecords) {
@@ -34871,37 +35439,37 @@ function createRenderTargetHost(options = {}) {
     recover() {
       if (disposed) return;
       const generation = currentGeneration();
-      for (const target4 of targets) {
-        const inspected = owner.inspect(target4);
+      for (const target5 of targets) {
+        const inspected = owner.inspect(target5);
         if (!inspected.ok || inspected.value.state !== "active") continue;
-        destroyPhysical(options.getDevice?.(), activePhysical.get(target4));
-        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target4));
-        activePhysical.delete(target4);
-        candidatePhysical.delete(target4);
+        destroyPhysical(options.getDevice?.(), activePhysical.get(target5));
+        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target5));
+        activePhysical.delete(target5);
+        candidatePhysical.delete(target5);
         for (const record of readbackRecords) {
-          if (record.target !== target4) continue;
+          if (record.target !== target5) continue;
           if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
           readbacks.delete(record.ticket);
           readbackRecords.delete(record);
         }
-        const begun = owner.beginRecovery(target4, generation);
-        if (begun.ok) owner.finishRecovery(target4);
+        const begun = owner.beginRecovery(target5, generation);
+        if (begun.ok) owner.finishRecovery(target5);
       }
     },
     dispose() {
       disposed = true;
-      for (const target4 of [...targets]) {
-        destroyPhysical(options.getDevice?.(), activePhysical.get(target4));
-        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target4));
+      for (const target5 of [...targets]) {
+        destroyPhysical(options.getDevice?.(), activePhysical.get(target5));
+        destroyPhysical(options.getDevice?.(), candidatePhysical.get(target5));
         for (const record of readbackRecords) {
-          if (record.target !== target4) continue;
+          if (record.target !== target5) continue;
           if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
           readbacks.delete(record.ticket);
           readbackRecords.delete(record);
         }
-        activePhysical.delete(target4);
-        candidatePhysical.delete(target4);
-        owner.destroy(target4);
+        activePhysical.delete(target5);
+        candidatePhysical.delete(target5);
+        owner.destroy(target5);
       }
       targets.clear();
       staged.clear();
@@ -35786,11 +36354,11 @@ function createMeshSsboGrowController(init) {
     if (state.slotCount >= neededSlots) {
       return { ok: true };
     }
-    let target4 = state.slotCount > 0 ? state.slotCount : 1;
-    while (target4 < neededSlots) target4 = target4 * 2;
-    target4 = Math.max(target4, nextPow2(neededSlots));
+    let target5 = state.slotCount > 0 ? state.slotCount : 1;
+    while (target5 < neededSlots) target5 = target5 * 2;
+    target5 = Math.max(target5, nextPow2(neededSlots));
     const ceilingBytes = deriveStorageBufferCeiling(device.limits);
-    const targetBytes = target4 * perEntityStride;
+    const targetBytes = target5 * perEntityStride;
     if (targetBytes > ceilingBytes) {
       errorRegistry.fire(
         new MeshSsboCeilingReachedError(neededSlots, state.slotCount, ceilingBytes)
@@ -35801,7 +36369,7 @@ function createMeshSsboGrowController(init) {
         degradedToSlotCount: state.slotCount
       };
     }
-    allocBufferPair(target4);
+    allocBufferPair(target5);
     if (state.slotCount < neededSlots) {
       errorRegistry.fire(
         new MeshSsboCapacityExceededError(neededSlots, state.slotCount, ceilingBytes)
@@ -35973,7 +36541,7 @@ async function prewarmMipmapPipeline(rhiDevice, gpuStore, hasMaterialManifest) {
 }
 
 // src/assembly/webgpu-ready.ts
-async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, standardPbrShaderUvSetCount, requiredFullscreenPostProcesses, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinFxaa, registerBuiltinTemporalPostProcesses, setVolumetricFogShaderSources, setSsrShaderSources, setAtmosphereShaderSources) {
+async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, asyncCreateShaderModule, errorRegistry, requiredMaterialShaders, standardPbrShaderUvSetCount, requiredFullscreenPostProcesses, setGrowMeshSsboHook, seedShaderModule, seedMaterialShaderPipelineCache, registerBuiltinTonemap, registerBuiltinFxaa, registerBuiltinTemporalPostProcesses, registerBuiltinDepthOfField, setVolumetricFogShaderSources, setSsrShaderSources, setAtmosphereShaderSources) {
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   const capValue = rhiDevice.limits.maxStorageBuffersPerShaderStage;
   const webgl2Downlevel = rhiDevice.caps.backendKind === "wgpu-webgl2";
@@ -36578,6 +37146,7 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
     };
     await prewarmTemporal(motionBlurEntry, "forgeax.motion-blur");
     await prewarmTemporal(taaResolveEntry, "forgeax.taa-resolve");
+    await prewarmDepthOfField(manifestEntries, prewarmTemporal, registerBuiltinDepthOfField);
     registerBuiltinTemporalPostProcesses({
       ...motionBlurEntry === void 0 ? {} : { motionBlur: motionBlurEntry.wgsl },
       ...taaResolveEntry === void 0 ? {} : { taaResolve: taaResolveEntry.wgsl }
@@ -37448,11 +38017,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       }
       try {
         getOrBuildPipeline(spec, pipelineDeviceProvider, pipelineCache, modules);
-      } catch (err53) {
-        if (err53 instanceof PipelineSpecError) throw err53;
+      } catch (err54) {
+        if (err54 instanceof PipelineSpecError) throw err54;
         throw new PipelineSpecError({
           code: "pipeline-build-failed",
-          detail: { cause: err53 },
+          detail: { cause: err54 },
           hint: `Boot-time SPEC_CONST pre-warm failed for shader '${spec.shader.id}'; inspect gpuMessage on the cause`
         });
       }
@@ -37621,11 +38190,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
             pipelineCache,
             modules
           );
-        } catch (err53) {
-          if (err53 instanceof PipelineSpecError) throw err53;
+        } catch (err54) {
+          if (err54 instanceof PipelineSpecError) throw err54;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err53 },
+            detail: { cause: err54 },
             hint: "createRenderPipeline (fxaa fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -37879,11 +38448,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomBrightPipelineHandle,
                 () => void 0
               );
-            } catch (err53) {
-              if (err53 instanceof PipelineSpecError) throw err53;
+            } catch (err54) {
+              if (err54 instanceof PipelineSpecError) throw err54;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err53 },
+                detail: { cause: err54 },
                 hint: "createRenderPipeline (bloom-bright fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -37980,11 +38549,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomBlurHPipelineHandle,
                 () => void 0
               );
-            } catch (err53) {
-              if (err53 instanceof PipelineSpecError) throw err53;
+            } catch (err54) {
+              if (err54 instanceof PipelineSpecError) throw err54;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err53 },
+                detail: { cause: err54 },
                 hint: "createRenderPipeline (bloom-blur-h fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -38101,11 +38670,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomCompositePipelineHandle,
                 () => void 0
               );
-            } catch (err53) {
-              if (err53 instanceof PipelineSpecError) throw err53;
+            } catch (err54) {
+              if (err54 instanceof PipelineSpecError) throw err54;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err53 },
+                detail: { cause: err54 },
                 hint: "createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -38395,11 +38964,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_calc" }
             );
-          } catch (err53) {
-            if (err53 instanceof PipelineSpecError) throw err53;
+          } catch (err54) {
+            if (err54 instanceof PipelineSpecError) throw err54;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err53 },
+              detail: { cause: err54 },
               hint: "createRenderPipeline (ssao-calc fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -38430,11 +38999,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_blur" }
             );
-          } catch (err53) {
-            if (err53 instanceof PipelineSpecError) throw err53;
+          } catch (err54) {
+            if (err54 instanceof PipelineSpecError) throw err54;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err53 },
+              detail: { cause: err54 },
               hint: "createRenderPipeline (ssao-blur fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -38677,8 +39246,8 @@ async function tryCreateWebGPURenderer(canvas, options, pack, bundler, createRen
   if (pack._internal_getRawDevice && pack.translateErrorEventToRhiError) {
     const backendDevice = pack._internal_getRawDevice(device);
     if (backendDevice && typeof backendDevice === "object") {
-      const target4 = backendDevice;
-      target4.onuncapturederror = (event) => {
+      const target5 = backendDevice;
+      target5.onuncapturederror = (event) => {
         const translated = pack.translateErrorEventToRhiError?.(event);
         if (translated && !translated.ok) errorRegistry.fire(translated.error);
       };
@@ -39165,7 +39734,7 @@ async function makeWebGPURenderer(internals) {
     rendererId: /* @__PURE__ */ Symbol("renderer"),
     getGeneration: () => renderTargetGeneration,
     getDevice: () => renderTargetDevice,
-    canPromoteTarget: (target4) => renderSystemForTargetPromotion?.isCubeCapturePending(target4) !== true
+    canPromoteTarget: (target5) => renderSystemForTargetPromotion?.isCubeCapturePending(target5) !== true
   });
   const metrics = createEngineMetrics();
   let extendedLightingState = createExtendedLightingState(activeDeviceScope.generation);
@@ -39631,9 +40200,8 @@ async function makeWebGPURenderer(internals) {
     };
     extendedLightingState = promoteExtendedLightingCandidate(extendedLightingState, candidate);
   };
-  let tonemapRegistered = false;
-  let fxaaRegistered = false;
-  let temporalPostProcessesRegistered = false;
+  let tonemapRegistered = false, fxaaRegistered = false;
+  let temporalPostProcessesRegistered = false, depthOfFieldRegistered = false;
   const buildPipeline = (scope = activeDeviceScope, device = currentBuildDevice(), residencyStore = gpuStore) => buildReadyWebGPU(
     device,
     scope,
@@ -39648,7 +40216,6 @@ async function makeWebGPURenderer(internals) {
     ),
     materialShaderUvSetCounts.get("forgeax::default-standard-pbr") ?? 0,
     requiredFullscreenPostProcesses,
-    // Publish growth and capacity together for the active or candidate device.
     (hook, state) => {
       if (candidateBuildState !== void 0) {
         candidateBuildState.growMeshSsbo = hook;
@@ -39658,12 +40225,10 @@ async function makeWebGPURenderer(internals) {
         internals.meshSsboState = state;
       }
     },
-    // Both module adapters consume the generation's eager shader cache.
     (label, module) => {
       getShaderModuleAdapter().seedModule(label, module);
       getImmediateShaderModuleAdapter().seedModule(label, module);
     },
-    // Prewarm only the active build generation's material pipeline cache.
     (key, pso, group2Contract) => {
       const pipelineCache = currentPipelineCacheState().materialShaderPipelineCache;
       if (!pipelineCache.has(key)) {
@@ -39671,7 +40236,6 @@ async function makeWebGPURenderer(internals) {
       }
       materialShaderPipelineGroup2Contracts.set(pso, group2Contract);
     },
-    // Register the output transform after manifest loading, once RenderSystem exists.
     (source) => {
       if (candidateBuildState !== void 0 || tonemapRegistered) return;
       renderSystem.registerBuiltinPostProcess(STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, {
@@ -39708,6 +40272,11 @@ async function makeWebGPURenderer(internals) {
       }
       temporalPostProcessesRegistered = true;
     },
+    (entries) => {
+      if (candidateBuildState !== void 0 || depthOfFieldRegistered) return;
+      registerDepthOfFieldBuiltins(renderSystem, entries);
+      depthOfFieldRegistered = true;
+    },
     (sources) => {
       internals.volumetricFogShaders = sources;
     },
@@ -40353,7 +40922,7 @@ async function makeWebGPURenderer(internals) {
     set gpuPassTimingBeginReason(reason2) {
       internals.gpuPassTimingBeginReason = reason2;
     },
-    getRenderTargetPhysical: (target4) => renderTargetHost.getPhysicalTarget(target4),
+    getRenderTargetPhysical: (target5) => renderTargetHost.getPhysicalTarget(target5),
     resolveRenderTargetTextureSource: (source) => renderTargetHost.resolveRenderTargetTextureSource(source),
     encodeRenderTargetReadbacks: (encoder, faces) => renderTargetHost.encodePendingReadbacks(encoder, faces),
     get volumetricFogShaders() {
@@ -40557,10 +41126,10 @@ async function makeWebGPURenderer(internals) {
     },
     ...dynamicGeometryHost,
     createRenderTarget: (descriptor) => renderTargetHost.createRenderTarget(descriptor),
-    resizeRenderTarget: (target4, descriptor) => renderTargetHost.resizeRenderTarget(target4, descriptor),
-    createRenderTargetTextureSource: (target4, options) => renderTargetHost.createRenderTargetTextureSource(target4, options),
-    requestTargetReadback: (target4, request) => renderTargetHost.requestTargetReadback(target4, request),
-    destroyRenderTarget: (target4) => renderTargetHost.destroyRenderTarget(target4),
+    resizeRenderTarget: (target5, descriptor) => renderTargetHost.resizeRenderTarget(target5, descriptor),
+    createRenderTargetTextureSource: (target5, options) => renderTargetHost.createRenderTargetTextureSource(target5, options),
+    requestTargetReadback: (target5, request) => renderTargetHost.requestTargetReadback(target5, request),
+    destroyRenderTarget: (target5) => renderTargetHost.destroyRenderTarget(target5),
     setProfile(profile) {
       const invalid6 = validateRenderProfile(profile);
       if (invalid6 !== void 0) {
@@ -40678,6 +41247,7 @@ async function makeWebGPURenderer(internals) {
         directionalShadow,
         ...renderSystem.temporalTargetInspection === void 0 ? {} : { temporalTarget: Object.freeze(renderSystem.temporalTargetInspection) },
         ...renderSystem.motionBlurInspection === void 0 ? {} : { motionBlur: Object.freeze(renderSystem.motionBlurInspection) },
+        ...dofInspection(renderSystem.depthOfFieldInspection),
         ...renderSystem.lodOcclusionInspection === void 0 ? {} : { lodOcclusion: Object.freeze(renderSystem.lodOcclusionInspection) },
         ...renderSystem.transmission === void 0 ? {} : { transmission: renderSystem.transmission },
         ...standardLighting === void 0 ? {} : { standardLighting: Object.freeze({ ...standardLighting }) },