@forgeax/engine-render 0.1.34 → 0.1.36

package/dist/construct-renderer.mjs

@@ -1,28 +1,25 @@
-import { BARREL_DISTORTION_FEATURE_IDENTITY, createBarrelDistortionRenderFeature, 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, BARREL_DISTORTION_POST_PROCESS_ID, inspectPointShadow, admitSingleLayerMediumSubmission, createCloudShadowProjection, CLOUD_LAYER_FEATURE_IDENTITY, ReadonlyDynamicInputPage, DynamicGeometryError, sameCandidateCredential } from './chunk-ODZWR6JQ.mjs';
-import { createExtendedLightingState, promoteExtendedLightingCandidate, glyphTextLayoutSystem, emptyBloomInspection, projectExtendedLightingInspection, OcclusionRenderRuntime, extractFrames, viewKey, primitiveKey, projectBarrelDistortionInspection, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, InstanceBoundsCache, fingerprintNumericArray, buildShadowFrusta, createSsrHistoryOwner, createSsrSpatialResources, createCookieProjectionMatrixData } from './chunk-UI5SFODX.mjs';
-import './chunk-ILQ5MEZF.mjs';
-import { DEFAULT_DEPTH_OF_FIELD_PARAMS, projectMeshMaterialBindingObservation, resolveDepthOfFieldFrameParams, buildCubeCameraFaceViews, MeshFilter, MeshRenderer, Instances, Layer, Visibility, Points, Lines, SortKey, SKYLIGHT_RECOVERY_FALLBACK, hasVolumetricFogCapability, packDepthOfFieldParams, Camera, CAMERA_PROJECTION_ORTHOGRAPHIC, cloudShadowResolutionForQuality, CUBE_CAMERA_FACE_ORDER, createBarrelDistortionMapping, attachBarrelDistortionCameraFrame, MAX_VOLUMETRIC_FOG_OWNERS } from './chunk-UINHLCZA.mjs';
-import { TileLayer, decodeSortScope, SpriteInstances, SpriteRegionOverride, Tilemap } from './chunk-ELJFJ2BU.mjs';
-import { GPU_SCENE_LAYOUTS, deviceOptionsForAdapter, PipelineSpecError, assertStorageBufferCap, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, SurfaceSubmissionObservationOwner, createClusterBinScratch, resetSsaoResources, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, resolveMaterialSkylight, postProcessShaderEntrySignature, standardBloomAdmitted, selectSwapChainFormat, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, selectStandardPbrTransmissionPrewarmVariants, selectHdrpPbrPrewarmVariants, prewarmMaterialShaderVariants, selectProbePrewarmVariants, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, HDR_COLOR_ATTACHMENT_FORMAT, 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, ensureProbeBlendRecordBuffer, deriveRenderExtent, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, GPU_DRIVEN_VIEW_WGSL, selectGpuDrivenSceneIndexVariant, selectSkinPrewarmVariants, transmissionBackdropAvailable, VIEW_UBO_BYTES, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, MIPMAP_PREWARM_FORMATS, getIblProbeBackgroundSource, OcclusionConfidenceScheduler, shouldIssueRetest, selectGpuLodLane, ShadowViewStatePool, GpuDrivenView, MATERIAL_PER_ENTITY_STRIDE, shadowViewIdentityKey, combineGpuResourceAllocationInspections, inspectResourceClassSplits, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, resolveReflectionProbeBinding, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, detectNineSliceScaleTooSmall, DEPTH_TEXTURE_FORMAT, PREFILTER_SIZE, gpuSceneFieldOffset, projectedHeightForCandidate, geometryRenderStateForTopology, packInstanceStorageBuffer, GpuResourceAllocationLedger, MESH_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, standardTopologyVariantSet, resolveGeometryInstanceBuffer, 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, renderPipelineCloudHistoryTargets, createStandardSceneDataTarget, addStandardSceneDataPass, VIEW_UNIFORM_BYTES, addTypedFrameObservationPass, addReflectionFallbackObservationPass, selectLod, temporalReadIndex, temporalWriteIndex, CLOUD_HISTORY_FORMATS, prepareMaterialSkylight, BYTES_PER_DIRECT_LIGHT_SLOT, shadowViewRasterAccesses, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateFromChain, addTypedFullscreenPass, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedCompositePostEffects, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, variantSetFromVertexLayoutProjection, createStandardSurfaceLightingBindGroup, BLOOM_DOWNSAMPLE_PARAMS_BYTES, BLOOM_UPSAMPLE_PARAMS_BYTES, BLOOM_COMPOSITE_PARAMS_BYTES, isTemporalFullscreenBinding, createFullscreenBindGroup, stageTemporalGpuSubmit, applyParamSchemaDefaultsToUbo, defaultViewForUserRegionField, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-MKDIT2EM.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, isSceneDataTarget, resolveVolumetricFogProfile, SCENE_DATA_TEMPORAL_V1_SCHEMA } from './chunk-OCDLEI6I.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, buildSurfaceDirectInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, isCanonicalStandardPbrMaterialShader, getOpaqueResourceIdentity, gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, createTemporalCoverage, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, gpuDrivenMaterialArtifactKey, hasRequiredVertexInputs, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, PROBE_BLEND_RECORD_BYTE_SIZE, GPU_SHADER_STAGE_VERTEX, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, GPU_SHADER_STAGE_COMPUTE, LifecycleTransaction } from './chunk-SHFUFJ5N.mjs';
-import { RendererContractFailureError, RendererOperationError, MotionBlurValidationError, 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, InstanceProjectionStore, motionBlurTemporalDemand, createAutoExposureInspection, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, createVisibilityBudget, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, TransmissionCapabilityMissingError, motionBlurSampleDelta, isMotionBlurIntervalValid, MOTION_BLUR_PARAMS_BYTE_SIZE, effectiveMotionBlurSampleCount, motionBlurExposureScale, SHADOW_ATLAS_DEFAULT_LAYERS, DEFAULT_MOTION_BLUR_PARAMS, FXAA_POST_PROCESS_ID, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, GpuDrivenPreparationError, TemporalFrameSubmitError, ObservationUnavailableError, RenderFeaturePreparationFailedError, AutoExposureInvalidParameterError, PointsLinesPrepareFailedError, validateMotionBlurParams, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SceneDataUnavailableError, SkinPaletteOverflowError, GPU_TEXTURE_USAGE_STORAGE_BINDING, RenderFeatureDrawRecordingFailedError, PointShadowAtlasUninitializedError, RenderFeaturePreparedStateMismatchError } from './chunk-WEX45HKH.mjs';
+import { RenderPublicationError, BARREL_DISTORTION_FEATURE_IDENTITY, createBarrelDistortionRenderFeature, createRenderTargetHost, RenderPublicationTargetReceiver, registerRenderSourceSystems, publicationFrameDependencies, publicationDependencies, inspectVolumetricFog, renderMaterialContext, resolveSsrAdmissionGeneration, inspectLodOcclusion, zeroSsrAdmissionWork, projectSsrSpatialInspection, createDynamicGeometryLifecycle, inspectReflectionFallback, admitReflectionProbe, DEFAULT_REFLECTION_PROBE_LIMITS, buildReflectionProbeTable, advanceProbeFilter, commitProbeFilterStep, resolveReflectionFallbackSource, deriveReflectionFallbackProjection, reflectionFallbackCoverage, reflectionFallbackSourceKey, reflectionFallbackProjectionSignature, createProbeFilterState, ReflectionProbeProjection, RENDERABLE_SOURCE_COMPONENTS, isRenderableMember, createRenderSourceState, createGlobalTransformChangeQuery, admitPointsLines, projectSsrDependencies, resolveShadowMapSize, resolveSpotShadowMapSize, admitSsrSpatial, acquireSwapChainTarget, BARREL_DISTORTION_POST_PROCESS_ID, graphExecutionPhase, inspectPointShadow, admitSingleLayerMediumSubmission, createCloudShadowProjection, CLOUD_LAYER_FEATURE_IDENTITY, ReadonlyDynamicInputPage, DynamicGeometryError, resolveDirectionalShadowAtlasGrid, sameCandidateCredential } from './chunk-OEYKKMXG.mjs';
+import { createExtendedLightingState, promoteExtendedLightingCandidate, emptyBloomInspection, projectExtendedLightingInspection, OcclusionRenderRuntime, viewKey, primitiveKey, projectBarrelDistortionInspection, viewKeyId, primitiveKeyId, ProbeBlendSceneProjection, createSsrHistoryOwner, createSsrSpatialResources } from './chunk-D6WSBXJ2.mjs';
+import { DEFAULT_DEPTH_OF_FIELD_PARAMS, extractFrames, projectMeshMaterialBindingObservation, resolveDepthOfFieldFrameParams, buildCubeCameraFaceViews, Instances, Visibility, SKYLIGHT_RECOVERY_FALLBACK, hasVolumetricFogCapability, packDepthOfFieldParams, Points, Lines, buildShadowFrusta, cloudShadowResolutionForQuality, CUBE_CAMERA_FACE_ORDER, createBarrelDistortionMapping, attachBarrelDistortionCameraFrame, MeshFilter, MAX_VOLUMETRIC_FOG_OWNERS, MeshRenderer, createCookieProjectionMatrixData, internSharedRefFromGuid } from './chunk-BZQ4CDRF.mjs';
+import { SpriteInstances } from './chunk-X2KA6WHM.mjs';
+import { GPU_SCENE_LAYOUTS, deviceOptionsForAdapter, PipelineSpecError, assertStorageBufferCap, STANDARD_PBR_REQUIRED_SAMPLED_TEXTURES, GpuBuffer, GpuTexture, deriveRenderDataTexture, deriveRenderDataMesh, deriveRenderDataCubemap, createIblPipelines, CUBEMAP_FACE_VERTICES, runIblPrecompute, SurfaceSubmissionObservationOwner, createClusterBinScratch, resetSsaoResources, resetHdrpBuffers, retireTemporalGpuState, PostProcessError, entryHasDepthRead, DEPTH_MIN_PARAMS_BYTE_SIZE, postProcessShaderModuleLabel, resolveSsaoParameters, buildPerFrameBindGroups, resolveMaterialSkylight, postProcessShaderEntrySignature, standardBloomAdmitted, setIblComposedShaders, POINTS_LINES_MATERIAL_SHADER_ID, selectStandardPbrTransmissionPrewarmVariants, selectHdrpPbrPrewarmVariants, prewarmMaterialShaderVariants, selectProbePrewarmVariants, createHdrpClusterMembershipBindGroupLayoutDescriptor, createSkylightFallback, buildSpecConstTable, buildLinearLdrMaterialSpecTable, getOrBuildPipeline, cacheKeyOf, HDR_COLOR_ATTACHMENT_FORMAT, 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, ensureProbeBlendRecordBuffer, deriveRenderExtent, writeSpotModifierTextures, writeHdrpClusterAndSsaoBuffers, resolveSkyboxActive, computeSplitLdrSprite, writeViewUbo, writePointsLinesViewUbo, writeShadowCasterUniforms, uploadMeshSsboBatch, passKindPolicyTable, colorFormatsForPassKind, GPU_DRIVEN_VIEW_WGSL, selectGpuDrivenSceneIndexVariant, selectSkinPrewarmVariants, transmissionBackdropAvailable, VIEW_UBO_BYTES, POINTS_LINES_VIEW_BUFFER_SIZE, SHADOW_CASTER_BUFFER_SIZE, FALLBACK_BYTES_PER_ROW, MIPMAP_PREWARM_FORMATS, getIblProbeBackgroundSource, OcclusionConfidenceScheduler, shouldIssueRetest, selectGpuLodLane, ShadowViewStatePool, GpuDrivenView, shadowViewIdentityKey, combineGpuResourceAllocationInspections, inspectResourceClassSplits, createPointsLinesLaneContract, foldDispatchBuckets, CUBE_CAPTURE_VIEW_SLOT_BASE, variantSetFromDefines, resolveReflectionProbeBinding, cleanPerEntityCache, ensureMeshSsboCapacity, buildFoldDispatchPlan, evaluateFoldBucketUniformCap, incrementFoldedDrawsMetric, writePbrMaterialUboPayload, applyParamSnapshotToUbo, applyMaterialTextureUvScales, residentTextureView, detectNineSliceScaleTooSmall, DEPTH_TEXTURE_FORMAT, PREFILTER_SIZE, gpuSceneFieldOffset, projectedHeightForCandidate, geometryRenderStateForTopology, packInstanceStorageBuffer, GpuResourceAllocationLedger, MESH_PER_ENTITY_STRIDE, MESH_SSBO_BYTES, standardTopologyVariantSet, resolveGeometryInstanceBuffer, buildFullscreenPostProcessPass, getTemporalGpuState, getTemporalParamsBuffer, getTemporalBindGroupResources, TEMPORAL_HISTORY_FORMATS, createRenderPipelineTarget, encodeMainPass, abortTemporalGpuSubmit, commitTemporalGpuSubmit, retireTemporalGpuStateAfterFence, hasPendingTemporalGpuSubmit, importRenderPipelineSurface, renderExtentSize, DEFERRED_COLOR_FORMATS, aggregateTemporalDemand, standardTemporalLaneAdmission, addTypedScenePass, addTypedSsaoPasses, addTypedSkyboxPass, renderPipelineCloudHistoryTargets, createStandardSceneDataTarget, addStandardSceneDataPass, VIEW_UNIFORM_BYTES, addTypedFrameObservationPass, addReflectionFallbackObservationPass, selectLod, temporalReadIndex, temporalWriteIndex, CLOUD_HISTORY_FORMATS, prepareMaterialSkylight, BYTES_PER_DIRECT_LIGHT_SLOT, shadowViewRasterAccesses, encodeDirectionalShadowPass, encodePointShadowPass, encodeSpotShadowPass, getOrCreateFromChain, addTypedFullscreenPass, resolveOutputDither, addTypedTemporalResolvePass, addTypedBloomPasses, addTypedOutputTransformPass, addTypedCompositePostEffects, geometryRenderStateForPass, standardStorageVariantSet, getOrCreateHdrpBuffers, variantSetFromVertexLayoutProjection, createStandardSurfaceLightingBindGroup, BLOOM_DOWNSAMPLE_PARAMS_BYTES, BLOOM_UPSAMPLE_PARAMS_BYTES, BLOOM_COMPOSITE_PARAMS_BYTES, isTemporalFullscreenBinding, createFullscreenBindGroup, stageTemporalGpuSubmit, applyParamSchemaDefaultsToUbo, defaultViewForUserRegionField, assembleMaterialWithSkylightEntries, TYPED_BLOOM_PASS_NAMES } from './chunk-CJOV2XLO.mjs';
+import { DEFAULT_STANDARD_PROFILE, DEFAULT_CLUSTER_GRID, selectSwapChainFormat, configureSurface, STANDARD_PIPELINE_ID, STANDARD_LIGHT_COUNTS, STANDARD_POST_STAGE_NAMES, createSceneDataCatalog, MATERIAL_PER_ENTITY_STRIDE, isSceneDataTarget, resolveSurfaceFormatPair, resolveSurfaceProfile, resolveVolumetricFogProfile, STANDARD_PBR_UBO_SIZE, SCENE_DATA_TEMPORAL_V1_SCHEMA } from './chunk-OB5WAFYH.mjs';
+import { getTransparentSortConfig, TRANSPARENT_SORT_MODE_DISTANCE, TRANSPARENT_SORT_MODE_LAYER_Z, TRANSPARENT_SORT_MODE_LAYER_Y, TRANSPARENT_SORT_MODE_LAYER_YZ, SPRITE_PREMULTIPLIED_ALPHA_BLEND } from './chunk-XSFB7XXQ.mjs';
+import { createTemporalCoverage, PROBE_BLEND_RECORD_BYTE_SIZE } from './chunk-RIPAEGI6.mjs';
+import { RendererContractFailureError, RendererOperationError, MotionBlurValidationError, DeviceScope, SKIN_MATERIAL_SHADER_ID, STANDARD_OUTPUT_TRANSFORM_FEATURE_ID, EXTENDED_LIGHTING_TOPOLOGY, FrameReceiptStaleError, getTextureIdentity, RenderFeatureStageFailedError, RenderFeatureCapabilityMissingError, deriveExtendedLightingCapability, GPU_TEXTURE_USAGE_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_DST, GPU_BUFFER_USAGE_VERTEX, GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_INDEX, IES_SLICE_WIDTH, IES_SLICE_HEIGHT, COOKIE_SLICE_SIZE, COOKIE_MATRIX_BYTES, RENDER_PHASE_CATALOG, InstanceProjectionStore, GPU_BUFFER_USAGE_UNIFORM, worldEntityKey, motionBlurTemporalDemand, createAutoExposureInspection, createHdrpBindGroupLayoutDescriptor, createHdrpSkinBindGroupLayoutDescriptor, GPU_BUFFER_USAGE_QUERY_RESOLVE, GPU_BUFFER_USAGE_COPY_SRC, GPU_BUFFER_USAGE_MAP_READ, RenderFeatureRegistrationConflictError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING, GPU_TEXTURE_USAGE_COPY_SRC, createVisibilityBudget, gpuDrivenShadowDrawKey, EnvironmentGenerationFailedError, PointsLinesMaterialUnsupportedError, StandardProfileInvalidError, buildGpuDrivenDraws, TransmissionCapabilityMissingError, motionBlurSampleDelta, isMotionBlurIntervalValid, makeZeroCameraFallbackSnapshot, MOTION_BLUR_PARAMS_BYTE_SIZE, effectiveMotionBlurSampleCount, motionBlurExposureScale, SHADOW_ATLAS_DEFAULT_LAYERS, DEFAULT_MOTION_BLUR_PARAMS, FXAA_POST_PROCESS_ID, buildPbrPipelineLayouts, buildPbrSkinLayouts, buildGpuDrivenPbrInstancesBindGroupLayout, buildSurfaceDirectInstancesBindGroupLayout, buildGpuDrivenPbrPipelineLayout, buildGpuDrivenPbrSkinPipelineLayout, GPU_BUFFER_USAGE_STORAGE, resolvePipelineGroup2Contract, GPU_SHADER_STAGE_FRAGMENT, RenderTargetStateInvalidError, InstanceBoundsCache, fingerprintNumericArray, GpuDrivenPreparationError, isCanonicalStandardPbrMaterialShader, getOpaqueResourceIdentity, gpuDrivenDrawKey, gpuDrivenSourceDrawItemIndex, TemporalFrameSubmitError, GPU_TEXTURE_USAGE_RENDER_ATTACHMENT, ObservationUnavailableError, RenderFeaturePreparationFailedError, AutoExposureInvalidParameterError, instanceCollectionCacheKey, validateGraphTargetCaptureReadback, isStandardPbrMaterialShader, buildBindGroupLayoutDescriptor, gpuDrivenMaterialArtifactKey, PointsLinesPrepareFailedError, validateMotionBlurParams, hasRequiredVertexInputs, SHADOW_ATLAS_DEFAULT_FACE_SIZE, resolveRenderTargetMaterialSource, buildPbrMaterialUserRegionEntries, extendedLightingSampledTextureCapacityAvailable, SceneDataUnavailableError, SkinPaletteOverflowError, GPU_TEXTURE_USAGE_STORAGE_BINDING, RenderFeatureDrawRecordingFailedError, GPU_SHADER_STAGE_VERTEX, PointShadowAtlasUninitializedError, SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET, SHADOW_CASTER_SHADER_ID, shadowCasterVariantSet, RenderFeaturePreparedStateMismatchError, GPU_SHADER_STAGE_COMPUTE, RenderTargetOperationFailedError, LifecycleTransaction } from './chunk-2OZAS3WU.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, RuntimeMaterialValue, RuntimeMeshVertices, resolveAssetHandle, numMipLevels, encodeMipmapLevel, resolveTilesetRuntime, MeshSsboCeilingReachedError, MeshSsboCapacityExceededError } from '@forgeax/engine-assets-runtime';
+import { AssetRegistry, DynamicTextureStore, adaptDynamicTextureDevice, getOrCreateMipmapPipeline, prepareMipmaps, blitMipmapsSync, HANDLE_CUBE, HANDLE_TRIANGLE, HANDLE_QUAD, HANDLE_SPHERE, HANDLE_NINESLICE_QUAD, BuiltinAssetRegistry, RuntimeMaterialValue, RuntimeMeshVertices, resolveAssetHandle, numMipLevels, encodeMipmapLevel, MeshSsboCeilingReachedError, MeshSsboCapacityExceededError } from '@forgeax/engine-assets-runtime';
 import { audioLoader } from '@forgeax/engine-audio-webaudio';
-import { Update, Time, FixedTime } from '@forgeax/engine-ecs';
-import { createRenderReadLease, createStateProjection } from '@forgeax/engine-ecs/projection';
-import { buildMeshAttributeMapForUvSets, deriveVertexBufferLayout, DEFAULT_VERTEX_ATTRIBUTE_MAP, deriveVertexCount, deriveVertexLayoutProjection, SKIN_VERTEX_ATTRIBUTE_MAP, deriveVertexBufferLayoutFromProjection } from '@forgeax/engine-geometry';
-import { registerPropagateTransforms, collectSubtree, Name, ChildOf, Children, MorphWeights, GlobalTransform, Transform } from '@forgeax/engine-scene';
-import { STANDARD_PIPELINE_PARAM_SCHEMA, createStandardPbrArtifactReceipt, SINGLE_LAYER_MEDIUM_RAW_DEPTH_WGSL, SINGLE_LAYER_MEDIUM_MSAA_PAIRED_COLOR_WGSL, SINGLE_LAYER_MEDIUM_MSAA_RAW_DEPTH_WGSL, ShaderCatalog, findVariantByKey, LTC_TABLES, standardPhysicalTextureFields, LTC_TABLE_HEIGHT, LTC_TABLE_WIDTH, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, AUTO_EXPOSURE_METER_WGSL } from '@forgeax/engine-shader';
-import { halfFloat, frustum, mat4, vec3, box3, mat3 } from '@forgeax/engine-math';
-import { derive, err as err$1, ok as ok$1, handleSlot, deriveTextureLayout, ASSET_ERROR_HINTS, countExtraUvSets, toShared, RenderQueue, IMAGE_ERROR_HINTS, BUILTIN_BASE, unwrapHandle, materialValuesToLinearRuntime } from '@forgeax/engine-types';
+import { createRenderReadLease } from '@forgeax/engine-ecs/projection';
+import { deriveVertexLayoutProjection, buildMeshAttributeMapForUvSets, deriveVertexCount, DEFAULT_VERTEX_ATTRIBUTE_MAP, SKIN_VERTEX_ATTRIBUTE_MAP, deriveVertexBufferLayoutFromProjection, deriveVertexBufferLayout } from '@forgeax/engine-geometry';
+import { STANDARD_PIPELINE_PARAM_SCHEMA, createStandardPbrArtifactReceipt, SINGLE_LAYER_MEDIUM_RAW_DEPTH_WGSL, SINGLE_LAYER_MEDIUM_MSAA_PAIRED_COLOR_WGSL, SINGLE_LAYER_MEDIUM_MSAA_RAW_DEPTH_WGSL, ShaderCatalog, findVariantByKey, MaterialArtifactRegistry, ShaderRegistry, LTC_TABLES, standardPhysicalTextureFields, LTC_TABLE_HEIGHT, LTC_TABLE_WIDTH, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, AUTO_EXPOSURE_METER_WGSL } from '@forgeax/engine-shader';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { derive, ok as ok$1, err as err$1, handleSlot, deriveTextureLayout, ASSET_ERROR_HINTS, countExtraUvSets, toShared, AssetError, RenderQueue, IMAGE_ERROR_HINTS, BUILTIN_BASE, materialValuesToLinearRuntime } from '@forgeax/engine-types';
+import { halfFloat, mat4, vec3, box3, frustum, mat3 } from '@forgeax/engine-math';
 import { createCurrentFrameObservationLease, RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import { Time, FixedTime } from '@forgeax/engine-ecs';
+import { collectSubtree, Name, ChildOf, Children, GlobalTransform, MorphWeights, Transform } from '@forgeax/engine-scene';
 import { Skin } from '@forgeax/engine-skinning';
-import { decodeTileBits } from '@forgeax/engine-graphics-extras';
-import { AssetGuid } from '@forgeax/engine-pack/guid';
 import '@forgeax/engine-pack/material-cook';
 
 // src/assembly/backend-contract.ts
@@ -268,7 +265,8 @@ function exposeRenderer(renderer) {
     cause: structuredRendererCause(cause, "renderer-event")
   });
   const drawError = (cause) => {
-    if (cause instanceof MotionBlurValidationError) return cause;
+    if (cause instanceof MotionBlurValidationError || cause instanceof RenderPublicationError)
+      return cause;
     if (cause instanceof RendererOperationError) return cause;
     if (cause instanceof RendererContractFailureError) {
       return new RendererOperationError("device-operation-failed", {
@@ -543,6 +541,237 @@ function freezeRenderProfile(profile) {
     postStages: Object.freeze([...profile.postStages])
   });
 }
+function installPublicationPrograms(assets, programs) {
+  if (programs.length === 0) return;
+  const validation = new MaterialArtifactRegistry();
+  const shaders = new ShaderRegistry({ manifestUrl: void 0 });
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of programs) {
+    if (keys.has(row.key) || row.artifact !== void 0 && row.artifact.key !== row.key)
+      throw new RenderPublicationError({
+        reason: "shape",
+        subject: "duplicate or mismatched program key"
+      });
+    keys.add(row.key);
+    shaders.installMaterialArtifact(row.key, row.shader);
+    const previous = assets.shaderRegistry.findMaterialArtifact(row.key);
+    if (previous.ok && (previous.value.source !== row.shader.source || JSON.stringify(previous.value.paramSchema) !== JSON.stringify(row.shader.paramSchema) || JSON.stringify(previous.value.receipt) !== JSON.stringify(row.shader.receipt))) {
+      throw new RenderPublicationError({
+        reason: "shape",
+        subject: `conflicting immutable shader ${row.key}`
+      });
+    }
+    if (row.artifact !== void 0) {
+      const existing = assets.getMaterialArtifact(row.key);
+      if (existing !== void 0) validation.register(existing).unwrap();
+      validation.register(row.artifact).unwrap();
+    }
+  }
+  for (const row of programs) {
+    if (row.artifact !== void 0) assets.materialArtifactRegistry.register(row.artifact).unwrap();
+    if (!assets.shaderRegistry.findMaterialArtifact(row.key).ok)
+      assets.shaderRegistry.installMaterialArtifact(row.key, row.shader);
+  }
+}
+var RenderPublicationReceiver = class {
+  constructor(identity) {
+    this.identity = identity;
+    const resolveAsset = (handle) => {
+      const value = this.assets.get(handle);
+      return value === void 0 ? err$1(
+        new AssetError({
+          code: "asset-not-found",
+          expected: "the accepted publication contains the referenced asset generation",
+          hint: "publish the asset closure before drawing its consumer"
+        })
+      ) : ok$1(value);
+    };
+    this.resources = {
+      identity: `${identity.source}:${identity.epoch}`,
+      time: { delta: 0, elapsed: 0, maxDeltaSeconds: 0 },
+      transparentSort: { mode: 0, yzAlpha: 1 },
+      resolveAsset,
+      videoFrame: (entity, clip) => this.videoFrames.get(`${entity}:${clip}`),
+      handleForGuid: (guid) => this.guidHandles.get(guid.toLowerCase()),
+      lookupAsset: (guid) => {
+        const handle = this.guidHandles.get(guid.toLowerCase());
+        return handle === void 0 ? void 0 : this.assets.get(handle);
+      }
+    };
+  }
+  identity;
+  revision = 0;
+  videoFrames = /* @__PURE__ */ new Map();
+  entities = /* @__PURE__ */ new Set();
+  assets = /* @__PURE__ */ new Map();
+  resources;
+  guidHandles = /* @__PURE__ */ new Map();
+  accept(packet) {
+    const reject = (reason2, subject) => err$1(new RenderPublicationError({ reason: reason2, subject }));
+    if (packet.source !== this.identity.source || packet.epoch !== this.identity.epoch)
+      return reject("identity", "source/epoch");
+    if (packet.base !== this.revision || packet.baseline !== (this.revision === 0))
+      return reject("base", "accepted revision");
+    if (!Number.isSafeInteger(packet.revision) || packet.revision !== this.revision + 1)
+      return reject("revision", "next revision");
+    if (!(packet.upserts instanceof Uint32Array) || packet.upserts.length % 2 !== 0 || !(packet.removed instanceof Uint32Array) || !(packet.transformEntities instanceof Uint32Array) || !(packet.transforms instanceof Float32Array) || packet.transforms.length !== packet.transformEntities.length * 16 || !packet.transforms.every(Number.isFinite) || !Number.isFinite(packet.sampleTimeSeconds))
+      return reject("shape", "numeric columns");
+    if (!Array.isArray(packet.videoFrames) || !Array.isArray(packet.targets) || !Array.isArray(packet.targetSources) || !Array.isArray(packet.features) || !Array.isArray(packet.templates) || !Array.isArray(packet.programs) || !Array.isArray(packet.assets) || !Array.isArray(packet.retiredAssets) || !Array.isArray(packet.invalidatedAssets) || packet.metadata === null || typeof packet.metadata !== "object" || !Array.isArray(packet.metadata.cameras) || !Number.isFinite(packet.time?.elapsed) || !Number.isFinite(packet.time?.delta))
+      return reject("shape", "frame metadata");
+    const videoKeys = /* @__PURE__ */ new Set();
+    for (const row of packet.videoFrames) {
+      const key = `${row.entity}:${row.clip}`;
+      if (!Number.isSafeInteger(row.entity) || !Number.isSafeInteger(row.clip) || typeof VideoFrame === "undefined" || !(row.frame instanceof VideoFrame) || row.frame.displayWidth <= 0 || row.frame.displayHeight <= 0 || videoKeys.has(key))
+        return reject("shape", "video frame");
+      videoKeys.add(key);
+    }
+    const targetIds = /* @__PURE__ */ new Set();
+    const targetTokens = /* @__PURE__ */ new Set();
+    for (const row of packet.targets) {
+      if (!Number.isSafeInteger(row.id) || row.id <= 0 || targetIds.has(row.id) || typeof row.token !== "object" || row.token === null || targetTokens.has(row.token) || typeof row.descriptor !== "object" || row.descriptor === null)
+        return reject("shape", "target identity/descriptor");
+      targetIds.add(row.id);
+      targetTokens.add(row.token);
+    }
+    for (const camera of [
+      ...packet.metadata.cameras,
+      ...packet.metadata.auxiliaryCameras,
+      ...packet.metadata.cubeCameras
+    ])
+      if (camera.target !== void 0 && !targetTokens.has(camera.target))
+        return reject("shape", "missing target descriptor");
+    const sourceTokens = /* @__PURE__ */ new Set();
+    for (const row of packet.targetSources) {
+      if (!targetTokens.has(row.target) || typeof row.token !== "object" || row.token === null || sourceTokens.has(row.token))
+        return reject("shape", "target source");
+      sourceTokens.add(row.token);
+    }
+    const featureIdentities = /* @__PURE__ */ new Set();
+    for (const row of packet.features) {
+      if (typeof row.identity !== "string" || featureIdentities.has(row.identity))
+        return reject("shape", "feature identity");
+      featureIdentities.add(row.identity);
+    }
+    const matrices = /* @__PURE__ */ new Map();
+    for (let i = 0; i < packet.transformEntities.length; i++) {
+      const entity = packet.transformEntities[i];
+      if (matrices.has(entity)) return reject("shape", "duplicate transform identity");
+      matrices.set(entity, packet.transforms.slice(i * 16, i * 16 + 16));
+    }
+    const operations = [];
+    const renderables = [];
+    const dispatch = [];
+    const updated = /* @__PURE__ */ new Set();
+    for (let i = 0; i < packet.upserts.length; i += 2) {
+      const entityKey = packet.upserts[i];
+      const template = packet.templates[packet.upserts[i + 1]];
+      const world = matrices.get(entityKey);
+      if (template === void 0 || world === void 0 || updated.has(entityKey))
+        return reject("shape", "upsert template/transform");
+      if (!Array.isArray(template.snapshot?.materials) || !Array.isArray(template.dispatch))
+        return reject("shape", "template");
+      for (const material of template.snapshot.materials)
+        for (const source of material.textureSources?.values() ?? [])
+          if (!sourceTokens.has(source)) return reject("shape", "missing target source");
+      if (template.snapshot.skin !== void 0) return reject("shape", "source GPU skin receipt");
+      const pose = template.snapshot.skinPose;
+      if (pose !== void 0 && (!Number.isInteger(pose.jointCount) || pose.jointCount <= 0 || pose.inverseBindMatrices.length !== pose.jointCount || pose.jointWorlds.length !== pose.jointCount || [...pose.inverseBindMatrices, ...pose.jointWorlds].some(
+        (matrix) => !(matrix instanceof Float32Array) || matrix.length !== 16 || !matrix.every(Number.isFinite)
+      )))
+        return reject("shape", "skin pose");
+      updated.add(entityKey);
+      const snapshot = {
+        ...template.snapshot,
+        worldId: 0,
+        entityKey,
+        transform: { world }
+      };
+      for (const item of template.dispatch)
+        dispatch.push({ ...item, entityIndex: entityKey, renderableIndex: renderables.length });
+      renderables.push(snapshot);
+      operations.push({ kind: "update", worldId: 0, entityKey, snapshot });
+    }
+    const removed = /* @__PURE__ */ new Set();
+    for (const entityKey of packet.removed) {
+      if (!this.entities.has(entityKey) || updated.has(entityKey) || removed.has(entityKey))
+        return reject("shape", "duplicate removal");
+      removed.add(entityKey);
+      operations.push({ kind: "remove", worldId: 0, entityKey });
+    }
+    for (const [entityKey, world] of matrices) {
+      if (removed.has(entityKey)) return reject("shape", "removed transform");
+      if (!updated.has(entityKey) && !this.entities.has(entityKey))
+        return reject("shape", "unknown transform identity");
+      if (!updated.has(entityKey))
+        operations.push({ kind: "update", worldId: 0, entityKey, world });
+    }
+    const assetHandles = /* @__PURE__ */ new Set();
+    for (const row of packet.assets) {
+      if (row.value === null || typeof row.value !== "object" || !Number.isSafeInteger(row.handle) || assetHandles.has(row.handle) || packet.retiredAssets.includes(row.handle))
+        return reject("shape", "asset payload");
+      assetHandles.add(row.handle);
+    }
+    for (const handles of [
+      publicationFrameDependencies(packet.metadata),
+      ...renderables.map(publicationDependencies)
+    ]) {
+      if (handles.some(
+        (handle) => !assetHandles.has(handle) && (!this.assets.has(handle) || packet.retiredAssets.includes(handle))
+      ))
+        return reject("shape", "missing asset dependency");
+    }
+    const guidHandles = new Map(this.guidHandles);
+    for (const [guid, handle] of guidHandles)
+      if (packet.retiredAssets.includes(handle)) guidHandles.delete(guid);
+    for (const row of packet.assets)
+      if (row.guid !== void 0) guidHandles.set(row.guid.toLowerCase(), row.handle);
+    for (const row of renderables)
+      if (row.lods?.some((lod) => !guidHandles.has(AssetGuid.format(lod.mesh).toLowerCase())))
+        return reject("shape", "missing LOD dependency");
+    for (const entity of removed) this.entities.delete(entity);
+    for (const entity of updated) this.entities.add(entity);
+    if (packet.baseline) this.assets.clear();
+    this.guidHandles.clear();
+    for (const [guid, handle] of guidHandles) this.guidHandles.set(guid, handle);
+    for (const handle of packet.retiredAssets) this.assets.delete(handle);
+    for (const row of packet.assets) this.assets.set(row.handle, row.value);
+    Object.assign(this.resources, { time: packet.time, transparentSort: packet.transparentSort });
+    this.releaseVideoFrames();
+    this.videoFrames = new Map(
+      packet.videoFrames.map((row) => [`${row.entity}:${row.clip}`, row.frame])
+    );
+    this.revision = packet.revision;
+    return ok$1({
+      resources: this.resources,
+      packet,
+      operations,
+      frame: {
+        ...packet.metadata,
+        renderables,
+        dispatch,
+        visibilitySnapshots: [],
+        featureVisibilitySnapshots: [],
+        hiddenEntityReports: [],
+        shadowCasterEntityKeys: /* @__PURE__ */ new Set(),
+        shadowCasterDrawKeys: /* @__PURE__ */ new Set()
+      }
+    });
+  }
+  /** copyExternalImageToTexture consumes native sources synchronously during draw. */
+  releaseVideoFrames() {
+    for (const frame of this.videoFrames.values()) frame.close();
+    this.videoFrames.clear();
+  }
+  dispose() {
+    this.releaseVideoFrames();
+    this.assets.clear();
+    this.guidHandles.clear();
+    this.entities.clear();
+  }
+  get acceptedRevision() {
+    return this.revision;
+  }
+};
 
 // src/device/mesh-residency-lifetime.ts
 var MeshResidencyLifetime = class {
@@ -899,9 +1128,9 @@ var GpuResidencyCache = class {
     this.meshLifetime(entry).retire();
   }
   /**
-   * Compose a cache key from the raw handle slot and its owning World. The
+   * Compose a cache key from the raw handle slot and its owning RenderResourceScope. The
    * draw-time world index is only a position in one frame's `worlds[]`; it is
-   * not an asset identity and can be reused by a later World. World objects
+   * not an asset identity and can be reused by a later RenderResourceScope. RenderResourceScope objects
    * therefore receive a renderer-local namespace, while numeric callers keep
    * the legacy namespace for low-level tests and built-in upload paths.
    */
@@ -1874,12 +2103,12 @@ var GpuResidencyCache = class {
     });
     if (!equirectViewResult.ok) return recordFailed(equirectViewResult.error);
     const equirectView = equirectViewResult.value;
-    const bytesPerPixel2 = tex.format === "rgba32float" ? 16 : tex.format === "rgba16float" ? 8 : 4;
+    const bytesPerPixel = tex.format === "rgba32float" ? 16 : tex.format === "rgba16float" ? 8 : 4;
     const equirectWriteResult = device.queue.writeTexture(
       { texture: equirectGpuTex },
       tex.data,
       {
-        bytesPerRow: tex.shape.extent.width * bytesPerPixel2,
+        bytesPerRow: tex.shape.extent.width * bytesPerPixel,
         rowsPerImage: tex.shape.extent.height
       },
       {
@@ -1945,7 +2174,7 @@ var GpuResidencyCache = class {
       view: cubeView,
       faceViews
     });
-    const regResult = registerCube(world, cubeAsset);
+    const regResult = registerCube(world, cubeAsset, sourceHandle);
     if (!regResult.ok) return recordFailed(regResult.error);
     const cubeHandle = regResult.value;
     const cubeId = handleSlot(cubeHandle);
@@ -2566,8 +2795,8 @@ function cloneSignatureNode(value, previous) {
       values
     });
   }
-  const token2 = stablePrimitiveToken(value);
-  return previous?.kind === "primitive" && previous.token === token2 ? previous : { kind: "primitive", token: token2 };
+  const token = stablePrimitiveToken(value);
+  return previous?.kind === "primitive" && previous.token === token ? previous : { kind: "primitive", token };
 }
 function signatureResourceValue(resource) {
   if (resource.kind !== "buffer") return resource;
@@ -4292,7 +4521,10 @@ function runRenderFeatureFrame(host, input) {
     const extracted = invokeStage(
       slot,
       "extract",
-      () => slot.feature.extract(extractContext),
+      () => {
+        const published = input.publishedFeatures?.find((row) => row.identity === identity);
+        return published === void 0 ? slot.feature.extract(extractContext) : ok$1(published.data);
+      },
       stageEvents,
       errors
     );
@@ -4447,12 +4679,14 @@ function runRenderFeatureFrame(host, input) {
       continue;
     }
     planExecutionProjections.set(plannedFrame, projected.value);
-    if (feature.onFrameSubmitted !== void 0) {
+    if (feature.onFrameSubmitted !== void 0 || feature.onSourceFrameSubmitted !== void 0) {
       submissionSensitivePlans.add(plannedFrame);
-      submissionAcknowledgments.set(
-        plannedFrame,
-        () => feature.onFrameSubmitted?.(extracted.value, projected.value)
-      );
+      submissionAcknowledgments.set(plannedFrame, () => {
+        feature.onFrameSubmitted?.(extracted.value, projected.value);
+        if (input.publishedFeatures?.some((row) => row.identity === identity))
+          input.onFeatureSourceSubmitted?.(identity, declared.value.sourceFeedback);
+        else feature.onSourceFrameSubmitted?.(extracted.value, declared.value.sourceFeedback);
+      });
     }
     plans.push(plannedFrame);
     if (feature.onFrameAborted !== void 0) {
@@ -6370,16 +6604,6 @@ function addTransmissionBackdropTemporalPass(graph, source) {
     encode: () => void 0
   });
 }
-
-// src/typed-shadow-atlas.ts
-function resolveDirectionalShadowAtlasGrid(cascadeCount) {
-  const count = Math.max(1, Math.min(4, Math.round(cascadeCount)));
-  if (count === 1) return { columns: 1, rows: 1 };
-  if (count === 2) return { columns: 2, rows: 1 };
-  return { columns: 2, rows: 2 };
-}
-
-// src/typed-shadow-passes.ts
 function shadowViewCacheReuse(frame, identity) {
   const context = frame;
   const gpuShadowViews = context.gpuDrivenShadowViews;
@@ -6428,6 +6652,8 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
         index: cascade
       });
       if (shadowProjection !== void 0 && !shadowProjection.ok) return shadowProjection;
+      let forceRasterPending = true;
+      let forceRasterEncodePending = false;
       const added = recordShadowPass(
         graph,
         `shadowCascade${cascade}`,
@@ -6443,9 +6669,18 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
             w: mapSize,
             h: mapSize
           },
-          shadowFeatures === void 0 ? void 0 : (view) => shadowFeatures.encode(pass, frame, resources, view)
+          shadowFeatures === void 0 ? void 0 : (view) => shadowFeatures.encode(pass, frame, resources, view),
+          forceRasterEncodePending
         ),
-        (frame) => shadowFeatures !== void 0 || !shadowViewCacheReuse(frame, { kind: "directional", index: cascade }),
+        (frame) => {
+          forceRasterEncodePending = false;
+          if (forceRasterPending) {
+            forceRasterPending = false;
+            forceRasterEncodePending = true;
+            return true;
+          }
+          return shadowFeatures !== void 0 || !shadowViewCacheReuse(frame, { kind: "directional", index: cascade });
+        },
         [
           ...shadowProjection?.ok === true && shadowProjection.value?.graphResources !== void 0 ? shadowViewRasterAccesses(shadowProjection.value.graphResources) : [],
           ...shadowFeatures?.accesses ?? []
@@ -6508,6 +6743,7 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
           face
         });
         if (shadowProjection !== void 0 && !shadowProjection.ok) return shadowProjection;
+        let forceRasterPending = true;
         const identity = { kind: "point", index: pointIndex, face };
         const cacheReuse = (frame) => shadowViewCacheReuse(frame, identity);
         const faceView = graph.view(texture.value, {
@@ -6532,7 +6768,13 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
             face,
             shadowFeatures === void 0 ? void 0 : (view) => shadowFeatures.encode(pass, frame, resources, view)
           ),
-          (frame) => shadowFeatures !== void 0 || !cacheReuse(frame),
+          (frame) => {
+            if (forceRasterPending) {
+              forceRasterPending = false;
+              return true;
+            }
+            return shadowFeatures !== void 0 || !cacheReuse(frame);
+          },
           [
             ...shadowProjection?.ok === true && shadowProjection.value?.graphResources !== void 0 ? shadowViewRasterAccesses(shadowProjection.value.graphResources) : [],
             ...shadowFeatures?.accesses ?? []
@@ -6550,6 +6792,7 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
   for (let spotIndex = 0; spotIndex < Math.max(1, topology.shadow.spotCount); spotIndex += 1) {
     const shadowProjection = projectGpuDrivenShadow?.({ kind: "spot", index: spotIndex });
     if (shadowProjection !== void 0 && !shadowProjection.ok) return shadowProjection;
+    let forceRasterPending = true;
     const identity = { kind: "spot", index: spotIndex };
     const cacheReuse = (frame) => shadowViewCacheReuse(frame, identity);
     const added = recordShadowPass(
@@ -6563,7 +6806,13 @@ function addTypedShadowPasses(graph, topology, projectGpuDrivenShadowOrFeatures,
         spotIndex,
         shadowFeatures === void 0 ? void 0 : (view) => shadowFeatures.encode(pass, frame, resources, view)
       ),
-      (frame) => shadowFeatures !== void 0 || !cacheReuse(frame),
+      (frame) => {
+        if (forceRasterPending) {
+          forceRasterPending = false;
+          return true;
+        }
+        return shadowFeatures !== void 0 || !cacheReuse(frame);
+      },
       [
         ...shadowProjection?.ok === true && shadowProjection.value?.graphResources !== void 0 ? shadowViewRasterAccesses(shadowProjection.value.graphResources) : [],
         ...shadowFeatures?.accesses ?? []
@@ -9592,7 +9841,7 @@ function prepareStandardLutGpu(input) {
   if (!asset.ok) {
     return failure2(
       "standard-lut-residency-failed",
-      "the authored TextureAsset handle resolves in the active World",
+      "the authored TextureAsset handle resolves in the active RenderResourceScope",
       "register or rebuild the TextureAsset, then retry the same camera generation",
       causeDetail(asset.error)
     );
@@ -13033,6 +13282,75 @@ function projectCaptureScene(retained, visible, displayDispatch) {
     })
   };
 }
+function renderTime(source) {
+  return "resolveAsset" in source ? source.time : source.getResource(Time);
+}
+function renderAssetByGuid(source, assets, guid) {
+  return "resolveAsset" in source ? source.lookupAsset(typeof guid === "string" ? guid : AssetGuid.format(guid)) : assets.lookup(guid);
+}
+
+// src/publication/prepare-geometry.ts
+function preparePublicationGeometry(input, scene, palette, assets, instances, getMaterialShaderArtifact) {
+  const replacements = /* @__PURE__ */ new Map();
+  for (const operation of input.operations) {
+    if (operation.kind !== "remove" && operation.snapshot === void 0) continue;
+    if (operation.kind === "remove" || operation.snapshot?.instances === void 0)
+      instances.release(input.resources, operation.entityKey);
+    const prior = scene.compositionSlot(0, operation.entityKey)?.snapshot.skin;
+    const pose = operation.kind === "remove" ? void 0 : operation.snapshot?.skinPose;
+    if (prior !== void 0 && prior.identity !== pose?.identity)
+      palette?.releasePersistentSlice(prior.identity);
+  }
+  for (const row of input.frame.renderables) {
+    const { skinPose, ...source } = row;
+    let skin = row.skin;
+    if (skinPose !== void 0) {
+      if (palette == null)
+        throw new RenderPublicationError({
+          reason: "unsupported",
+          subject: "skin palette allocator"
+        });
+      palette.observePersistentJoints(
+        skinPose.identity,
+        skinPose.inverseBindMatrices,
+        skinPose.jointWorlds
+      );
+      skin = palette.allocatePersistentSlice(skinPose);
+      palette.writePersistentJointPalette(skin, skinPose.inverseBindMatrices, skinPose.jointWorlds);
+    }
+    const projected = row.instances === void 0 ? void 0 : instances.project(input.resources, row.entityKey, row.instances.transforms);
+    const snapshot = {
+      ...source,
+      ...skin === void 0 ? {} : { skin },
+      ...projected === void 0 || row.instances === void 0 ? {} : { instances: { ...row.instances, ...projected, archVersion: 0 } }
+    };
+    if (projected !== void 0) instances.accept(input.resources, row.entityKey, projected);
+    const mesh = input.resources.resolveAsset(
+      row.assetHandle
+    );
+    if (!mesh.ok) throw mesh.error;
+    const gpuDrivenDraws = row.morph === void 0 ? buildGpuDrivenDraws({
+      mesh: mesh.value,
+      materials: row.materials,
+      fallbackMaterial: row.material,
+      baseSnapshot: snapshot,
+      ...getMaterialShaderArtifact === void 0 ? {} : { getMaterialShaderArtifact },
+      ...row.lods === void 0 ? {} : {
+        lodMeshes: row.lods.map(
+          (lod) => renderAssetByGuid(input.resources, assets, lod.mesh)
+        )
+      }
+    }) : [];
+    replacements.set(row.entityKey, { ...snapshot, gpuDrivenDraws });
+  }
+  return {
+    ...input,
+    frame: { ...input.frame, renderables: [...replacements.values()] },
+    operations: input.operations.map(
+      (operation) => operation.kind !== "remove" && operation.snapshot !== void 0 ? { ...operation, snapshot: replacements.get(operation.entityKey) } : operation
+    )
+  };
+}
 
 // src/assembly/directional-shadow-inspection.ts
 function deepFreeze2(value, seen = /* @__PURE__ */ new WeakSet()) {
@@ -14641,8 +14959,8 @@ var MaterialAbiRasterAdapter = class _MaterialAbiRasterAdapter {
       return;
     }
     if (!this.pendingProjectionRetirements.add(buffer)) return;
-    const token2 = this.allocationTokens.get(buffer);
-    if (token2 !== void 0) this.allocationLedger.retire(token2);
+    const token = this.allocationTokens.get(buffer);
+    if (token !== void 0) this.allocationLedger.retire(token);
     void this.device.queue.onSubmittedWorkDone().then(
       () => {
         this.pendingProjectionRetirements.delete(buffer);
@@ -14659,8 +14977,8 @@ var MaterialAbiRasterAdapter = class _MaterialAbiRasterAdapter {
     this.destroyedProjectionBuffers.add(buffer);
     this.projectionBuffers.delete(buffer);
     this.surfaceInputBuffers.delete(buffer);
-    const token2 = this.allocationTokens.get(buffer);
-    if (token2 !== void 0) this.allocationLedger.release(token2);
+    const token = this.allocationTokens.get(buffer);
+    if (token !== void 0) this.allocationLedger.release(token);
     this.device.destroyBuffer(buffer);
   }
   trackOwnedBuffer(buffer, bytes2) {
@@ -14673,8 +14991,8 @@ var MaterialAbiRasterAdapter = class _MaterialAbiRasterAdapter {
     this.projectionBuffers.delete(buffer);
     this.surfaceInputBuffers.delete(buffer);
     this.pendingProjectionRetirements.delete(buffer);
-    const token2 = this.allocationTokens.get(buffer);
-    if (token2 !== void 0) this.allocationLedger.rollback(token2);
+    const token = this.allocationTokens.get(buffer);
+    if (token !== void 0) this.allocationLedger.rollback(token);
     this.device.destroyBuffer(buffer);
   }
   get instancesFrameGroup() {
@@ -16267,7 +16585,14 @@ var GpuDrivenProduction = class _GpuDrivenProduction {
       };
     }
     const shadowTopologySignature = () => this.shadowViews?.inspect().map(
-      (entry) => `${shadowViewIdentityKey(entry.identity)}:${entry.cache}:${entry.generation}:${entry.sourceRevision}:${entry.resourceGeneration}`
+      (entry) => (
+        // Cache decisions and logical update generations are frame-local
+        // producer state. They must not feed the compiled graph key: a
+        // graph replacement may intentionally invalidate a shadow view
+        // once without creating a graph-rebuild feedback loop. Resource
+        // and source-plan generations remain real graph dependencies.
+        `${shadowViewIdentityKey(entry.identity)}:${entry.sourceRevision}:${entry.resourceGeneration}`
+      )
     ).join("|") ?? "";
     const production = this;
     const surfaceDynamicInputForCommit = this.surfaceSubmission !== void 0 && input.surfaceDynamicInput !== void 0 ? {
@@ -16368,10 +16693,10 @@ var GpuDrivenProduction = class _GpuDrivenProduction {
           frameNumber
         )
       },
-      projectShadow: (graph, identity) => {
+      projectShadow: (graph, identity, forceCompute = false) => {
         if (!shadowViewPool.isActive(identity) || shadowViewPool.submission(identity) === void 0)
           return ok(void 0);
-        return shadowViewPool.project(graph, identity);
+        return shadowViewPool.project(graph, identity, forceCompute);
       },
       updateShadowViews: (views) => shadowFiltered.plan.batches.length > 0 ? this.updateShadowViews(
         views,
@@ -20189,7 +20514,9 @@ function validateRenderables(internals, world, worlds, pipelineState, frameState
     }
     const meshAssetHandle = toShared(r.assetHandle);
     let meshHandles = internals.gpuStore.getMeshGpuHandles(meshAssetHandle, renderableWorld);
-    const lodMeshes = r.lods?.map((lod) => internals.assets.lookup(lod.mesh));
+    const lodMeshes = r.lods?.map(
+      (lod) => renderAssetByGuid(renderableWorld, internals.assets, lod.mesh)
+    );
     const resolvedLodMeshes = lodMeshes?.every((lod) => lod?.kind === "mesh") === true ? lodMeshes : void 0;
     if (meshHandles === void 0 && r.assetHandle > handleSlot(HANDLE_NINESLICE_QUAD)) {
       const residentRes = internals.gpuStore.ensureResident(
@@ -21008,157 +21335,197 @@ function inspectBarrelDistortionState(state, deviceGeneration) {
     lastKnownGood: mapping !== void 0 && state.compiledFrameGraph !== null && state.barrelDistortionGraphResolution === "retained"
   });
 }
-
-// src/record/frame-targets.ts
-function graphExecutionPhase(passName) {
-  if (passName.startsWith("shadowCascade")) return "record/graph-execute/shadow";
-  if (passName.startsWith("point-shadow")) return "record/graph-execute/point-shadow";
-  if (passName.startsWith("spot-shadow")) return "record/graph-execute/spot-shadow";
-  if (passName === "ssr-hiz-seed" || passName.startsWith("ssr-hiz-reduce-")) {
-    return "record/graph-execute/ssr-hiz";
-  }
-  if (passName === "ssr-trace") return "record/graph-execute/ssr-trace";
-  if (passName === "ssr-temporal") return "record/graph-execute/ssr-temporal";
-  if (passName.startsWith("ssr-reflection-mip-")) {
-    return "record/graph-execute/ssr-reflection-mip";
-  }
-  if (passName === "ssr-compose") return "record/graph-execute/ssr-compose";
-  if (passName.startsWith("bloom-downsample-")) {
-    return "record/graph-execute/bloom-downsample";
-  }
-  if (passName.startsWith("bloom-upsample-")) {
-    return "record/graph-execute/bloom-upsample";
-  }
-  switch (passName) {
-    case "cluster-binner-upload":
-    case "cluster-membership-producer":
-      return "record/graph-execute/cluster-binner-upload";
-    case "g-buffer":
-      return "record/graph-execute/g-buffer";
-    case "ssao-calc":
-      return "record/graph-execute/ssao-calc";
-    case "ssao-blur":
-      return "record/graph-execute/ssao-blur";
-    case "lighting":
-      return "record/graph-execute/lighting";
-    case "forward":
-    case "transmission-forward":
-      return "record/graph-execute/forward";
-    case "output-transform":
-      return "record/graph-execute/output-transform";
-    case "present":
-      return "record/graph-execute/present";
-    case "debug-overlay":
-      return "record/graph-execute/debug-overlay";
-    case "shadow":
-      return "record/graph-execute/shadow";
-    case "skybox":
-      return "record/graph-execute/skybox";
-    case "main":
-      return "record/graph-execute/main";
-    case "fxaa":
-      return "record/graph-execute/fxaa";
-    case "bloom-downsample":
-      return "record/graph-execute/bloom-downsample";
-    case "bloom-upsample":
-      return "record/graph-execute/bloom-upsample";
-    case "bloom-composite":
-      return "record/graph-execute/bloom-composite";
-    default:
-      return "record/graph-execute/other";
-  }
+function renderTargetMipCount(work) {
+  const { descriptor } = work.physical;
+  return descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
 }
-function resolveRenderTargetMipExtent(descriptor, mipLevel) {
-  const mipCount2 = descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
-  const level = Math.max(0, Math.min(mipLevel, mipCount2 - 1));
-  return {
-    width: Math.max(1, descriptor.width >> level),
-    height: Math.max(1, descriptor.height >> level)
-  };
-}
-function acquireSwapChainTarget(internals, pipelineState) {
-  const canvasContext = internals.context;
-  if (canvasContext === null) return null;
-  let currentTextureResult = canvasContext.getCurrentTexture();
-  if (!currentTextureResult.ok) {
-    const configuredDevice = internals.resolveSurfaceDevice?.(internals.device);
-    if (configuredDevice !== void 0 && !configuredDevice.ok) {
-      internals.errorRegistry.fire(configuredDevice.error);
-      internals.healthRegistry.fire({
-        reason: "internal-fault",
-        detail: { message: "surface device resolution failed; current frame skipped" },
-        recoverable: true
-      });
-      return null;
-    }
-    const configured = configureSurface(
-      canvasContext,
-      configuredDevice?.value ?? internals.device,
-      pipelineState.format,
-      pipelineState.colorAttachmentFormat
+function addTargetCaptureGraphPasses(builder, state) {
+  for (let index = 0; index < state.work.length; index += 1) {
+    const slot = index;
+    const initial = state.work[slot];
+    if (initial === void 0) continue;
+    const current = () => state.work[slot] ?? initial;
+    const texture = builder.importTexture(
+      `cube-capture.${slot}.texture`,
+      {
+        format: initial.physical.descriptor.format,
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 || initial.physical.descriptor.shape === "2d" ? 1 : 6
+        },
+        mipLevelCount: initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: "2d",
+        usage: 16 | 4 | 1
+      },
+      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture
     );
-    if (!configured.ok) {
-      internals.errorRegistry.fire(configured.error);
-      internals.healthRegistry.fire({
-        reason: "internal-fault",
-        detail: { message: "surface configure candidate failed; current frame skipped" },
-        recoverable: true
-      });
-      return null;
-    }
-    pipelineState.perPassResources.configured = true;
-    globalThis.__forgeaxSwapChainFormat = pipelineState.format;
-    const retry = canvasContext.getCurrentTexture();
-    if (!retry.ok) {
-      internals.errorRegistry.fire(retry.error);
-      internals.healthRegistry.fire({
-        reason: "internal-fault",
-        detail: {
-          message: "surface-configure-failed after retry: getCurrentTexture failed twice consecutively"
+    if (!texture.ok) return texture;
+    const color = builder.importView(
+      texture.value,
+      {
+        label: `cube-capture.${slot}.color`,
+        dimension: "2d",
+        baseMipLevel: 0,
+        mipLevelCount: 1,
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1
+      },
+      () => current().physical.faceViews[current().faceIndex] ?? initial.physical.faceViews[initial.faceIndex] ?? initial.physical.view
+    );
+    if (!color.ok) return color;
+    const depthTexture = builder.importTexture(
+      `cube-capture.${slot}.depth-texture`,
+      {
+        format: "depth24plus-stencil8",
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 || initial.physical.descriptor.shape === "2d" ? 1 : 6
         },
-        recoverable: false
-      });
-      return null;
-    }
-    currentTextureResult = retry;
-  }
-  const viewDescriptor = pipelineState.colorAttachmentFormat === pipelineState.format ? {} : { format: pipelineState.colorAttachmentFormat };
-  const viewResult = internals.device.createTextureView(currentTextureResult.value, viewDescriptor);
-  if (!viewResult.ok) {
-    internals.errorRegistry.fire(viewResult.error);
-    return null;
+        mipLevelCount: 1,
+        sampleCount: initial.physical.descriptor.sampleCount,
+        dimension: "2d",
+        usage: 16
+      },
+      () => current().physical.depthTextures[current().faceIndex]
+    );
+    if (!depthTexture.ok) return depthTexture;
+    const depth = builder.importView(
+      depthTexture.value,
+      {
+        label: `cube-capture.${slot}.depth`,
+        dimension: "2d",
+        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
+        arrayLayerCount: 1
+      },
+      () => current().physical.depthViews[current().faceIndex]
+    );
+    if (!depth.ok) return depth;
+    const resolveTexture = initial.physical.descriptor.sampleCount === 4 ? builder.importTexture(
+      `cube-capture.${slot}.resolve-texture`,
+      {
+        format: initial.physical.descriptor.format,
+        size: {
+          width: initial.physical.descriptor.width,
+          height: initial.physical.descriptor.height,
+          depthOrArrayLayers: initial.physical.descriptor.shape === "cube" ? 6 : 1
+        },
+        mipLevelCount: renderTargetMipCount(initial),
+        sampleCount: 1,
+        dimension: "2d",
+        usage: 16 | 4 | 1
+      },
+      () => current().physical.resolveTexture ?? initial.physical.resolveTexture ?? initial.physical.texture
+    ) : void 0;
+    if (resolveTexture !== void 0 && !resolveTexture.ok) return resolveTexture;
+    const resolve = resolveTexture === void 0 ? void 0 : builder.importView(
+      resolveTexture.value,
+      {
+        label: `cube-capture.${slot}.resolve`,
+        dimension: "2d",
+        baseMipLevel: 0,
+        mipLevelCount: 1,
+        baseArrayLayer: initial.faceIndex,
+        arrayLayerCount: 1
+      },
+      () => current().physical.resolveFaceViews[current().faceIndex] ?? initial.physical.resolveFaceViews[initial.faceIndex] ?? initial.physical.resolveView
+    );
+    if (resolve !== void 0 && !resolve.ok) return resolve;
+    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
+      accesses: [
+        { resource: color.value, usage: "color-attachment" },
+        { resource: depth.value, usage: "depth-stencil-write" },
+        ...resolve === void 0 ? [] : [{ resource: resolve.value, usage: "color-attachment" }]
+      ],
+      colorAttachments: [
+        {
+          view: color.value,
+          ...resolve === void 0 ? {} : { resolveTarget: resolve.value },
+          loadOp: "clear",
+          storeOp: "store",
+          clearValue: () => {
+            const clear = current().physical.descriptor.shape === "2d" ? current().faceCamera.clearColor : [0, 0, 0, 1];
+            return { r: clear[0] ?? 0, g: clear[1] ?? 0, b: clear[2] ?? 0, a: clear[3] ?? 1 };
+          }
+        }
+      ],
+      depthStencilAttachment: {
+        view: depth.value,
+        depthClearValue: 1,
+        depthLoadOp: "clear",
+        depthStoreOp: "store",
+        stencilClearValue: 0,
+        stencilLoadOp: "clear",
+        stencilStoreOp: "store"
+      },
+      encode: ({ pass, frame, resources }) => {
+        const internal = frame;
+        const captureColor = resources.textureView(color.value);
+        if (!captureColor.ok) return;
+        const captureDepth = resources.textureView(depth.value);
+        if (!captureDepth.ok) return;
+        const captureResolve = resolve === void 0 ? void 0 : resources.textureView(resolve.value);
+        if (resolve !== void 0 && (captureResolve === void 0 || !captureResolve.ok)) return;
+        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
+        const selfSampling = /* @__PURE__ */ new Map();
+        for (const row of internal.validatedOrdered) {
+          for (const material of row.source.materials) {
+            if (![...material.textureSources?.values() ?? []].some(
+              (source) => resolveRenderTargetMaterialSource(source)?.target === current().target
+            ))
+              continue;
+            let handles = selfSampling.get(row.renderableIndex);
+            if (handles === void 0) {
+              handles = /* @__PURE__ */ new Set();
+              selfSampling.set(row.renderableIndex, handles);
+            }
+            handles.add(material.materialHandle ?? 0);
+          }
+        }
+        const captureContext = {
+          ...internal,
+          camera: current().faceCamera,
+          targetW: current().physical.descriptor.width,
+          targetH: current().physical.descriptor.height,
+          dispatch: (internal.captureDispatch ?? internal.dispatch).filter(
+            (entry) => !selfSampling.get(entry.renderableIndex)?.has(entry.materialHandle)
+          ),
+          foldDispatchPlan: null,
+          // Cube faces are raw scene captures, not display-camera HDR output.
+          // Select the PSO against the actual target attachment so an LDR
+          // cube target is rendered by a compatible forward pipeline.
+          tonemapActive: false,
+          skyboxActive: false,
+          transparentColorFormat: initial.physical.descriptor.format,
+          msaaActive: initial.physical.descriptor.sampleCount === 4,
+          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
+          geometryColorView: captureColor.value,
+          geometryDepthView: captureDepth.value,
+          geometryColorResolveView: captureResolveView,
+          splitLdrSprite: false,
+          ldrSpritePassView: null
+        };
+        delete captureContext.gpuDrivenDrawKeys;
+        delete captureContext.gpuDrivenStandardPbrFrameResources;
+        encodeMainPass(
+          captureContext,
+          pass,
+          { LightMode: ["Forward"] },
+          {
+            colorViews: [captureColor.value],
+            colorFormats: [initial.physical.descriptor.format],
+            depthView: captureDepth.value,
+            passKind: "forward",
+            clearColor: current().physical.descriptor.shape === "2d" ? current().faceCamera.clearColor : [0, 0, 0, 1]
+          }
+        );
+      }
+    });
+    if (!added.ok) return added;
   }
-  return {
-    currentTexture: currentTextureResult.value,
-    view: viewResult.value,
-    targetW: internals.canvas.width | 0,
-    targetH: internals.canvas.height | 0
-  };
-}
-function resolveShadowMapSize(internals, lights) {
-  if (lights.cascadeCount === void 0) return void 0;
-  const requested = lights.shadowMapSize;
-  if (!(requested !== void 0 && requested > 0)) return requested;
-  const cascades = Math.max(1, Math.min(4, Math.round(lights.cascadeCount ?? 1)));
-  const atlasGrid = resolveDirectionalShadowAtlasGrid(cascades);
-  const maxDimension = internals.device.limits.maxTextureDimension2D;
-  if (!(maxDimension > 0)) return Math.floor(requested);
-  const depthTextureDimension = internals.device.caps?.backendKind === "wgpu-webgl2" ? Math.max(1, Math.floor(maxDimension / 2)) : maxDimension;
-  const maxPerTile = Math.max(
-    1,
-    Math.floor(depthTextureDimension / Math.max(atlasGrid.columns, atlasGrid.rows))
-  );
-  return Math.max(1, Math.min(Math.floor(requested), maxPerTile));
-}
-function resolveSpotShadowMapSize(internals, lights) {
-  const requested = lights.spot.find(
-    (spot) => spot.shadowAtlasTile >= 0 && spot.lightViewProj !== void 0
-  )?.mapSize;
-  if (!(requested !== void 0 && requested > 0)) return requested;
-  const maxDimension = internals.device.limits.maxTextureDimension2D;
-  if (!(maxDimension > 0)) return Math.floor(requested);
-  const maxPerTile = Math.max(1, Math.floor(maxDimension / 2));
-  return Math.max(1, Math.min(Math.floor(requested), maxPerTile));
+  return ok$1(void 0);
 }
 
 // src/assembly/renderer-frame-transaction.ts
@@ -22195,169 +22562,6 @@ function isMotionBlurTemporalDemand(motionBlur) {
     targetFps: motionBlur.targetFps ?? 60
   });
 }
-function renderTargetMipCount(work) {
-  const { descriptor } = work.physical;
-  return descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
-}
-function addCubeCaptureGraphPasses(builder, state) {
-  for (let index = 0; index < state.work.length; index += 1) {
-    const slot = index;
-    const initial = state.work[slot];
-    if (initial === void 0) continue;
-    const current = () => state.work[slot] ?? initial;
-    const texture = builder.importTexture(
-      `cube-capture.${slot}.texture`,
-      {
-        format: initial.physical.descriptor.format,
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6
-        },
-        mipLevelCount: initial.physical.descriptor.sampleCount === 4 ? 1 : renderTargetMipCount(initial),
-        sampleCount: initial.physical.descriptor.sampleCount,
-        dimension: "2d",
-        usage: 16 | 4 | 1
-      },
-      () => current().physical.colorTextures[current().faceIndex] ?? initial.physical.texture
-    );
-    if (!texture.ok) return texture;
-    const color = builder.importView(
-      texture.value,
-      {
-        label: `cube-capture.${slot}.color`,
-        dimension: "2d",
-        baseMipLevel: 0,
-        mipLevelCount: 1,
-        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
-        arrayLayerCount: 1
-      },
-      () => current().physical.faceViews[current().faceIndex] ?? initial.physical.faceViews[initial.faceIndex] ?? initial.physical.view
-    );
-    if (!color.ok) return color;
-    const depthTexture = builder.importTexture(
-      `cube-capture.${slot}.depth-texture`,
-      {
-        format: "depth24plus-stencil8",
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: initial.physical.descriptor.sampleCount === 4 ? 1 : 6
-        },
-        mipLevelCount: 1,
-        sampleCount: initial.physical.descriptor.sampleCount,
-        dimension: "2d",
-        usage: 16
-      },
-      () => current().physical.depthTextures[current().faceIndex]
-    );
-    if (!depthTexture.ok) return depthTexture;
-    const depth = builder.importView(
-      depthTexture.value,
-      {
-        label: `cube-capture.${slot}.depth`,
-        dimension: "2d",
-        baseArrayLayer: initial.physical.descriptor.sampleCount === 4 ? 0 : initial.faceIndex,
-        arrayLayerCount: 1
-      },
-      () => current().physical.depthViews[current().faceIndex]
-    );
-    if (!depth.ok) return depth;
-    const resolveTexture = initial.physical.descriptor.sampleCount === 4 ? builder.importTexture(
-      `cube-capture.${slot}.resolve-texture`,
-      {
-        format: initial.physical.descriptor.format,
-        size: {
-          width: initial.physical.descriptor.width,
-          height: initial.physical.descriptor.height,
-          depthOrArrayLayers: 6
-        },
-        mipLevelCount: renderTargetMipCount(initial),
-        sampleCount: 1,
-        dimension: "2d",
-        usage: 16 | 4 | 1
-      },
-      () => current().physical.resolveTexture ?? initial.physical.resolveTexture ?? initial.physical.texture
-    ) : void 0;
-    if (resolveTexture !== void 0 && !resolveTexture.ok) return resolveTexture;
-    const resolve = resolveTexture === void 0 ? void 0 : builder.importView(
-      resolveTexture.value,
-      {
-        label: `cube-capture.${slot}.resolve`,
-        dimension: "2d",
-        baseMipLevel: 0,
-        mipLevelCount: 1,
-        baseArrayLayer: initial.faceIndex,
-        arrayLayerCount: 1
-      },
-      () => current().physical.resolveFaceViews[current().faceIndex] ?? initial.physical.resolveFaceViews[initial.faceIndex] ?? initial.physical.resolveView
-    );
-    if (resolve !== void 0 && !resolve.ok) return resolve;
-    const added = builder.addRasterPass(`cube-capture-face.${slot}`, {
-      accesses: [
-        { resource: color.value, usage: "color-attachment" },
-        { resource: depth.value, usage: "depth-stencil-write" },
-        ...resolve === void 0 ? [] : [{ resource: resolve.value, usage: "color-attachment" }]
-      ],
-      colorAttachments: [
-        {
-          view: color.value,
-          ...resolve === void 0 ? {} : { resolveTarget: resolve.value },
-          loadOp: "clear",
-          storeOp: "store",
-          clearValue: () => {
-            return { r: 0, g: 0, b: 0, a: 1 };
-          }
-        }
-      ],
-      depthStencilAttachment: {
-        view: depth.value,
-        depthClearValue: 1,
-        depthLoadOp: "clear",
-        depthStoreOp: "store",
-        stencilClearValue: 0,
-        stencilLoadOp: "clear",
-        stencilStoreOp: "store"
-      },
-      encode: ({ pass, frame, resources }) => {
-        const internal = frame;
-        const captureColor = resources.textureView(color.value);
-        if (!captureColor.ok) return;
-        const captureDepth = resources.textureView(depth.value);
-        if (!captureDepth.ok) return;
-        const captureResolve = resolve === void 0 ? void 0 : resources.textureView(resolve.value);
-        if (resolve !== void 0 && (captureResolve === void 0 || !captureResolve.ok)) return;
-        const captureResolveView = captureResolve?.ok ? captureResolve.value : null;
-        const captureContext = {
-          ...internal,
-          camera: current().faceCamera,
-          // Cube faces are raw scene captures, not display-camera HDR output.
-          // Select the PSO against the actual target attachment so an LDR
-          // cube target is rendered by a compatible forward pipeline.
-          tonemapActive: false,
-          skyboxActive: false,
-          transparentColorFormat: initial.physical.descriptor.format,
-          msaaActive: initial.physical.descriptor.sampleCount === 4,
-          viewBindGroupDynamicOffset: current().viewBindGroupDynamicOffset,
-          geometryColorView: captureColor.value,
-          geometryDepthView: captureDepth.value,
-          geometryColorResolveView: captureResolveView,
-          splitLdrSprite: false,
-          ldrSpritePassView: null
-        };
-        encodeMainPass(captureContext, pass, void 0, {
-          colorViews: [captureColor.value],
-          colorFormats: [initial.physical.descriptor.format],
-          depthView: captureDepth.value,
-          passKind: "forward",
-          clearColor: [0, 0, 0, 1]
-        });
-      }
-    });
-    if (!added.ok) return added;
-  }
-  return ok$1(void 0);
-}
 function addReflectionProbeGraphPasses(builder, state, environmentCube) {
   const accesses = [];
   for (const work of state.work) {
@@ -23581,7 +23785,7 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
     // renderer-owned and read dynamically by the compiled pass, so a page
     // rotation must not invalidate the graph or its cached bind groups.
     occlusionQuery: occlusion === void 0 ? void 0 : { active: true, sampleCount: occlusion.sampleCount },
-    cubeCaptureSlots: cubeCaptureState?.work.length ?? 0,
+    cubeCaptureSlots: cubeCaptureState?.work.map((work) => work.physical.descriptor),
     reflectionProbeSlots: cubeCaptureState?.reflectionProbes?.work.map((work) => [
       work.probeIndex,
       work.rawCaptureFace ?? -1,
@@ -23717,7 +23921,13 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
         );
       },
       ...gpuDriven?.projectShadow === void 0 ? {} : {
-        projectGpuDrivenShadow: (identity) => gpuDriven.projectShadow?.(builder, identity) ?? ok$1(void 0)
+        projectGpuDrivenShadow: (identity) => (
+          // A newly compiled graph must include the shadow compute passes
+          // even when the producer cache hit. The graph owns its pass
+          // list; importing only the cached view resources would reuse
+          // stale indirect arguments after a topology replacement.
+          gpuDriven.projectShadow?.(builder, identity, true) ?? ok$1(void 0)
+        )
       },
       contributeShadowFeatures: () => featureShadows ??= projectRenderFeatureShadows(
         builder,
@@ -23765,7 +23975,7 @@ function ensureCompiledFrameGraph(internals, frameState, pipelineState, camera,
           environmentCube
         );
         if (!reflectionProbes.ok) return reflectionProbes;
-        return cubeCaptureState === void 0 ? ok$1(void 0) : addCubeCaptureGraphPasses(builder, cubeCaptureState);
+        return cubeCaptureState === void 0 ? ok$1(void 0) : addTargetCaptureGraphPasses(builder, cubeCaptureState);
       },
       hasFeature: (identity) => projectedFeaturePlans.value.some((execution) => execution.featureIdentity === identity),
       hasFeatureWork: (identity, placement) => projectedFeaturePlans.value.some(
@@ -24822,7 +25032,7 @@ function gpuDrivenMeshesForFrame(internals, pipelineState, worlds, scene) {
       const asset = resolveAssetHandle(world, sharedHandle);
       if (asset.ok) {
         const lodMeshes = slot.snapshot.lods?.map(
-          (lod) => internals.assets.lookup(lod.mesh)
+          (lod) => renderAssetByGuid(world, internals.assets, lod.mesh)
         );
         const resolvedLodMeshes = lodMeshes?.every((lod) => lod?.kind === "mesh") === true ? lodMeshes : void 0;
         const resident = internals.gpuStore.ensureResident(
@@ -24883,6 +25093,18 @@ function prepareCubeCapture(internals, input, displayCamera) {
       viewBindGroupDynamicOffset: (CUBE_CAPTURE_VIEW_SLOT_BASE + physicalWork.length) * VIEW_UNIFORM_SLOT_STRIDE
     });
   }
+  for (const camera of input.auxiliaryCameras) {
+    if (camera.target === void 0) continue;
+    const physical = internals.getRenderTargetPhysical?.(camera.target);
+    if (physical?.descriptor.shape !== "2d") continue;
+    physicalWork.push({
+      target: camera.target,
+      faceIndex: 0,
+      physical,
+      faceCamera: camera,
+      viewBindGroupDynamicOffset: (CUBE_CAPTURE_VIEW_SLOT_BASE + 6) * VIEW_UNIFORM_SLOT_STRIDE
+    });
+  }
   input.state.work = physicalWork;
   return physicalWork;
 }
@@ -24904,8 +25126,32 @@ function runRecordProfilePhase(runner, phase, action) {
 function shadowPlanes(matrix) {
   return frustum.fromViewProjection(frustum.create(), matrix);
 }
-function shadowViewToken(matrix) {
-  return Array.from(matrix).join(",");
+function shadowViewPlanesByView(lights) {
+  const views = /* @__PURE__ */ new Map();
+  for (const [index, matrix] of (lights.lightViewProj ?? []).entries()) {
+    views.set(shadowViewIdentityKey({ kind: "directional", index }), shadowPlanes(matrix));
+  }
+  for (const [index, point] of lights.pointShadow.entries()) {
+    for (let face = 0; face < 6; face += 1) {
+      views.set(
+        shadowViewIdentityKey({ kind: "point", index, face }),
+        shadowPlanes(point.shadowMatrices.subarray(face * 16, face * 16 + 16))
+      );
+    }
+  }
+  let spotIndex = 0;
+  for (const spot of lights.spot) {
+    if (spot.lightViewProj === void 0) continue;
+    views.set(
+      shadowViewIdentityKey({ kind: "spot", index: spotIndex }),
+      shadowPlanes(spot.lightViewProj)
+    );
+    spotIndex += 1;
+  }
+  return views;
+}
+function shadowViewToken(matrix, targetSize, graphGeneration) {
+  return `${Array.from(matrix).join(",")}|target:${targetSize}|graph:${graphGeneration}`;
 }
 function halfFloatToNumber(bits) {
   const sign = (bits & 32768) === 0 ? 1 : -1;
@@ -25270,7 +25516,7 @@ function frameClockSample(world, worlds, camera, sampleTimeSeconds) {
   const owner = worlds[camera.worldId ?? 0] ?? world;
   const invalidSampleTime = sampleTimeSeconds !== void 0 && !Number.isFinite(sampleTimeSeconds);
   try {
-    const clock = owner.getResource(Time);
+    const clock = renderTime(owner);
     return {
       deltaSeconds: Number.isFinite(clock.delta) ? Math.max(0, clock.delta) : 0,
       // Keep the raw host sample even when ECS accepted only a clamped
@@ -25807,7 +26053,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
           shadowViews.push({
             identity: { kind: "directional", index },
             planes: shadowPlanes(matrix),
-            cacheToken: `${shadowViewToken(matrix)}|target:${graphShadowMapSize}:${frameState.graphGeneration}`
+            cacheToken: shadowViewToken(matrix, graphShadowMapSize, frameState.graphGeneration)
           });
         }
         for (const [index, point] of lights.pointShadow.entries()) {
@@ -25816,7 +26062,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
             shadowViews.push({
               identity: { kind: "point", index, face },
               planes: shadowPlanes(matrix),
-              cacheToken: `${shadowViewToken(matrix)}|target:${graphShadowMapSize}:${frameState.graphGeneration}`
+              cacheToken: shadowViewToken(matrix, graphShadowMapSize, frameState.graphGeneration)
             });
           }
         }
@@ -25826,7 +26072,11 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
           shadowViews.push({
             identity: { kind: "spot", index: shadowSpotIndex },
             planes: shadowPlanes(spot.lightViewProj),
-            cacheToken: `${shadowViewToken(spot.lightViewProj)}|target:${graphShadowMapSize}:${frameState.graphGeneration}`
+            cacheToken: shadowViewToken(
+              spot.lightViewProj,
+              graphShadowMapSize,
+              frameState.graphGeneration
+            )
           });
           shadowSpotIndex += 1;
         }
@@ -26380,6 +26630,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
           gpuDrivenShadowDrawKeysByView: rasterGpuDriven.shadowDrawKeysByView
         }
       },
+      shadowViewPlanesByView: shadowViewPlanesByView(lights),
       ...frameGpuDriven?.scene === void 0 ? {} : { gpuDrivenSceneMaterialBuffer: frameGpuDriven.scene.scene.materialBuffer },
       ...cubeCapture?.reflectionProbes === void 0 ? {} : { reflectionProbes: cubeCapture.reflectionProbes },
       ...cubeCapture?.captureDispatch === void 0 ? {} : { captureDispatch: cubeCapture.captureDispatch },
@@ -26487,7 +26738,7 @@ function recordFrame(internals, world, cameras, lights, renderables, transparent
       }
       acknowledgeRenderFeatureSubmission(getRenderFeatureGraphState(internals).plans);
     }
-    if (cubeCapture !== void 0 && cubeCaptureWork.length > 0) {
+    if (cubeCapture !== void 0 && cubeCaptureWork.some((work) => work.physical.descriptor.shape === "cube")) {
       const completed = cubeCapture.scheduler.completeSubmission(submitted, completion);
       if (!completed.ok) internals.errorRegistry.fire(completed.error);
     }
@@ -27393,7 +27644,6 @@ function createRenderSystemRecovery(deps) {
       if (pendingOutput !== void 0) retireAutoExposureGpuResources(pendingOutput);
       candidateFrameState.pendingAutoExposureGpuResources = void 0;
       for (const work of setupWorks) work.discard();
-      setupWorks.length = 0;
       const graph = candidateFrameState.compiledFrameGraph;
       candidateFrameState.compiledFrameGraph = null;
       candidateFrameState.perFrameGraph = null;
@@ -27639,7 +27889,7 @@ function createRenderSystemRecovery(deps) {
           cloudHistory: seed.frame.cloudLayer !== void 0
         });
         const featureFrame = runRenderFeatureFrame(candidateFeatureHost, {
-          worlds: seed.worlds,
+          worlds: seed.worlds.filter((world) => !("resolveAsset" in world)),
           owner: seed.resourceOwner,
           frameNumber: candidateFrameState.frameNumber,
           selectedCamera: camera,
@@ -29113,11 +29363,11 @@ var ReflectionProbeRecordOwner = class {
       prefilterGroup0Bgl: cache.prefilterGroup0Bgl
     };
   }
-  createCubeSet(label, size, mipCount2 = PREFILTER_MIP_LEVELS) {
+  createCubeSet(label, size, mipCount = PREFILTER_MIP_LEVELS) {
     const texture = this.internals.device.createTexture({
       label,
       size: { width: size, height: size, depthOrArrayLayers: 6 },
-      mipLevelCount: mipCount2,
+      mipLevelCount: mipCount,
       sampleCount: 1,
       dimension: "2d",
       format: this.outputFormat,
@@ -29130,7 +29380,7 @@ var ReflectionProbeRecordOwner = class {
       label: `${label}-cube`,
       dimension: "cube",
       baseMipLevel: 0,
-      mipLevelCount: mipCount2,
+      mipLevelCount: mipCount,
       arrayLayerCount: 6
     });
     if (!cubeView.ok) {
@@ -29139,7 +29389,7 @@ var ReflectionProbeRecordOwner = class {
     }
     const faceViews = [];
     const mipViews = [];
-    for (let mip = 0; mip < mipCount2; mip += 1) {
+    for (let mip = 0; mip < mipCount; mip += 1) {
       const faces = [];
       for (let face = 0; face < 6; face += 1) {
         const view = this.internals.device.createTextureView(texture.value, {
@@ -29661,32 +29911,25 @@ function createPreparedResolverCaches() {
     preparedMaterialPipelineShaders: /* @__PURE__ */ new WeakMap(),
     preparedGroup0Pipelines: /* @__PURE__ */ new WeakSet(),
     preparedViewOnlyPipelines: /* @__PURE__ */ new WeakSet(),
-    preparedRenderMaterialPipelines: /* @__PURE__ */ new WeakSet(),
-    preparedAssetHandles: /* @__PURE__ */ new WeakMap()
-  };
-}
-function preparedHandle(runtime, caches, world, guid, brand) {
-  let handles = caches.preparedAssetHandles.get(world);
-  if (handles === void 0) {
-    handles = /* @__PURE__ */ new Map();
-    caches.preparedAssetHandles.set(world, handles);
-  }
-  const key = `${brand}:${guid.toLowerCase()}`;
-  const cached = handles.get(key);
-  if (cached !== void 0) return cached;
-  const asset = runtime.assets.lookup(guid);
-  if (asset === void 0) return void 0;
-  const handle = world.allocSharedRef(brand, asset);
-  handles.set(key, handle);
-  return handle;
-}
-function preparedMaterialBindings(runtime, caches, worlds, materialShaderId, worldIndex, materialGuid, layout, skylightResources) {
+    preparedRenderMaterialPipelines: /* @__PURE__ */ new WeakSet()
+  };
+}
+function preparedHandle(runtime, world, guid, brand) {
+  if ("resolveAsset" in world)
+    return world.handleForGuid(guid);
+  return internSharedRefFromGuid(world, runtime.assets, guid, brand);
+}
+function preparedMaterialBindings(runtime, worlds, materialShaderId, worldIndex, materialGuid, layout, skylightResources) {
   const world = worlds[worldIndex];
-  const material = runtime.assets.lookup(materialGuid);
+  const handle = world === void 0 ? void 0 : preparedHandle(runtime, world, materialGuid, "MaterialAsset");
   const pipelineState = runtime.getPipelineState();
-  if (world === void 0 || material?.kind !== "material" || pipelineState === null) {
+  if (world === void 0 || handle === void 0 || pipelineState === null) {
     return err(new Error("prepared material asset is unavailable"));
   }
+  const resolved2 = resolveAssetHandle(world, handle);
+  if (!resolved2.ok) return resolved2;
+  const material = resolved2.value;
+  if (material.kind !== "material") return err(new Error("prepared material asset is unavailable"));
   const schema = runtime.getParamSchema?.(materialShaderId) ?? [];
   const values = materialValuesToLinearRuntime(
     material.values,
@@ -29726,32 +29969,20 @@ function preparedMaterialBindings(runtime, caches, worlds, materialShaderId, wor
     const textureValue = typeof value === "object" && value !== null && "texture" in value ? value : void 0;
     let sampler = pipelineState.defaultSampler;
     if (textureValue?.sampler !== void 0) {
-      const handle = preparedHandle(
-        runtime,
-        caches,
-        world,
-        String(textureValue.sampler),
-        "SamplerAsset"
-      );
-      if (handle !== void 0) {
-        const asset = resolveAssetHandle(world, handle);
+      const handle2 = preparedHandle(runtime, world, String(textureValue.sampler), "SamplerAsset");
+      if (handle2 !== void 0) {
+        const asset = resolveAssetHandle(world, handle2);
         if (asset.ok) {
-          const resident = runtime.gpuStore.ensureSamplerResident(handle, asset.value, world);
+          const resident = runtime.gpuStore.ensureSamplerResident(handle2, asset.value, world);
           if (resident.ok) sampler = resident.value;
         }
       }
     }
     let view = defaultViewForUserRegionField(field, pipelineState, schema);
     if (textureValue !== void 0) {
-      const handle = preparedHandle(
-        runtime,
-        caches,
-        world,
-        String(textureValue.texture),
-        "TextureAsset"
-      );
-      if (handle !== void 0) {
-        view = residentTextureView(world, runtime.gpuStore, runtime, handle) ?? view;
+      const handle2 = preparedHandle(runtime, world, String(textureValue.texture), "TextureAsset");
+      if (handle2 !== void 0) {
+        view = residentTextureView(world, runtime.gpuStore, runtime, handle2) ?? view;
       }
     }
     textureResources.push({ sampler, view });
@@ -29799,7 +30030,6 @@ function preparedMaterialBindings(runtime, caches, worlds, materialShaderId, wor
       prefilterView: fallback.prefilterView,
       prefilterSampler: fallback.sampler,
       brdfLutView: fallback.brdfLutView,
-      brdfLutSampler: fallback.sampler,
       intensityBuffer: fallback.intensityBuffer
     },
     transmissionBackdropAvailable(runtime.device.limits.maxSampledTexturesPerShaderStage) ? void 0 : null
@@ -32263,56 +32493,6 @@ var RenderScene = class {
     return slot === void 0 ? worldBounds(snapshot) : this.cullingWorldBoundsAt(slot);
   }
 };
-var RENDERABLE_SOURCE_COMPONENTS = [
-  ChildOf,
-  MeshFilter,
-  MeshRenderer,
-  Instances,
-  SpriteInstances,
-  SpriteRegionOverride,
-  Skin,
-  Layer,
-  Visibility,
-  MorphWeights,
-  Points,
-  Lines,
-  SortKey
-];
-function createGlobalTransformChangeQuery(world) {
-  const result = world.query({ read: [GlobalTransform], changed: [GlobalTransform] });
-  if (!result.ok) throw result.error;
-  const query = result.value;
-  for (const _span of query.spans().unwrap()) {
-  }
-  return query;
-}
-function createRenderSourceState(world) {
-  const components = [...RENDERABLE_SOURCE_COMPONENTS, RuntimeMaterialValue, RuntimeMeshVertices];
-  const projection = createStateProjection(world, components, [
-    ...components,
-    Transform,
-    GlobalTransform
-  ]);
-  const entities = /* @__PURE__ */ new Map();
-  const contentHandles = /* @__PURE__ */ new Map();
-  const batch = projection.read();
-  for (const index of batch.indices) {
-    const entity = projection.entity(index);
-    if (entity !== void 0) {
-      entities.set(index, entity);
-      const handles = [];
-      const material = world.hasComponent(entity, RuntimeMaterialValue) ? world.get(entity, RuntimeMaterialValue) : void 0;
-      const mesh = world.hasComponent(entity, RuntimeMeshVertices) ? world.get(entity, RuntimeMeshVertices) : void 0;
-      if (material?.ok) handles.push(Number(material.value.asset));
-      if (mesh?.ok) handles.push(Number(mesh.value.asset));
-      if (handles.length > 0) contentHandles.set(index, handles);
-    }
-  }
-  return { projection, entities, contentHandles, batch };
-}
-function isRenderableMember(world, entity) {
-  return world.hasComponent(entity, MeshRenderer) && world.hasComponent(entity, Transform) && world.hasComponent(entity, MeshFilter);
-}
 function sourceMembershipChanged(world, slot) {
   const entity = slot.entityKey;
   const snapshot = slot.snapshot;
@@ -32593,6 +32773,9 @@ var PersistentRenderScene = class {
   compositionSlots() {
     return this.composition?.projection.slotsSnapshot() ?? [];
   }
+  compositionSlot(worldId, entityKey) {
+    return this.composition?.projection.slot(worldId, entityKey);
+  }
   shadowCasterProjection() {
     return this.shadowProjection;
   }
@@ -32799,11 +32982,81 @@ var PersistentRenderScene = class {
   reflectionProbeProjection() {
     return this.reflectionProbes.snapshot();
   }
+  consumePublication(input) {
+    const { resources, packet, frame } = input;
+    let entry = this.composition;
+    if (entry === void 0 || packet.baseline) {
+      this.invalidate();
+      const projection = new RenderScene();
+      entry = {
+        token: {},
+        worlds: [resources],
+        projection,
+        topology: new BatchTopology(),
+        transmissionDemand: new PersistentTransmissionDemandProjection(),
+        hiddenEntityReports: [],
+        worldKeys: this.visibilityWorldKeysFor([resources]),
+        readVersions: [],
+        leaseIdentities: [],
+        transformQueries: [],
+        sourceStates: [],
+        dispatchBySlot: /* @__PURE__ */ new Map(),
+        dispatchRevision: 0,
+        dispatchCache: void 0,
+        skinConsumersByJoint: /* @__PURE__ */ new Map(),
+        pendingRenderableEntitiesByWorld: [],
+        unavailableSlots: /* @__PURE__ */ new Set(),
+        catalogEpoch: 0,
+        probeProjection: new ProbeBlendSceneProjection(),
+        probeObjects: void 0,
+        temporalDemanded: false,
+        gpuDrivenSceneRequired: true
+      };
+      this.composition = entry;
+      this.fullRebuilds++;
+      this.lastResyncReason = "attach";
+    }
+    this.worldEntitiesScanned = 0;
+    this.sceneTableUploadBytes = 0;
+    const removedDemand = [];
+    for (const operation of input.operations) {
+      if (operation.kind !== "remove" && operation.snapshot === void 0) continue;
+      const previous = entry.projection.slot(0, operation.entityKey);
+      for (let index = 0; index < (previous?.snapshot.materials.length ?? 0); index++)
+        removedDemand.push({ kind: "remove", key: `0:${operation.entityKey}:${index}` });
+    }
+    const delta = entry.projection.apply(input.operations);
+    for (const removed of delta.removedSlots) {
+      entry.dispatchBySlot.delete(removed.slot);
+      this.stableSlotByEntity.delete(worldEntityKey(entry.worldKeys[0] ?? 0, removed.entityKey));
+    }
+    for (const recreated of delta.recreatedSlots) entry.dispatchBySlot.delete(recreated.slot);
+    for (const [slot, dispatch] of dispatchEntriesBySlot(frame, entry.projection))
+      entry.dispatchBySlot.set(slot, dispatch);
+    if (frame.renderables.length || packet.removed.length) {
+      entry.dispatchRevision++;
+      entry.dispatchCache = void 0;
+      this.visibilityFacets.clear();
+      this.invalidateActiveEntityRevision();
+    }
+    for (const slot of [...delta.createdSlots, ...delta.updatedSlots, ...delta.recreatedSlots])
+      this.stableSlotByEntity.set(worldEntityKey(entry.worldKeys[0] ?? 0, slot.entityKey), slot);
+    entry.transmissionDemand.apply([
+      ...removedDemand,
+      ...transmissionDemandOperations(frame.renderables)
+    ]);
+    entry.topology.apply(delta);
+    this.syncGpuOwner(entry.token, entry.projection, delta);
+    if (input.operations.length) this.deltaFrames++;
+    else this.noChangeFrames++;
+    this.transformUpdates += delta.updated;
+    return this.deriveFramePlan(entry, frame);
+  }
   extractComposition(worlds, owner, catalogEpoch, buildCandidateFrame, leases) {
     this.worldEntitiesScanned = 0;
     this.sceneTableUploadBytes = 0;
     const entry = this.composition;
-    const sameWorldSet = entry !== void 0 && entry.worlds.length === worlds.length && entry.worlds.every((world) => worlds.includes(world));
+    const sameWorldSet = entry !== void 0 && entry.worlds.length === worlds.length && entry.worlds.every((world) => worlds.some((local) => local === world));
     const worldOrderChanged = entry !== void 0 && sameWorldSet && entry.worlds.some((world, index) => world !== worlds[index]);
     const leaseSetPreserved = entry !== void 0 && leases !== void 0 && leases.length === worlds.length && entry.leaseIdentities.length === leases.length && entry.leaseIdentities.every(
       (identity) => leases.some((lease) => lease.worldIdentity === identity)
@@ -33452,7 +33705,7 @@ var PersistentRenderScene = class {
   }
   reconcileComposition(worlds, _owner, catalogEpoch, buildCandidateFrame, leases, preserveVisibilityOnReorder = false) {
     const previousEntry = this.composition;
-    const sourceStates = worlds.map(createRenderSourceState);
+    const sourceStates = worlds.map((world) => createRenderSourceState(world));
     const candidateFrame = buildCandidateFrame({
       kind: "partial",
       entitiesByWorld: sourceStates.map((source) => new Set(source.entities.values()))
@@ -33484,7 +33737,11 @@ var PersistentRenderScene = class {
     const renderables = candidateFrame.renderables;
     const projection = previousEntry?.projection ?? new RenderScene();
     if (previousEntry !== void 0) {
-      projection.remapWorlds(previousEntry.worlds.map((world) => worlds.indexOf(world)));
+      projection.remapWorlds(
+        previousEntry.worlds.map(
+          (world) => worlds.indexOf(world)
+        )
+      );
     }
     const desired = new Set(
       renderables.map((snapshot) => identityKey(snapshot.worldId, snapshot.entityKey))
@@ -33529,9 +33786,9 @@ var PersistentRenderScene = class {
     for (const snapshot of stableCandidateFrame.renderables) {
       if (snapshot.skinJointEntities !== void 0) addSkinConsumer(skinConsumersByJoint, snapshot);
     }
-    const token2 = previousEntry?.token ?? {};
+    const token = previousEntry?.token ?? {};
     const entry = {
-      token: token2,
+      token,
       worlds: [...worlds],
       projection,
       topology,
@@ -33558,7 +33815,7 @@ var PersistentRenderScene = class {
     projection.setTemporalTracking(entry.temporalDemanded);
     this.projectReflectionProbes(candidateFrame.reflectionProbes ?? []);
     this.projectProbes(entry, candidateFrame);
-    this.syncGpuOwner(token2, projection, delta);
+    this.syncGpuOwner(token, projection, delta);
     if (previousEntry === void 0) this.fullRebuilds += 1;
     this.lastResyncReason = "attach";
     const materialized = projection.materialize();
@@ -33602,7 +33859,7 @@ var PersistentRenderScene = class {
     const candidateFrame = {
       ...resourceFrame,
       hiddenEntityReports: entry.hiddenEntityReports,
-      visibilityStats: { explicitlyHidden: entry.hiddenEntityReports.length },
+      visibilityStats: entry.sourceStates.length === 0 ? resourceFrame.visibilityStats : { explicitlyHidden: entry.hiddenEntityReports.length },
       dispatch
     };
     entry.temporalDemanded = frameDemandsTemporal(candidateFrame);
@@ -33940,12 +34197,12 @@ function assertExtent(extent) {
 function mipExtent(value, level) {
   return Math.max(1, Math.floor(value / 2 ** level));
 }
-function estimateTransmissionBackdropBytes(extent, mipCount2, format = "rgba16float") {
+function estimateTransmissionBackdropBytes(extent, mipCount, format = "rgba16float") {
   assertExtent(extent);
-  assertNonNegativeInteger("transmission inspection mipCount", mipCount2);
-  if (format !== "rgba16float" || mipCount2 === 0) return 0;
+  assertNonNegativeInteger("transmission inspection mipCount", mipCount);
+  if (format !== "rgba16float" || mipCount === 0) return 0;
   let bytes2 = 0;
-  for (let level = 0; level < mipCount2; level += 1) {
+  for (let level = 0; level < mipCount; level += 1) {
     bytes2 += mipExtent(extent.width, level) * mipExtent(extent.height, level);
   }
   return bytes2 * RGBA16FLOAT_BYTES_PER_PIXEL;
@@ -33971,9 +34228,9 @@ function inspectTransmission(input) {
   assertExtent(input.extent);
   const format = input.format ?? "rgba16float";
   const resourcePresent = input.resourcePresent ?? input.lastKnownGood;
-  const mipCount2 = resourcePresent ? input.mipCount ?? input.topology.mipCount + 1 : 0;
-  assertNonNegativeInteger("transmission inspection mipCount", mipCount2);
-  const bytes2 = resourcePresent ? input.bytes ?? estimateTransmissionBackdropBytes(input.extent, mipCount2, format) : 0;
+  const mipCount = resourcePresent ? input.mipCount ?? input.topology.mipCount + 1 : 0;
+  assertNonNegativeInteger("transmission inspection mipCount", mipCount);
+  const bytes2 = resourcePresent ? input.bytes ?? estimateTransmissionBackdropBytes(input.extent, mipCount, format) : 0;
   assertNonNegativeInteger("transmission inspection bytes", bytes2);
   const copyCount = resourcePresent ? input.topology.copyCount : 0;
   if (copyCount !== (resourcePresent ? 1 : 0)) {
@@ -33984,7 +34241,7 @@ function inspectTransmission(input) {
     needsRoughMips: active && input.demand.needsRoughMips,
     extent: Object.freeze({ ...input.extent }),
     format,
-    mipCount: mipCount2,
+    mipCount,
     bytes: bytes2,
     copyCount,
     transmissionDrawCount: input.transmissionDrawCount ?? 0,
@@ -35003,7 +35260,6 @@ function createRenderSystem(internals) {
         if (group === 1 && layout !== void 0 && materialShaderId !== void 0 && typeof material === "object" && material !== null && "world" in material && "guid" in material && typeof material.world === "number" && typeof material.guid === "string") {
           return preparedMaterialBindings(
             runtime,
-            caches,
             worlds,
             materialShaderId,
             material.world,
@@ -35315,9 +35571,10 @@ function createRenderSystem(internals) {
       }
       persistentRenderScene.detach(world);
     },
-    draw(worlds, opts, renderReadLeases, timingCapture) {
+    draw(worlds, opts, renderReadLeases, timingCapture, publication) {
       const composition = canonicalizeWorldComposition(worlds, opts, renderReadLeases);
-      const compositionWorlds = composition.worlds;
+      const sourceWorlds = composition.worlds;
+      const compositionWorlds = publication === void 0 ? sourceWorlds : [publication.resources];
       const compositionLeases = composition.leases;
       preparedWorlds = compositionWorlds;
       const profileSession = internals.profiler?.activeSession();
@@ -35340,19 +35597,41 @@ function createRenderSystem(internals) {
         if (frameState.installedPipelineHandle !== lastBuiltPipelineHandle) {
           resetRenderFeatureGraphState(internals);
           lastBuiltPipelineHandle = frameState.installedPipelineHandle;
-          persistentRenderScene.invalidate();
+          if (publication === void 0) persistentRenderScene.invalidate();
         }
         dispatchCounts.unlit = 0;
         const resourceWorld = compositionWorlds[resourceOwner];
         let frame;
         try {
           frame = runProfiledRenderPhase(profileSession, "extract", () => {
+            if (publication !== void 0) {
+              for (const handle of [
+                ...publication.packet.invalidatedAssets,
+                ...publication.packet.retiredAssets
+              ]) {
+                internals.gpuStore.invalidateMesh(handle, publication.resources);
+                internals.gpuStore.evictTexture(
+                  handle,
+                  publication.resources
+                );
+              }
+              return persistentRenderScene.consumePublication(
+                preparePublicationGeometry(
+                  publication,
+                  persistentRenderScene,
+                  internals.getPipelineState()?.skinPaletteAllocator,
+                  internals.assets,
+                  instanceCollections,
+                  internals.device.caps.storageBuffer ? internals.getMaterialShaderArtifact : void 0
+                )
+              );
+            }
             return persistentRenderScene.extractComposition(
-              compositionWorlds,
+              sourceWorlds,
               { cameraOwner, resourceOwner },
               internals.assets.catalogEpoch,
               (renderables2) => extractFrames(
-                compositionWorlds,
+                sourceWorlds,
                 {
                   cameraOwner,
                   resourceOwner,
@@ -35362,18 +35641,7 @@ function createRenderSystem(internals) {
                 internals.getPipelineState(),
                 persistentRenderScene.materialSnapshotCacheStore(),
                 {
-                  ...internals.device.caps.backendKind === "null" ? {} : {
-                    materialContext: {
-                      backend: internals.device.caps.backendKind === "wgpu-webgl2" ? "webgl2" : internals.device.caps.backendKind,
-                      capability: internals.device.caps.storageBuffer ? "storage-buffer" : "uniform-fallback",
-                      pipeline: "forward",
-                      geometry: "mesh",
-                      pass: "forward",
-                      profile: "forgeax-material-wgsl-v1",
-                      toolchain: "naga-oil",
-                      instrumentation: "none"
-                    }
-                  },
+                  ...renderMaterialContext(internals.device.caps),
                   cull: "none",
                   retainHidden: true,
                   renderables: renderables2,
@@ -35396,6 +35664,7 @@ function createRenderSystem(internals) {
         lastMotionBlurInvalidParams = void 0;
         const {
           cameras: extractedCameras,
+          auxiliaryCameras,
           cubeCameras,
           lights,
           environment,
@@ -35818,7 +36087,7 @@ function createRenderSystem(internals) {
         const motionBlurParams = cameras[0]?.motionBlur;
         let motionBlurDelta = 0;
         try {
-          const delta = compositionWorlds[cameraOwner].getResource(Time).delta;
+          const delta = renderTime(compositionWorlds[cameraOwner]).delta;
           motionBlurDelta = Number.isFinite(delta) ? Math.max(0, delta) : 0;
         } catch {
           motionBlurDelta = 0;
@@ -35850,9 +36119,22 @@ function createRenderSystem(internals) {
         preparedFeatureSkylightResources = preparedPipelineState === null ? void 0 : resolveMaterialSkylight(internals, preparedPipelineState, skylight, skylightCount).skylightResources;
         let featureGraphCandidate;
         const preparedResourceBatches = runProfiledRenderPhase(profileSession, "features", () => {
+          if (publication?.packet.features.some(
+            (row) => !internals.featureHost?.features.some(
+              (feature) => feature.identity === row.identity
+            )
+          ))
+            throw new RenderPublicationError({
+              reason: "shape",
+              subject: "published feature has no receiver implementation"
+            });
           if (internals.featureHost === void 0) return [];
           const featureFrame = runRenderFeatureFrame(internals.featureHost, {
-            worlds: compositionWorlds,
+            worlds: sourceWorlds,
+            ...publication === void 0 ? {} : {
+              publishedFeatures: publication.packet.features,
+              ...publication.onFeatureSourceSubmitted === void 0 ? {} : { onFeatureSourceSubmitted: publication.onFeatureSourceSubmitted }
+            },
             owner: resourceOwner,
             frameNumber: frameState.frameNumber,
             ...cameras[0] === void 0 ? {} : { selectedCamera: cameras[0] },
@@ -35984,7 +36266,7 @@ function createRenderSystem(internals) {
         const hasLiveFeatureState = liveOutput !== void 0 || frameState.autoExposureGpuResources !== void 0 || frameState.pendingAutoExposureGpuResources !== void 0 || frameState.autoExposureState !== void 0 || frameState.pendingAutoExposureState !== void 0 || frameState.standardLutGpuResources !== void 0 || frameState.pendingStandardLutGpuResources !== void 0 || frameState.standardLutState.resident !== null || frameState.pendingStandardLutState !== void 0;
         if (hasLiveFeatureState) {
           const cameraWorld = compositionWorlds[cameraOwner];
-          const deltaTime = cameraWorld.getResource(Time).delta;
+          const deltaTime = renderTime(cameraWorld).delta;
           stageLiveFeatureState(
             cameras[0],
             Number.isFinite(deltaTime) ? Math.max(0, deltaTime) : 0
@@ -35997,10 +36279,10 @@ function createRenderSystem(internals) {
           resourceGeneration: gpuDrivenProduction.inspect().resourceGeneration
         });
         frameState.surfaceSubmissionObservation = surfaceSubmissionCandidate;
-        const probeCaptureScene = shadowCasterProjection !== void 0 && reflectionProbeRecord.graph.work.some((work) => work.rawCaptureFace !== void 0) ? projectCaptureScene(shadowCasterProjection, submissionRenderables, orderedDispatch) : void 0;
+        const probeCaptureScene = shadowCasterProjection !== void 0 && (auxiliaryCameras.length > 0 || cubeCameras.length > 0 || reflectionProbeRecord.graph.work.some((work) => work.rawCaptureFace !== void 0)) ? projectCaptureScene(shadowCasterProjection, submissionRenderables, orderedDispatch) : void 0;
         const presentedRenderableKeys = /* @__PURE__ */ new Set();
         const presentedSubmeshKeys = /* @__PURE__ */ new Set();
-        const consumeDynamicGeometry = dynamicGeometryFrames.onRenderableDraw(compositionWorlds);
+        const consumeDynamicGeometry = dynamicGeometryFrames.onRenderableDraw(sourceWorlds);
         const markPresentedRenderable = (entry, submeshIndex, receipt) => {
           const entityKey = worldEntityKey(
             worldKeys[entry.source.worldId] ?? entry.source.worldId,
@@ -36049,7 +36331,9 @@ function createRenderSystem(internals) {
               },
               ...occlusionProjection === void 0 ? {} : { occlusion: occlusionProjection },
               frameTime: (() => {
-                const elapsed = compositionWorlds[cameraOwner].getResource(Time).elapsed;
+                const elapsed = renderTime(
+                  compositionWorlds[cameraOwner]
+                ).elapsed;
                 return Number.isFinite(elapsed) ? elapsed : 0;
               })(),
               deviceGeneration: internals.deviceScope.generation,
@@ -36061,6 +36345,7 @@ function createRenderSystem(internals) {
             pointsLinesOwner,
             {
               snapshots: cubeCameras,
+              auxiliaryCameras,
               scheduler: cubeCaptureScheduler,
               state: cubeCaptureState,
               reflectionProbes: reflectionProbeRecord,
@@ -36204,7 +36489,9 @@ function createRenderSystem(internals) {
             width: Math.max(1, internals.canvas.width),
             height: Math.max(1, internals.canvas.height),
             frameTime: (() => {
-              const elapsed = compositionWorlds[cameraOwner].getResource(Time).elapsed;
+              const elapsed = renderTime(
+                compositionWorlds[cameraOwner]
+              ).elapsed;
               return Number.isFinite(elapsed) ? elapsed : 0;
             })(),
             ...surfaceDynamicInputFrame === void 0 ? {} : { surfaceDynamicInput: surfaceDynamicInputFrame },
@@ -36279,20 +36566,20 @@ function createRenderSystem(internals) {
             if (!retired.ok) internals.errorRegistry.fire(retired.error);
           }
         }
-      } catch (err57) {
+      } catch (err58) {
         discardLiveFeatureState();
         if (!submitted) {
           internals.getPipelineState()?.perPassResources.discardBloomResources?.();
         }
-        const innerError = err57 instanceof PipelineSpecError ? {
-          name: err57.name,
-          code: err57.code,
-          message: err57.message,
-          detail: err57.detail
-        } : err57 instanceof RhiError ? err57 : {
+        const innerError = err58 instanceof PipelineSpecError ? {
+          name: err58.name,
+          code: err58.code,
+          message: err58.message,
+          detail: err58.detail
+        } : err58 instanceof RhiError ? err58 : {
           code: "unknown",
-          message: String(err57),
-          name: err57?.name
+          message: String(err58),
+          name: err58?.name
         };
         internals.errorRegistry.fire(
           new RhiError({
@@ -37022,578 +37309,6 @@ function postSpawnResolveJoints(world, resolver, spawnRoot) {
   }
   return { ok: true };
 }
-var atlasMaterialCache = /* @__PURE__ */ new WeakMap();
-var atlasOnlyMaterialCache = /* @__PURE__ */ new WeakMap();
-var streamingCacheByWorld = /* @__PURE__ */ new WeakMap();
-function streamingCache(world) {
-  let cache = streamingCacheByWorld.get(world);
-  if (cache === void 0) {
-    cache = {
-      layers: /* @__PURE__ */ new Map(),
-      chunkEntities: /* @__PURE__ */ new Map(),
-      activeChunks: /* @__PURE__ */ new Map()
-    };
-    streamingCacheByWorld.set(world, cache);
-  }
-  return cache;
-}
-function encodeTilemapLayerValue(layerOrder, chunkIndex, sortScope = "layer") {
-  if (sortScope === "per-cell") return layerOrder << 20 | 0;
-  return layerOrder << 20 | chunkIndex & 1048575 | 0;
-}
-function resolveTilesetMaterial(world, tileset, regionIndex, lookup) {
-  const region = tileset.regions[regionIndex];
-  if (region === void 0) return toShared(0);
-  const atlasIndex = region.atlasIndex ?? 0;
-  const atlasGuid = tileset.atlases[atlasIndex];
-  if (atlasGuid === void 0) return toShared(0);
-  const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
-  if (!atlas.ok) return toShared(0);
-  const atlasHandle = atlas.value.handle;
-  const atlasId = unwrapHandle(atlasHandle);
-  const cacheKey = `${atlasId}|${regionIndex}`;
-  const cache = atlasMaterialCache.get(world) ?? /* @__PURE__ */ new Map();
-  atlasMaterialCache.set(world, cache);
-  const cached = cache.get(cacheKey);
-  if (cached !== void 0) return cached;
-  const atlasSize = tileset.atlasSizes?.[atlasIndex];
-  const atlasWidth = Math.max(
-    1,
-    atlasSize !== void 0 ? atlasSize.pixelWidth : tileset.columns * tileset.tileWidth
-  );
-  const atlasHeight = Math.max(
-    1,
-    atlasSize !== void 0 ? atlasSize.pixelHeight : tileset.rows * tileset.tileHeight
-  );
-  const halfTexelU = 0.5 / atlasWidth;
-  const halfTexelV = 0.5 / atlasHeight;
-  const u = region.x / atlasWidth + halfTexelU;
-  const v = region.y / atlasHeight + halfTexelV;
-  const w = region.width / atlasWidth - 2 * halfTexelU;
-  const h = region.height / atlasHeight - 2 * halfTexelV;
-  const matPayload = {
-    kind: "material",
-    passes: [
-      {
-        name: "Forward",
-        program: { module: "forgeax::sprite" },
-        renderState: {
-          ...{ blend: SPRITE_PREMULTIPLIED_ALPHA_BLEND },
-          tags: { LightMode: "Forward" },
-          queue: 3e3
-        }
-      }
-    ],
-    values: {
-      colorTint: [1, 1, 1, 1],
-      baseColorTexture: atlasHandle,
-      region: [u, v, w, h],
-      pivotAndSize: [0.5, 0.5, 1, 1],
-      flipY: 1
-    }
-  };
-  const matHandle = world.allocSharedRef(
-    "MaterialAsset",
-    matPayload
-  );
-  cache.set(cacheKey, matHandle);
-  return matHandle;
-}
-function resolveAtlasOnlyMaterial(world, tileset, atlasIndex, lookup) {
-  const atlasGuid = tileset.atlases[atlasIndex];
-  if (atlasGuid === void 0) return toShared(0);
-  const atlas = resolveTilesetRuntime(world, atlasGuid, lookup);
-  if (!atlas.ok) return toShared(0);
-  const atlasHandle = atlas.value.handle;
-  const atlasId = unwrapHandle(atlasHandle);
-  const cacheKey = String(atlasId);
-  const cache = atlasOnlyMaterialCache.get(world) ?? /* @__PURE__ */ new Map();
-  atlasOnlyMaterialCache.set(world, cache);
-  const cached = cache.get(cacheKey);
-  if (cached !== void 0) return cached;
-  const matPayload = {
-    kind: "material",
-    passes: [
-      {
-        name: "Forward",
-        program: { module: "forgeax::sprite" },
-        renderState: {
-          ...{ blend: SPRITE_PREMULTIPLIED_ALPHA_BLEND },
-          tags: { LightMode: "Forward" },
-          queue: 3e3
-        }
-      }
-    ],
-    values: {
-      colorTint: [1, 1, 1, 1],
-      baseColorTexture: atlasHandle,
-      region: [0, 0, 1, 1],
-      pivotAndSize: [0.5, 0.5, 1, 1],
-      flipY: 1
-    }
-  };
-  const matHandle = world.allocSharedRef(
-    "MaterialAsset",
-    matPayload
-  );
-  cache.set(cacheKey, matHandle);
-  return matHandle;
-}
-function computeRegionUv(tileset, region, atlasIndex) {
-  const atlasSize = tileset.atlasSizes?.[atlasIndex];
-  const atlasWidth = Math.max(
-    1,
-    atlasSize !== void 0 ? atlasSize.pixelWidth : tileset.columns * tileset.tileWidth
-  );
-  const atlasHeight = Math.max(
-    1,
-    atlasSize !== void 0 ? atlasSize.pixelHeight : tileset.rows * tileset.tileHeight
-  );
-  const halfTexelU = 0.5 / atlasWidth;
-  const halfTexelV = 0.5 / atlasHeight;
-  return [
-    region.x / atlasWidth + halfTexelU,
-    region.y / atlasHeight + halfTexelV,
-    region.width / atlasWidth - 2 * halfTexelU,
-    region.height / atlasHeight - 2 * halfTexelV
-  ];
-}
-var SQRT1_2 = Math.SQRT1_2;
-function effectivePivotYForTilemapFlip(pivotY, pivotX, flipV, flipDiagonal) {
-  const base = flipDiagonal ? pivotX : pivotY;
-  return flipV ? 1 - base : base;
-}
-function specFor(layerCols, chunkSize, cellIndex, packedTile, materialHandle, entry, atlasIndex) {
-  const cellX = cellIndex % layerCols;
-  const cellY = Math.floor(cellIndex / layerCols);
-  const chunkX = Math.floor(cellX / chunkSize);
-  const chunkY = Math.floor(cellY / chunkSize);
-  const chunksPerRow = Math.max(1, Math.ceil(layerCols / chunkSize));
-  const chunkIndex = chunkY * chunksPerRow + chunkX;
-  const { tileId } = decodeTileBits(packedTile);
-  return {
-    cellX,
-    cellY,
-    tileId,
-    packedTile,
-    materialHandle,
-    chunkIndex,
-    widthCells: entry.widthCells ?? 1,
-    heightCells: entry.heightCells ?? 1,
-    pivotX: entry.pivotX ?? 0.5,
-    pivotY: entry.pivotY ?? 0.5,
-    atlasIndex,
-    regionIndex: entry.regionIndex
-  };
-}
-function computeTileTrs(tilemap, spec, packedTile) {
-  const { flipH, flipV, flipDiagonal } = decodeTileBits(packedTile);
-  const basePivotForX = flipDiagonal ? spec.pivotY : spec.pivotX;
-  const effectivePivotX = flipH ? 1 - basePivotForX : basePivotForX;
-  const effectivePivotY = effectivePivotYForTilemapFlip(
-    spec.pivotY,
-    spec.pivotX,
-    flipV,
-    flipDiagonal
-  );
-  const tileSizeX = tilemap.tileSize[0] ?? 1;
-  const tileSizeY = tilemap.tileSize[1] ?? 1;
-  return {
-    posX: (spec.cellX + effectivePivotX + (0.5 - effectivePivotX) * spec.widthCells) * tileSizeX,
-    posY: (spec.cellY + effectivePivotY + (0.5 - effectivePivotY) * spec.heightCells) * tileSizeY,
-    scaleX: (flipH ? -1 : 1) * spec.widthCells * tileSizeX,
-    scaleY: (flipV ? -1 : 1) * spec.heightCells * tileSizeY,
-    quatZ: flipDiagonal ? SQRT1_2 : 0,
-    quatW: flipDiagonal ? SQRT1_2 : 1
-  };
-}
-function spawnDerivedRenderEntities(world, tilemap, layerEntity, layerOrder, spec, packedTile, sortScope = "layer") {
-  const { posX, posY, scaleX, scaleY, quatZ, quatW } = computeTileTrs(tilemap, spec, packedTile);
-  const layerValue = encodeTilemapLayerValue(layerOrder, spec.chunkIndex, sortScope);
-  return world.spawn(
-    {
-      component: Transform,
-      data: {
-        pos: [posX, posY, 0],
-        quat: [0, 0, quatZ, quatW],
-        scale: [scaleX, scaleY, 1]
-      }
-    },
-    { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
-    {
-      component: MeshRenderer,
-      data: {
-        materials: [spec.materialHandle]
-      }
-    },
-    { component: Layer, data: { value: layerValue } },
-    { component: ChildOf, data: { parent: layerEntity } }
-  ).unwrap();
-}
-function spawnSpriteInstancesGroup(world, tilemap, tileset, layerEntity, layerOrder, chunkIndex, atlasIndex, materialHandle, cellSpecs) {
-  if (cellSpecs.length === 0) return void 0;
-  const N = cellSpecs.length;
-  const transforms = new Float32Array(N * 16);
-  const regions = new Float32Array(N * 4);
-  const tmpMat = mat4.create();
-  const tmpT = [0, 0, 0];
-  const tmpR = [0, 0, 0, 1];
-  const tmpS = [1, 1, 1];
-  const chunksPerRow = Math.max(1, Math.ceil(tilemap.cols / tilemap.chunkSize));
-  const chunkX = chunkIndex % chunksPerRow;
-  const chunkY = Math.floor(chunkIndex / chunksPerRow);
-  const chunkScaleX = tilemap.chunkSize * (tilemap.tileSize[0] ?? 1);
-  const chunkScaleY = tilemap.chunkSize * (tilemap.tileSize[1] ?? 1);
-  const chunkCenterX = (chunkX + 0.5) * chunkScaleX;
-  const chunkCenterY = (chunkY + 0.5) * chunkScaleY;
-  const invSX = chunkScaleX > 0 ? 1 / chunkScaleX : 1;
-  const invSY = chunkScaleY > 0 ? 1 / chunkScaleY : 1;
-  for (let i = 0; i < N; i++) {
-    const spec = cellSpecs[i];
-    const { posX, posY, scaleX, scaleY, quatZ, quatW } = computeTileTrs(
-      tilemap,
-      spec,
-      spec.packedTile
-    );
-    tmpT[0] = posX;
-    tmpT[1] = posY;
-    tmpT[2] = 0;
-    tmpR[0] = 0;
-    tmpR[1] = 0;
-    tmpR[2] = quatZ;
-    tmpR[3] = quatW;
-    tmpS[0] = scaleX;
-    tmpS[1] = scaleY;
-    tmpS[2] = 1;
-    mat4.compose(tmpMat, tmpT, tmpR, tmpS);
-    const dst = i * 16;
-    for (let c = 0; c < 4; c++) {
-      const base = c * 4;
-      const w3 = tmpMat[base + 3] ?? 0;
-      transforms[dst + base + 0] = ((tmpMat[base + 0] ?? 0) - chunkCenterX * w3) * invSX;
-      transforms[dst + base + 1] = ((tmpMat[base + 1] ?? 0) - chunkCenterY * w3) * invSY;
-      transforms[dst + base + 2] = tmpMat[base + 2] ?? 0;
-      transforms[dst + base + 3] = w3;
-    }
-    const region = tileset.regions[spec.regionIndex];
-    if (region !== void 0) {
-      const [u, v, w, h] = computeRegionUv(tileset, region, atlasIndex);
-      regions[i * 4 + 0] = u;
-      regions[i * 4 + 1] = v;
-      regions[i * 4 + 2] = w;
-      regions[i * 4 + 3] = h;
-    }
-  }
-  const layerValue = encodeTilemapLayerValue(layerOrder, chunkIndex, "layer");
-  return world.spawn(
-    {
-      component: Transform,
-      data: {
-        pos: [chunkCenterX, chunkCenterY, 0],
-        quat: [0, 0, 0, 1],
-        scale: [chunkScaleX, chunkScaleY, 1]
-      }
-    },
-    { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
-    {
-      component: MeshRenderer,
-      data: {
-        materials: [materialHandle]
-      }
-    },
-    { component: SpriteInstances, data: { transforms, regions } },
-    { component: Layer, data: { value: layerValue } },
-    { component: ChildOf, data: { parent: layerEntity } }
-  ).unwrap();
-}
-function bucketTileLayer(world, layerEntity, parentEntity, lookup) {
-  const tilemapRes = world.get(parentEntity, Tilemap);
-  if (!tilemapRes.ok) return void 0;
-  const tilemap = tilemapRes.value;
-  const tilesetPayload = lookup(tilemap.tileset);
-  if (tilesetPayload === void 0 || "code" in tilesetPayload) return void 0;
-  if (tilesetPayload.kind !== "tileset") return void 0;
-  const tileset = tilesetPayload;
-  const layerRes = world.get(layerEntity, TileLayer);
-  if (!layerRes.ok) return void 0;
-  const layer = layerRes.value;
-  const tiles = layer.tiles;
-  const sortScope = decodeSortScope(layer.sortScope);
-  const useSpriteInstances = sortScope === "layer";
-  const specs = [];
-  for (let i = 0; i < tiles.length; i++) {
-    const packed = tiles[i] ?? 0;
-    if (packed === 0) continue;
-    const { tileId } = decodeTileBits(packed);
-    if (tileId === 0) continue;
-    const entry = tileset.tiles[tileId - 1];
-    if (entry === void 0) continue;
-    const region = tileset.regions[entry.regionIndex];
-    if (region === void 0) continue;
-    const atlasIndex = region.atlasIndex ?? 0;
-    const materialHandle = useSpriteInstances ? resolveAtlasOnlyMaterial(world, tileset, atlasIndex, lookup) : resolveTilesetMaterial(world, tileset, entry.regionIndex, lookup);
-    const spec = specFor(
-      tilemap.cols,
-      tilemap.chunkSize,
-      i,
-      packed,
-      materialHandle,
-      entry,
-      atlasIndex
-    );
-    specs.push(spec);
-  }
-  return {
-    tilemap,
-    layerOrder: layer.layerOrder,
-    sortScope,
-    tileset,
-    specs
-  };
-}
-function buildCameraFrustumPlanes(world) {
-  const query = world.query({ with: [Camera, Transform, GlobalTransform] }).unwrap();
-  let result = null;
-  for (const row of query) {
-    const camEntity = row.entity;
-    const camRes = world.get(camEntity, Camera);
-    const trRes = world.get(camEntity, GlobalTransform);
-    if (!camRes.ok || !trRes.ok) continue;
-    const cam = camRes.value;
-    const tr = trRes.value;
-    const { near, far } = cam;
-    if (near >= far) continue;
-    const proj = mat4.create();
-    if (cam.projection === CAMERA_PROJECTION_ORTHOGRAPHIC) {
-      mat4.orthographic(
-        proj,
-        cam.left,
-        cam.right,
-        cam.top,
-        cam.bottom,
-        near,
-        far
-      );
-    } else {
-      mat4.perspective(
-        proj,
-        cam.fov,
-        cam.aspect,
-        near,
-        far
-      );
-    }
-    const view = mat4.create();
-    mat4.invert(
-      view,
-      tr.world
-    );
-    const vp = mat4.create();
-    mat4.multiply(
-      vp,
-      proj,
-      view
-    );
-    const f = frustum.create();
-    frustum.fromViewProjection(f, vp);
-    result = f;
-    break;
-  }
-  return result;
-}
-function computeChunkStreamBounds(tilemap, specs) {
-  let minX = Number.MAX_VALUE;
-  let minY = Number.MAX_VALUE;
-  let maxX = -Number.MAX_VALUE;
-  let maxY = -Number.MAX_VALUE;
-  for (const spec of specs) {
-    const { posX, posY, scaleX, scaleY } = computeTileTrs(tilemap, spec, spec.packedTile);
-    const halfW = Math.abs(scaleX) * 0.5;
-    const halfH = Math.abs(scaleY) * 0.5;
-    const x0 = posX - halfW;
-    const x1 = posX + halfW;
-    const y0 = posY - halfH;
-    const y1 = posY + halfH;
-    if (x0 < minX) minX = x0;
-    if (y0 < minY) minY = y0;
-    if (x1 > maxX) maxX = x1;
-    if (y1 > maxY) maxY = y1;
-  }
-  return [minX, minY, -1, maxX, maxY, 1];
-}
-function purgeDerivedEntities(world, layerEntity) {
-  const r = world.get(layerEntity, Children);
-  if (!r.ok) return;
-  const snap = r.value.entities;
-  for (let i = 0; i < snap.length; i++) {
-    const e = snap[i];
-    if (e !== void 0) world.despawn(e);
-  }
-}
-function evictDeadPerCellStreamingCaches(work, world) {
-  const cache = streamingCache(world);
-  const aliveLayerKeys = /* @__PURE__ */ new Set();
-  for (const w of work) {
-    aliveLayerKeys.add(String(w.layerEntity));
-  }
-  const deadLayerKeys = /* @__PURE__ */ new Set();
-  for (const layerKey of cache.activeChunks.keys()) {
-    if (!aliveLayerKeys.has(layerKey)) deadLayerKeys.add(layerKey);
-  }
-  for (const layerKey of cache.layers.keys()) {
-    if (!aliveLayerKeys.has(layerKey)) deadLayerKeys.add(layerKey);
-  }
-  for (const deadKey of deadLayerKeys) {
-    const activeSet = cache.activeChunks.get(deadKey);
-    if (activeSet !== void 0) {
-      for (const chunkIdx of activeSet) {
-        cache.chunkEntities.delete(`${deadKey}:${chunkIdx}`);
-      }
-      cache.activeChunks.delete(deadKey);
-    }
-    cache.layers.delete(deadKey);
-  }
-}
-function tilemapChunkExtractSystem(world, lookup = () => void 0) {
-  const streaming = streamingCache(world);
-  const work = [];
-  const tileLayerQuery = world.query({ read: [TileLayer, ChildOf] }).unwrap();
-  for (const row of tileLayerQuery) {
-    const layer = row.get(TileLayer);
-    const parent = row.get(ChildOf).parent;
-    if (parent === null) continue;
-    work.push({
-      layerEntity: row.entity,
-      parentEntity: parent,
-      dirty: layer.dirty,
-      sortScopeRaw: layer.sortScope
-    });
-  }
-  evictDeadPerCellStreamingCaches(work, world);
-  let frustumPlanes;
-  for (const w of work) {
-    const layerKey = String(w.layerEntity);
-    const isStreaming = decodeSortScope(w.sortScopeRaw) === "per-cell";
-    if (!isStreaming) {
-      const childrenRes = world.get(w.layerEntity, Children);
-      const childCount = childrenRes.ok ? childrenRes.value.entities.length : 0;
-      if (childCount > 0 && w.dirty === 0) continue;
-      purgeDerivedEntities(world, w.layerEntity);
-      const bucket = bucketTileLayer(world, w.layerEntity, w.parentEntity, lookup);
-      if (bucket === void 0) continue;
-      const byChunkAtlas = /* @__PURE__ */ new Map();
-      for (const spec of bucket.specs) {
-        const key = (spec.chunkIndex & 1048575) << 16 | spec.atlasIndex & 65535;
-        const list = byChunkAtlas.get(key);
-        if (list === void 0) {
-          byChunkAtlas.set(key, [spec]);
-        } else {
-          list.push(spec);
-        }
-      }
-      for (const groupSpecs of byChunkAtlas.values()) {
-        const first = groupSpecs[0];
-        if (first === void 0) continue;
-        spawnSpriteInstancesGroup(
-          world,
-          bucket.tilemap,
-          bucket.tileset,
-          w.layerEntity,
-          bucket.layerOrder,
-          first.chunkIndex,
-          first.atlasIndex,
-          first.materialHandle,
-          groupSpecs
-        );
-      }
-      if (w.dirty !== 0) {
-        world.set(w.layerEntity, TileLayer, { dirty: 0 }).unwrap();
-      }
-      continue;
-    }
-    if (w.dirty !== 0 || !streaming.layers.has(layerKey)) {
-      const activeSet2 = streaming.activeChunks.get(layerKey);
-      if (activeSet2 !== void 0) {
-        for (const chunkIdx of activeSet2) {
-          const key = `${layerKey}:${chunkIdx}`;
-          const entities = streaming.chunkEntities.get(key);
-          if (entities !== void 0) {
-            for (const e of entities) world.despawn(e);
-            streaming.chunkEntities.delete(key);
-          }
-        }
-        activeSet2.clear();
-      }
-      streaming.layers.delete(layerKey);
-      const bucket = bucketTileLayer(world, w.layerEntity, w.parentEntity, lookup);
-      if (bucket !== void 0) {
-        const byChunkSpecs = /* @__PURE__ */ new Map();
-        for (const spec of bucket.specs) {
-          const list = byChunkSpecs.get(spec.chunkIndex);
-          if (list === void 0) {
-            byChunkSpecs.set(spec.chunkIndex, [spec]);
-          } else {
-            list.push(spec);
-          }
-        }
-        const byChunk = /* @__PURE__ */ new Map();
-        for (const [chunkIdx, specs] of byChunkSpecs) {
-          byChunk.set(chunkIdx, {
-            specs,
-            bounds: computeChunkStreamBounds(bucket.tilemap, specs)
-          });
-        }
-        streaming.layers.set(layerKey, {
-          byChunk,
-          tilemap: bucket.tilemap,
-          layerOrder: bucket.layerOrder,
-          sortScope: bucket.sortScope
-        });
-      }
-      if (w.dirty !== 0) {
-        world.set(w.layerEntity, TileLayer, { dirty: 0 }).unwrap();
-      }
-    }
-    const cache = streaming.layers.get(layerKey);
-    if (cache === void 0) continue;
-    if (frustumPlanes === void 0) {
-      frustumPlanes = buildCameraFrustumPlanes(world);
-    }
-    const activeSet = streaming.activeChunks.get(layerKey) ?? /* @__PURE__ */ new Set();
-    streaming.activeChunks.set(layerKey, activeSet);
-    const { tilemap } = cache;
-    for (const [chunkIdx, entry] of cache.byChunk) {
-      const { specs, bounds } = entry;
-      const visible = frustumPlanes === null || frustum.intersectsBox(frustumPlanes, bounds);
-      const wasActive = activeSet.has(chunkIdx);
-      if (visible && !wasActive) {
-        const spawned = [];
-        for (const spec of specs) {
-          const e = spawnDerivedRenderEntities(
-            world,
-            tilemap,
-            w.layerEntity,
-            cache.layerOrder,
-            spec,
-            spec.packedTile,
-            cache.sortScope
-          );
-          spawned.push(e);
-        }
-        streaming.chunkEntities.set(`${layerKey}:${chunkIdx}`, spawned);
-        activeSet.add(chunkIdx);
-      } else if (!visible && wasActive) {
-        const key = `${layerKey}:${chunkIdx}`;
-        const entities = streaming.chunkEntities.get(key);
-        if (entities !== void 0) {
-          for (const e of entities) world.despawn(e);
-          streaming.chunkEntities.delete(key);
-        }
-        activeSet.delete(chunkIdx);
-      }
-    }
-  }
-}
 
 // src/assembly/analytic-fog-registration.ts
 function registerAnalyticFogPostProcess(renderSystem, source, candidate) {
@@ -40087,6 +39802,14 @@ function createRendererRecovery(deps) {
       device,
       adaptMipmapShaderModuleFactory2(internals.pack.createShaderModule),
       (world, pod) => {
+        if ("resolveAsset" in world)
+          return err(
+            new AssetError({
+              code: "asset-not-found",
+              expected: "source-owned environment asset allocation",
+              hint: "publish the environment asset from its source owner before GPU preparation"
+            })
+          );
         const handle = world.allocSharedRef(
           "EquirectAsset",
           pod
@@ -40583,974 +40306,6 @@ function collectRequiredFullscreenPostProcesses(features) {
   return Object.freeze([...entries.values()]);
 }
 
-// src/targets/contracts.ts
-var FORMAT_BYTES = {
-  rgba16float: 8,
-  rgba8unorm: 4,
-  "rgba8unorm-srgb": 4
-};
-function mipFactor(mipLevels) {
-  return mipLevels === "full" ? 4 / 3 : 1;
-}
-function estimatedBytes(descriptor) {
-  const layers = descriptor.shape === "cube" ? 6 : 1;
-  const samples = descriptor.sampleCount;
-  const depthBytes = descriptor.depth === void 0 ? 0 : 4;
-  return Math.ceil(
-    descriptor.width * descriptor.height * FORMAT_BYTES[descriptor.format] * layers * samples * mipFactor(descriptor.mipLevels) + descriptor.width * descriptor.height * depthBytes * layers * samples * mipFactor(descriptor.mipLevels)
-  );
-}
-function invalid4(field, value, expected) {
-  return {
-    ok: false,
-    error: new RenderTargetDescriptorInvalidError({ field, value, expected })
-  };
-}
-function admitRenderTargetDescriptor(descriptor, limits) {
-  if (!Number.isInteger(descriptor.width) || descriptor.width < 1) {
-    return invalid4("width", descriptor.width, "an integer >= 1");
-  }
-  if (!Number.isInteger(descriptor.height) || descriptor.height < 1) {
-    return invalid4("height", descriptor.height, "an integer >= 1");
-  }
-  if (descriptor.width > limits.maxTextureDimension2D || descriptor.height > limits.maxTextureDimension2D) {
-    return invalid4(
-      "extent",
-      { width: descriptor.width, height: descriptor.height },
-      `width and height <= ${limits.maxTextureDimension2D}`
-    );
-  }
-  if (descriptor.shape === "cube" && descriptor.width !== descriptor.height) {
-    return invalid4("shape", descriptor.shape, "cube width === height");
-  }
-  if (!limits.renderableFormats.includes(descriptor.format)) {
-    return {
-      ok: false,
-      error: new RenderTargetCapabilityMissingError({
-        operation: "create",
-        requested: descriptor.format,
-        capability: "renderableFormats",
-        actual: limits.renderableFormats.join(", ")
-      })
-    };
-  }
-  if (!limits.sampleCounts.includes(descriptor.sampleCount)) {
-    return {
-      ok: false,
-      error: new RenderTargetCapabilityMissingError({
-        operation: "create",
-        requested: String(descriptor.sampleCount),
-        capability: "sampleCounts",
-        actual: limits.sampleCounts.join(", ")
-      })
-    };
-  }
-  if (descriptor.depth !== void 0 && !limits.depthFormats.includes(descriptor.depth)) {
-    return {
-      ok: false,
-      error: new RenderTargetCapabilityMissingError({
-        operation: "create",
-        requested: descriptor.depth,
-        capability: "depthFormats",
-        actual: limits.depthFormats.join(", ")
-      })
-    };
-  }
-  const bytes2 = estimatedBytes(descriptor);
-  if (bytes2 > limits.maxBytesPerTarget) {
-    return invalid4("bytes", bytes2, `estimated allocation <= ${limits.maxBytesPerTarget}`);
-  }
-  return { ok: true, value: descriptor };
-}
-
-// src/targets/owner.ts
-function frozenDescriptor(descriptor) {
-  return Object.freeze({ ...descriptor });
-}
-function invalid5(operation, reason2, state, generation) {
-  return {
-    ok: false,
-    error: new RenderTargetStateInvalidError({ operation, reason: reason2, state, generation })
-  };
-}
-function token() {
-  return Object.freeze({});
-}
-function createRenderTargetOwner(options) {
-  const targets = /* @__PURE__ */ new WeakMap();
-  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);
-    }
-    if (state.state === "destroyed") {
-      return invalid5(operation, "destroyed", state.state, state.generation);
-    }
-    return { ok: true, value: state };
-  };
-  return {
-    create(descriptor) {
-      const target5 = token();
-      targets.set(target5, {
-        target: target5,
-        rendererId: options.rendererId,
-        state: "uninitialized",
-        generation: 0,
-        descriptor: frozenDescriptor(descriptor),
-        candidate: void 0,
-        retiredGenerations: /* @__PURE__ */ new Set()
-      });
-      return { ok: true, value: target5 };
-    },
-    stage(target5, descriptor) {
-      const found = requireTarget(target5, "resize");
-      if (!found.ok) return found;
-      const state = found.value;
-      if (state.state === "rebuilding") {
-        return invalid5("resize", "generation-mismatch", state.state, state.generation);
-      }
-      const candidate = Object.freeze({
-        generation: state.state === "uninitialized" ? options.initialGeneration : state.generation,
-        descriptor: frozenDescriptor(descriptor ?? state.descriptor)
-      });
-      state.candidate = candidate;
-      state.state = "candidate";
-      return { ok: true, value: candidate };
-    },
-    promote(target5, generation) {
-      const found = requireTarget(target5, "resize");
-      if (!found.ok) return found;
-      const state = found.value;
-      if (state.candidate?.generation !== generation) {
-        return invalid5("resize", "generation-mismatch", state.state, state.generation);
-      }
-      state.descriptor = state.candidate.descriptor;
-      state.generation = generation;
-      state.candidate = void 0;
-      state.state = "active";
-      return { ok: true, value: void 0 };
-    },
-    rejectCandidate(target5, generation, stage) {
-      const found = requireTarget(target5, "resize");
-      if (!found.ok) return found;
-      const state = found.value;
-      if (state.candidate?.generation !== generation) {
-        return invalid5("resize", "generation-mismatch", state.state, state.generation);
-      }
-      state.candidate = void 0;
-      state.state = state.generation === 0 ? "uninitialized" : "active";
-      return {
-        ok: false,
-        error: new RenderTargetOperationFailedError({
-          operation: "resize",
-          stage,
-          generation,
-          cause: new Error(`candidate ${generation} failed during ${stage}`),
-          recovery: state.generation === 0 ? "retry" : "retain-last-known-good"
-        })
-      };
-    },
-    beginRecovery(target5, generation) {
-      const found = requireTarget(target5, "resize");
-      if (!found.ok) return found;
-      const state = found.value;
-      if (state.state !== "active" || generation <= state.generation) {
-        return invalid5("resize", "generation-mismatch", state.state, state.generation);
-      }
-      state.generation = generation;
-      state.candidate = void 0;
-      state.state = "rebuilding";
-      return { ok: true, value: void 0 };
-    },
-    finishRecovery(target5) {
-      const found = requireTarget(target5, "resize");
-      if (!found.ok) return found;
-      const state = found.value;
-      if (state.state !== "rebuilding") {
-        return invalid5("resize", "generation-mismatch", state.state, state.generation);
-      }
-      state.state = "uninitialized";
-      return { ok: true, value: void 0 };
-    },
-    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(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);
-      }
-      if (state.state === "destroyed") return { ok: true, value: void 0 };
-      state.candidate = void 0;
-      state.state = "destroyed";
-      return { ok: true, value: void 0 };
-    },
-    inspect(target5) {
-      const found = requireTarget(target5, "inspect");
-      if (!found.ok) return found;
-      const state = found.value;
-      return {
-        ok: true,
-        value: Object.freeze({
-          token: state.target,
-          state: state.state,
-          generation: state.generation,
-          descriptor: state.descriptor,
-          ...state.candidate === void 0 ? {} : { candidate: state.candidate }
-        })
-      };
-    }
-  };
-}
-
-// src/targets/readback.ts
-function invalidTicket(ticket, reason2) {
-  return {
-    ok: false,
-    error: new RenderTargetStateInvalidError({
-      operation: "readback",
-      reason: reason2,
-      state: reason2 === "destroyed" ? "destroyed" : "active",
-      generation: ticket.deviceGeneration
-    })
-  };
-}
-function bindRenderTargetReadbackTicket(ticket, receipt) {
-  if (ticket.consumed) return invalidTicket(ticket, "destroyed");
-  if (ticket.frameId !== void 0) {
-    return invalidTicket(ticket, "generation-mismatch");
-  }
-  ticket.frameId = receipt.frameId;
-  ticket.deviceGeneration = receipt.deviceGeneration;
-  return { ok: true, value: void 0 };
-}
-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,
-      error: new RenderTargetOperationFailedError({
-        operation: "readback",
-        stage: "copy",
-        generation: input.deviceGeneration,
-        cause: new Error("readback dimensions and identity must be non-negative integers"),
-        recovery: "retry"
-      })
-    };
-  }
-  const unalignedRowBytes = input.width * input.bytesPerPixel;
-  const bytesPerRow = Math.ceil(unalignedRowBytes / 256) * 256;
-  return {
-    ok: true,
-    value: {
-      target: target5,
-      frameId: input.frameId,
-      deviceGeneration: input.deviceGeneration,
-      mipLevel: input.mipLevel,
-      ...input.face === void 0 ? {} : { face: input.face },
-      width: input.width,
-      height: input.height,
-      bytesPerRow,
-      byteLength: bytesPerRow * input.height,
-      consumed: false
-    }
-  };
-}
-function completeRenderTargetReadback(ticket, receipt, bytes2) {
-  if (ticket.consumed) return invalidTicket(ticket, "destroyed");
-  if (ticket.frameId === void 0 || receipt.frameId !== ticket.frameId || receipt.deviceGeneration !== ticket.deviceGeneration) {
-    return invalidTicket(ticket, "generation-mismatch");
-  }
-  if (bytes2.byteLength !== ticket.byteLength) {
-    return {
-      ok: false,
-      error: new RenderTargetOperationFailedError({
-        operation: "readback",
-        stage: "copy",
-        generation: ticket.deviceGeneration,
-        cause: new Error(`expected ${ticket.byteLength} bytes, received ${bytes2.byteLength}`),
-        recovery: "retry"
-      })
-    };
-  }
-  ticket.consumed = true;
-  return {
-    ok: true,
-    value: {
-      bytes: bytes2,
-      frameId: ticket.frameId,
-      deviceGeneration: ticket.deviceGeneration,
-      mipLevel: ticket.mipLevel,
-      ...ticket.face === void 0 ? {} : { face: ticket.face }
-    }
-  };
-}
-
-// src/assembly/render-target-host.ts
-var DEFAULT_LIMITS = {
-  maxTextureDimension2D: 8192,
-  maxBytesPerTarget: 256 * 1024 * 1024,
-  renderableFormats: ["rgba16float", "rgba8unorm", "rgba8unorm-srgb"],
-  sampleCounts: [1, 4],
-  depthFormats: ["depth24plus-stencil8", "depth32float"]
-};
-function opaqueTicket() {
-  return Object.freeze({});
-}
-function bytesPerPixel(format) {
-  return format === "rgba16float" ? 8 : 4;
-}
-function mipCount(descriptor) {
-  return descriptor.mipLevels === 1 ? 1 : Math.floor(Math.log2(Math.max(descriptor.width, descriptor.height))) + 1;
-}
-function makePhysical(device, descriptor, generation) {
-  const layers = descriptor.shape === "cube" ? 6 : 1;
-  const usage = GPU_TEXTURE_USAGE_RENDER_ATTACHMENT | (descriptor.sampled ? GPU_TEXTURE_USAGE_TEXTURE_BINDING : 0) | (descriptor.readback ? GPU_TEXTURE_USAGE_COPY_SRC : 0);
-  const created = device.createTexture({
-    label: `render-target.${generation}`,
-    size: { width: descriptor.width, height: descriptor.height, depthOrArrayLayers: layers },
-    format: descriptor.format,
-    mipLevelCount: mipCount(descriptor),
-    // WebGPU forbids multisampled array textures. The cube is always the
-    // single-sample resolve destination; MSAA capture uses one depth=1 color
-    // texture per face below.
-    sampleCount: 1,
-    dimension: "2d",
-    usage,
-    viewFormats: void 0,
-    textureBindingViewDimension: descriptor.shape === "cube" ? "cube" : void 0
-  });
-  if (!created.ok)
-    return {
-      ok: false,
-      error: new RenderTargetOperationFailedError({
-        operation: "create",
-        stage: "allocation",
-        generation,
-        cause: created.error,
-        recovery: "retry"
-      })
-    };
-  const texture = created.value;
-  const view = device.createTextureView(texture, {
-    dimension: descriptor.shape,
-    baseMipLevel: 0,
-    mipLevelCount: mipCount(descriptor),
-    baseArrayLayer: 0,
-    arrayLayerCount: layers
-  });
-  if (!view.ok)
-    return {
-      ok: false,
-      error: new RenderTargetOperationFailedError({
-        operation: "create",
-        stage: "allocation",
-        generation,
-        cause: view.error,
-        recovery: "retry"
-      })
-    };
-  const mipViews = [];
-  for (let mip = 0; mip < mipCount(descriptor); mip += 1) {
-    const mipView = device.createTextureView(texture, {
-      dimension: descriptor.shape,
-      baseMipLevel: mip,
-      mipLevelCount: 1,
-      baseArrayLayer: 0,
-      arrayLayerCount: layers
-    });
-    if (!mipView.ok)
-      return {
-        ok: false,
-        error: new RenderTargetOperationFailedError({
-          operation: "create",
-          stage: "allocation",
-          generation,
-          cause: mipView.error,
-          recovery: "retry"
-        })
-      };
-    mipViews.push(mipView.value);
-  }
-  const resolveFaceViews = [];
-  for (let face = 0; face < layers; face += 1) {
-    const faceView = device.createTextureView(texture, {
-      dimension: "2d",
-      baseMipLevel: 0,
-      mipLevelCount: 1,
-      baseArrayLayer: face,
-      arrayLayerCount: 1
-    });
-    if (!faceView.ok)
-      return {
-        ok: false,
-        error: new RenderTargetOperationFailedError({
-          operation: "create",
-          stage: "allocation",
-          generation,
-          cause: faceView.error,
-          recovery: "retry"
-        })
-      };
-    resolveFaceViews.push(faceView.value);
-  }
-  const colorTextures = [];
-  const faceViews = [];
-  const depthTextures = [];
-  const depthViews = [];
-  if (descriptor.shape === "cube") {
-    for (let face = 0; face < layers; face += 1) {
-      const depth = device.createTexture({
-        label: `render-target.${generation}.depth.${face}`,
-        size: {
-          width: descriptor.width,
-          height: descriptor.height,
-          depthOrArrayLayers: descriptor.sampleCount === 4 ? 1 : layers
-        },
-        mipLevelCount: 1,
-        sampleCount: descriptor.sampleCount,
-        dimension: "2d",
-        format: "depth24plus-stencil8",
-        usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
-        viewFormats: void 0,
-        textureBindingViewDimension: void 0
-      });
-      if (!depth.ok)
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: "create",
-            stage: "allocation",
-            generation,
-            cause: depth.error,
-            recovery: "retry"
-          })
-        };
-      const depthView = device.createTextureView(depth.value, {
-        dimension: "2d",
-        baseArrayLayer: descriptor.sampleCount === 4 ? 0 : face,
-        arrayLayerCount: 1
-      });
-      if (!depthView.ok)
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: "create",
-            stage: "allocation",
-            generation,
-            cause: depthView.error,
-            recovery: "retry"
-          })
-        };
-      depthTextures.push(depth.value);
-      depthViews.push(depthView.value);
-    }
-  }
-  if (descriptor.sampleCount === 4) {
-    for (let face = 0; face < layers; face += 1) {
-      const msaa = device.createTexture({
-        label: `render-target.${generation}.msaa.${face}`,
-        size: { width: descriptor.width, height: descriptor.height, depthOrArrayLayers: 1 },
-        format: descriptor.format,
-        mipLevelCount: 1,
-        sampleCount: 4,
-        dimension: "2d",
-        usage: GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
-        viewFormats: void 0,
-        textureBindingViewDimension: void 0
-      });
-      if (!msaa.ok)
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: "create",
-            stage: "allocation",
-            generation,
-            cause: msaa.error,
-            recovery: "retry"
-          })
-        };
-      const msaaView = device.createTextureView(msaa.value, {
-        dimension: "2d",
-        baseMipLevel: 0,
-        mipLevelCount: 1,
-        baseArrayLayer: 0,
-        arrayLayerCount: 1
-      });
-      if (!msaaView.ok)
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: "create",
-            stage: "allocation",
-            generation,
-            cause: msaaView.error,
-            recovery: "retry"
-          })
-        };
-      colorTextures.push(msaa.value);
-      faceViews.push(msaaView.value);
-    }
-  } else {
-    for (let face = 0; face < layers; face += 1) {
-      colorTextures.push(texture);
-      faceViews.push(resolveFaceViews[face] ?? view.value);
-    }
-  }
-  return {
-    ok: true,
-    value: {
-      generation,
-      descriptor,
-      texture,
-      view: view.value,
-      mipViews,
-      colorTextures,
-      faceViews,
-      depthTextures,
-      depthViews,
-      ...descriptor.sampleCount === 4 ? { resolveTexture: texture } : {},
-      resolveView: view.value,
-      resolveFaceViews
-    }
-  };
-}
-function destroyPhysical(device, physical) {
-  if (device === void 0 || physical === void 0) return;
-  const textures = /* @__PURE__ */ new Set();
-  textures.add(physical.texture);
-  if (physical.resolveTexture !== void 0) textures.add(physical.resolveTexture);
-  for (const texture of physical.colorTextures) textures.add(texture);
-  for (const texture of physical.depthTextures) textures.add(texture);
-  for (const texture of textures) device.destroyTexture(texture);
-}
-function createRenderTargetHost(options = {}) {
-  let disposed = false;
-  const limits = options.limits ?? DEFAULT_LIMITS;
-  const owner = createRenderTargetOwner({
-    rendererId: options.rendererId ?? /* @__PURE__ */ Symbol("renderer"),
-    initialGeneration: options.initialGeneration ?? 0
-  });
-  const targets = /* @__PURE__ */ new Set();
-  const staged = /* @__PURE__ */ new Set();
-  const activePhysical = /* @__PURE__ */ new WeakMap();
-  const candidatePhysical = /* @__PURE__ */ new WeakMap();
-  const sources = /* @__PURE__ */ new WeakMap();
-  const readbacks = /* @__PURE__ */ new WeakMap();
-  const readbackRecords = /* @__PURE__ */ new Set();
-  const currentGeneration = () => options.getGeneration?.() ?? options.initialGeneration ?? 0;
-  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(target5);
-      return { ok: true, value: void 0 };
-    }
-    const physical = makePhysical(
-      device,
-      stagedTarget.value.descriptor,
-      stagedTarget.value.generation
-    );
-    if (!physical.ok) {
-      owner.rejectCandidate(target5, stagedTarget.value.generation, "allocation");
-      return physical;
-    }
-    candidatePhysical.set(target5, physical.value);
-    staged.add(target5);
-    return { ok: true, value: void 0 };
-  };
-  return Object.freeze({
-    owner: "renderer",
-    createRenderTarget(descriptor) {
-      if (disposed) {
-        return {
-          ok: false,
-          error: new RenderTargetStateInvalidError({
-            operation: "inspect",
-            reason: "destroyed",
-            state: "destroyed",
-            generation: currentGeneration()
-          })
-        };
-      }
-      const admitted = admitRenderTargetDescriptor(descriptor, limits);
-      if (!admitted.ok) return admitted;
-      const created = owner.create(admitted.value);
-      if (created.ok) targets.add(created.value);
-      return created;
-    },
-    resizeRenderTarget(target5, descriptor) {
-      const admitted = admitRenderTargetDescriptor(descriptor, limits);
-      if (!admitted.ok) return admitted;
-      return stagePhysical(target5, admitted.value);
-    },
-    createRenderTargetTextureSource(target5, sourceOptions) {
-      const inspected = owner.inspect(target5);
-      if (!inspected.ok) return inspected;
-      if (!inspected.value.descriptor.sampled) {
-        return {
-          ok: false,
-          error: new RenderTargetCapabilityMissingError({
-            operation: "source",
-            requested: "sampled=true",
-            capability: "sampled",
-            actual: "false"
-          })
-        };
-      }
-      if (sourceOptions.dimension !== inspected.value.descriptor.shape) {
-        return {
-          ok: false,
-          error: new RenderTargetDescriptorInvalidError({
-            field: "dimension",
-            value: sourceOptions.dimension,
-            expected: `dimension matches ${inspected.value.descriptor.shape}`
-          })
-        };
-      }
-      if (!Number.isInteger(sourceOptions.mipLevel) || sourceOptions.mipLevel < 0 || inspected.value.descriptor.mipLevels === 1 && sourceOptions.mipLevel !== 0) {
-        return {
-          ok: false,
-          error: new RenderTargetDescriptorInvalidError({
-            field: "mipLevel",
-            value: sourceOptions.mipLevel,
-            expected: "an admitted mip level for the target"
-          })
-        };
-      }
-      const binding = createRenderTargetMaterialSource(target5, inspected.value.descriptor, {
-        ...sourceOptions,
-        generation: inspected.value.generation
-      });
-      if (!binding.ok) return binding;
-      sources.set(binding.value.source, binding.value);
-      return { ok: true, value: binding.value.source };
-    },
-    resolveRenderTargetTextureSource(source) {
-      const binding = sources.get(source) ?? resolveRenderTargetMaterialSource(source);
-      if (binding === void 0) return void 0;
-      const physical = activePhysical.get(binding.target);
-      if (physical === void 0) return binding;
-      const view = physical.mipViews[binding.view.mipLevel] ?? (binding.shape === "cube" ? physical.view : physical.resolveView);
-      if (binding.generation !== physical.generation) return binding;
-      return { ...binding, textureView: view };
-    },
-    requestTargetReadback(target5, request) {
-      const inspected = owner.inspect(target5);
-      if (!inspected.ok) return inspected;
-      if (!inspected.value.descriptor.readback) {
-        return {
-          ok: false,
-          error: new RenderTargetCapabilityMissingError({
-            operation: "readback",
-            requested: "readback=true",
-            capability: "readback",
-            actual: "false"
-          })
-        };
-      }
-      if (!Number.isInteger(request.mipLevel) || request.mipLevel < 0) {
-        return {
-          ok: false,
-          error: new RenderTargetDescriptorInvalidError({
-            field: "mipLevel",
-            value: request.mipLevel,
-            expected: "a non-negative integer"
-          })
-        };
-      }
-      const mipCount2 = inspected.value.descriptor.mipLevels === 1 ? 1 : Math.floor(
-        Math.log2(
-          Math.max(inspected.value.descriptor.width, inspected.value.descriptor.height)
-        )
-      ) + 1;
-      if (request.mipLevel >= mipCount2) {
-        return {
-          ok: false,
-          error: new RenderTargetDescriptorInvalidError({
-            field: "mipLevel",
-            value: request.mipLevel,
-            expected: `mipLevel < ${mipCount2}`
-          })
-        };
-      }
-      if (request.face !== void 0 && (!Number.isInteger(request.face) || request.face < 0 || request.face > 5 || inspected.value.descriptor.shape !== "cube")) {
-        return {
-          ok: false,
-          error: new RenderTargetDescriptorInvalidError({
-            field: "face",
-            value: request.face,
-            expected: inspected.value.descriptor.shape === "cube" ? "an integer in [0, 5]" : "omitted for a 2d target"
-          })
-        };
-      }
-      const ticket = opaqueTicket();
-      const extent = resolveRenderTargetMipExtent(inspected.value.descriptor, request.mipLevel);
-      const buffer = options.getDevice?.()?.createBuffer({
-        label: `render-target-readback.${request.mipLevel}.${request.face ?? 0}`,
-        size: Math.ceil(extent.width * bytesPerPixel(inspected.value.descriptor.format) / 256) * 256 * extent.height,
-        usage: GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ,
-        mappedAtCreation: false
-      });
-      if (buffer !== void 0 && !buffer.ok) {
-        return {
-          ok: false,
-          error: new RenderTargetOperationFailedError({
-            operation: "readback",
-            stage: "allocation",
-            generation: inspected.value.generation,
-            cause: buffer.error,
-            recovery: "retry"
-          })
-        };
-      }
-      const internalTicket = createRenderTargetReadbackTicket(target5, {
-        deviceGeneration: inspected.value.generation,
-        mipLevel: request.mipLevel,
-        ...request.face === void 0 ? {} : { face: request.face },
-        width: extent.width,
-        height: extent.height,
-        bytesPerPixel: bytesPerPixel(inspected.value.descriptor.format)
-      });
-      if (!internalTicket.ok) return internalTicket;
-      const record = {
-        target: target5,
-        request,
-        ticket: internalTicket.value,
-        ...buffer === void 0 ? {} : { buffer: buffer.value },
-        encoded: false
-      };
-      readbacks.set(ticket, record);
-      readbackRecords.add(record);
-      return { ok: true, value: ticket };
-    },
-    async observeTargetReadbacks(receipt, tickets) {
-      const results = [];
-      for (const publicTicket of tickets) {
-        const record = readbacks.get(publicTicket);
-        if (record === void 0) {
-          return {
-            ok: false,
-            error: new RenderTargetStateInvalidError({
-              operation: "readback",
-              reason: "foreign-renderer",
-              state: "destroyed",
-              generation: receipt.deviceGeneration
-            })
-          };
-        }
-        const inspected = owner.inspect(record.target);
-        if (!inspected.ok) return inspected;
-        if (inspected.value.state !== "active") {
-          return {
-            ok: false,
-            error: new RenderTargetStateInvalidError({
-              operation: "readback",
-              reason: "uninitialized",
-              state: inspected.value.state,
-              generation: inspected.value.generation
-            })
-          };
-        }
-        if (inspected.value.generation !== receipt.deviceGeneration) {
-          return {
-            ok: false,
-            error: new RenderTargetStateInvalidError({
-              operation: "readback",
-              reason: "generation-mismatch",
-              state: inspected.value.state,
-              generation: inspected.value.generation
-            })
-          };
-        }
-        const bound = bindRenderTargetReadbackTicket(record.ticket, receipt);
-        if (!bound.ok) return bound;
-        let bytes2 = new Uint8Array(record.ticket.byteLength);
-        if (record.buffer !== void 0 && typeof record.buffer.mapAsync === "function") {
-          const mapped = await record.buffer.mapAsync(1);
-          if (!mapped.ok) {
-            return {
-              ok: false,
-              error: new RenderTargetOperationFailedError({
-                operation: "readback",
-                stage: "copy",
-                generation: receipt.deviceGeneration,
-                cause: mapped.error,
-                recovery: "retry"
-              })
-            };
-          }
-          const range = mapped.value.getMappedRange();
-          if (!range.ok) {
-            return {
-              ok: false,
-              error: new RenderTargetOperationFailedError({
-                operation: "readback",
-                stage: "copy",
-                generation: receipt.deviceGeneration,
-                cause: range.error,
-                recovery: "retry"
-              })
-            };
-          }
-          bytes2 = new Uint8Array(range.value.slice(0));
-          mapped.value.unmap();
-        }
-        const completed = completeRenderTargetReadback(record.ticket, receipt, bytes2);
-        if (!completed.ok) return completed;
-        results.push({
-          ticket: publicTicket,
-          bytes: completed.value.bytes,
-          frameId: completed.value.frameId,
-          deviceGeneration: completed.value.deviceGeneration,
-          mipLevel: completed.value.mipLevel,
-          ...completed.value.face === void 0 ? {} : { face: completed.value.face },
-          bytesPerRow: record.ticket.bytesPerRow,
-          byteLength: record.ticket.byteLength
-        });
-      }
-      return { ok: true, value: Object.freeze(results) };
-    },
-    destroyRenderTarget(target5) {
-      const destroyed = owner.destroy(target5);
-      if (destroyed.ok) {
-        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 !== target5) continue;
-          if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
-          readbacks.delete(record.ticket);
-          readbackRecords.delete(record);
-        }
-        targets.delete(target5);
-      }
-      return destroyed;
-    },
-    beginFrame() {
-      if (disposed) return;
-      for (const target5 of targets) {
-        const inspected = owner.inspect(target5);
-        if (!inspected.ok || inspected.value.state === "active" || inspected.value.state === "candidate") {
-          continue;
-        }
-        stagePhysical(target5);
-      }
-    },
-    onFrameSubmitted(completed = Promise.resolve({ ok: true, value: void 0 })) {
-      if (disposed) return;
-      const submittedTargets = [...staged];
-      staged.clear();
-      void completed.then((result) => {
-        for (const target5 of submittedTargets) {
-          const candidate = owner.inspect(target5);
-          if (!candidate.ok || candidate.value.candidate === void 0) continue;
-          if (!result.ok) {
-            owner.rejectCandidate(target5, candidate.value.candidate.generation, "submit");
-            destroyPhysical(options.getDevice?.(), candidatePhysical.get(target5));
-            candidatePhysical.delete(target5);
-            continue;
-          }
-          if (options.canPromoteTarget?.(target5) === false) {
-            staged.add(target5);
-            continue;
-          }
-          const generation = candidate.value.candidate.generation;
-          const physical = candidatePhysical.get(target5);
-          if (physical === void 0) {
-            owner.rejectCandidate(target5, generation, "submit");
-            continue;
-          }
-          const promoted = owner.promote(target5, generation);
-          if (!promoted.ok) {
-            destroyPhysical(options.getDevice?.(), physical);
-            candidatePhysical.delete(target5);
-            continue;
-          }
-          const previous = activePhysical.get(target5);
-          activePhysical.set(target5, physical);
-          candidatePhysical.delete(target5);
-          destroyPhysical(options.getDevice?.(), previous);
-        }
-      });
-    },
-    getPhysicalTarget(target5) {
-      return candidatePhysical.get(target5) ?? activePhysical.get(target5);
-    },
-    encodePendingReadbacks(encoder, faces) {
-      for (const record of readbackRecords) {
-        if (record.encoded || record.buffer === void 0) continue;
-        if (faces !== void 0 && record.ticket.face !== void 0 && !faces.includes(record.ticket.face)) {
-          continue;
-        }
-        const candidate = candidatePhysical.get(record.target);
-        const physical = faces !== void 0 && candidate !== void 0 && record.ticket.face !== void 0 && faces.includes(record.ticket.face) ? candidate : activePhysical.get(record.target);
-        if (physical === void 0) continue;
-        const source = physical.resolveTexture ?? physical.texture;
-        encoder.copyTextureToBuffer(
-          {
-            texture: source,
-            mipLevel: record.ticket.mipLevel,
-            origin: { x: 0, y: 0, z: record.ticket.face ?? 0 }
-          },
-          {
-            buffer: record.buffer,
-            bytesPerRow: record.ticket.bytesPerRow,
-            rowsPerImage: record.ticket.height
-          },
-          [record.ticket.width, record.ticket.height, 1]
-        );
-        record.encoded = true;
-      }
-    },
-    recover() {
-      if (disposed) return;
-      const generation = currentGeneration();
-      for (const target5 of targets) {
-        const inspected = owner.inspect(target5);
-        if (!inspected.ok || inspected.value.state !== "active") continue;
-        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 !== target5) continue;
-          if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
-          readbacks.delete(record.ticket);
-          readbackRecords.delete(record);
-        }
-        const begun = owner.beginRecovery(target5, generation);
-        if (begun.ok) owner.finishRecovery(target5);
-      }
-    },
-    dispose() {
-      disposed = true;
-      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 !== target5) continue;
-          if (record.buffer !== void 0) options.getDevice?.()?.destroyBuffer(record.buffer);
-          readbacks.delete(record.ticket);
-          readbackRecords.delete(record);
-        }
-        activePhysical.delete(target5);
-        candidatePhysical.delete(target5);
-        owner.destroy(target5);
-      }
-      targets.clear();
-      staged.clear();
-      readbackRecords.clear();
-    }
-  });
-}
-
 // src/assembly/renderer-feature-inspection.ts
 function projectRendererFeatureInspection(featureHost) {
   const featureDiagnostics = featureHost?.diagnostics() ?? Object.freeze([]);
@@ -41967,6 +40722,7 @@ function createSkinPaletteAllocator(device, maxBindingSize, useStorageBuffer = t
     if (allocation === void 0) pendingDirty.set(identity, dirty);
   }
   function releasePersistentSlice(identity) {
+    frameSeenPersistent.delete(identity);
     const allocation = persistent.get(identity);
     persistent.delete(identity);
     pendingDirty.delete(identity);
@@ -44249,11 +43005,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
       }
       try {
         getOrBuildPipeline(spec, pipelineDeviceProvider, pipelineCache, modules);
-      } catch (err57) {
-        if (err57 instanceof PipelineSpecError) throw err57;
+      } catch (err58) {
+        if (err58 instanceof PipelineSpecError) throw err58;
         throw new PipelineSpecError({
           code: "pipeline-build-failed",
-          detail: { cause: err57 },
+          detail: { cause: err58 },
           hint: `Boot-time SPEC_CONST pre-warm failed for shader '${spec.shader.id}'; inspect gpuMessage on the cause`
         });
       }
@@ -44407,11 +43163,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
             pipelineCache,
             modules
           );
-        } catch (err57) {
-          if (err57 instanceof PipelineSpecError) throw err57;
+        } catch (err58) {
+          if (err58 instanceof PipelineSpecError) throw err58;
           throw new PipelineSpecError({
             code: "pipeline-build-failed",
-            detail: { cause: err57 },
+            detail: { cause: err58 },
             hint: "createRenderPipeline (fxaa fullscreen) failed; inspect gpuMessage"
           });
         }
@@ -44666,11 +43422,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomDownsamplePipelineHandle,
                 () => void 0
               );
-            } catch (err57) {
-              if (err57 instanceof PipelineSpecError) throw err57;
+            } catch (err58) {
+              if (err58 instanceof PipelineSpecError) throw err58;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err57 },
+                detail: { cause: err58 },
                 hint: "createRenderPipeline (bloom-downsample fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -44776,11 +43532,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomUpsamplePipelineHandle,
                 () => void 0
               );
-            } catch (err57) {
-              if (err57 instanceof PipelineSpecError) throw err57;
+            } catch (err58) {
+              if (err58 instanceof PipelineSpecError) throw err58;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err57 },
+                detail: { cause: err58 },
                 hint: "createRenderPipeline (bloom-upsample fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -44881,11 +43637,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
                 bloomCompositePipelineHandle,
                 () => void 0
               );
-            } catch (err57) {
-              if (err57 instanceof PipelineSpecError) throw err57;
+            } catch (err58) {
+              if (err58 instanceof PipelineSpecError) throw err58;
               throw new PipelineSpecError({
                 code: "pipeline-build-failed",
-                detail: { cause: err57 },
+                detail: { cause: err58 },
                 hint: "createRenderPipeline (bloom-composite fullscreen) failed; inspect gpuMessage"
               });
             }
@@ -45183,11 +43939,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_calc" }
             );
-          } catch (err57) {
-            if (err57 instanceof PipelineSpecError) throw err57;
+          } catch (err58) {
+            if (err58 instanceof PipelineSpecError) throw err58;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err57 },
+              detail: { cause: err58 },
               hint: "createRenderPipeline (ssao-calc fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -45218,11 +43974,11 @@ async function buildReadyWebGPU(rhiDevice, rendererScope, getShader, gpuStore, a
               pipelineCache,
               { ...baseModules, fragmentEntryPoint: "fs_ssao_blur" }
             );
-          } catch (err57) {
-            if (err57 instanceof PipelineSpecError) throw err57;
+          } catch (err58) {
+            if (err58 instanceof PipelineSpecError) throw err58;
             throw new PipelineSpecError({
               code: "pipeline-build-failed",
-              detail: { cause: err57 },
+              detail: { cause: err58 },
               hint: "createRenderPipeline (ssao-blur fullscreen) failed; inspect gpuMessage"
             });
           }
@@ -45621,6 +44377,28 @@ function createRendererObservationCaptureOwner(fireError) {
   };
   return owner;
 }
+var PARTICLE_MESH_DEFAULTS = {
+  position: [0, 0, 0],
+  normal: [0, 0, 1],
+  uv: [0, 0],
+  tangent: [1, 0, 0, 1],
+  uv1: [0, 0],
+  color: [1, 1, 1, 1]
+};
+var PARTICLE_MESH_GEOMETRY = deriveVertexLayoutProjection(
+  Object.fromEntries(Object.keys(PARTICLE_MESH_DEFAULTS).map((key) => [key, new Float32Array()]))
+);
+var PARTICLE_MESH_VERTEX_BUFFER = {
+  arrayStride: PARTICLE_MESH_GEOMETRY.arrayStride,
+  stepMode: "vertex",
+  attributes: PARTICLE_MESH_GEOMETRY.attributes.map(({ key, shaderLocation, offset: offset2, format }) => ({
+    shaderLocation: key === "color" ? 14 : key === "uv1" ? 15 : shaderLocation,
+    offset: offset2,
+    format
+  }))
+};
+
+// src/assembly/webgpu-vertex-layouts.ts
 var FLOAT32_COMPONENT_COUNT = {
   float32x2: 2,
   float32x3: 3,
@@ -45687,13 +44465,6 @@ var MESH_GEOMETRY_MATERIAL_INSTANCE_SPEC = {
 };
 var PREPARED_INSTANCE_VERTEX_ATTRS = buildMeshAttributeMapForUvSets(2);
 var PREPARED_MATERIAL_INSTANCE_VERTEX_ATTRS = SKIN_VERTEX_ATTRIBUTE_MAP;
-function canonicalMeshVertexBufferLayout() {
-  const [buffer] = toGpuVertexBufferLayouts(deriveVertexBufferLayout(DEFAULT_VERTEX_ATTRIBUTE_MAP));
-  if (buffer === void 0) {
-    throw new Error("The canonical mesh vertex layout must contain one vertex buffer");
-  }
-  return { ...buffer, stepMode: "vertex" };
-}
 var POSITION_SIZE_COLOR_INSTANCE_VERTEX_BUFFERS = [
   defineFeatureVertexBuffer(POSITION_SIZE_COLOR_INSTANCE_SPEC)
 ];
@@ -45704,7 +44475,7 @@ var TOPOLOGY_SEGMENT_INSTANCE_VERTEX_BUFFERS = [
   defineFeatureVertexBuffer(TOPOLOGY_SEGMENT_INSTANCE_SPEC)
 ];
 var MESH_GEOMETRY_MATERIAL_INSTANCE_VERTEX_BUFFERS = [
-  canonicalMeshVertexBufferLayout(),
+  PARTICLE_MESH_VERTEX_BUFFER,
   defineFeatureVertexBuffer(MESH_GEOMETRY_MATERIAL_INSTANCE_SPEC)
 ];
 var PREPARED_MATERIAL_VERTEX_LAYOUTS = /* @__PURE__ */ new Set([
@@ -45796,12 +44567,13 @@ function resolveWebGPUVertexBufferLayouts(options) {
 }
 
 // src/assembly/webgpu-renderer.ts
-var nextDerivedSystemId = 0;
 async function tryCreateWebGPURenderer2(canvas, options, pack, bundler) {
   return tryCreateWebGPURenderer(canvas, options, pack, bundler, makeWebGPURenderer);
 }
 async function makeWebGPURenderer(internals) {
+  let publicationTargets;
   let disposed = false;
+  const publicationReceiver = internals.options?.publicationSource === void 0 ? void 0 : new RenderPublicationReceiver(internals.options.publicationSource);
   const observeTiming = observeGpuPassTimingDisabled;
   const frameContinuations = /* @__PURE__ */ new Set();
   let recoveryAttempt = 0;
@@ -46015,11 +44787,10 @@ async function makeWebGPURenderer(internals) {
   const getShader = () => {
     const state = candidateShaderState ?? activeShaderState;
     if (state.shaderInstance === null) {
-      const bundler = internals.bundler;
-      const explicitUrl = bundler?.shaderManifestUrl;
-      state.shaderInstance = new ShaderCatalog({
+      const activeCatalog = activeShaderState.shaderInstance;
+      state.shaderInstance = state === candidateShaderState && activeCatalog !== null ? activeCatalog.forkForDevice(getShaderModuleAdapter()) : new ShaderCatalog({
         device: getShaderModuleAdapter(),
-        manifestUrl: bundler !== void 0 && "shaderManifestUrl" in bundler ? explicitUrl : "/shaders/manifest.json"
+        manifestUrl: internals.bundler !== void 0 && "shaderManifestUrl" in internals.bundler ? internals.bundler.shaderManifestUrl : "/shaders/manifest.json"
       });
     }
     return state.shaderInstance;
@@ -46096,7 +44867,8 @@ async function makeWebGPURenderer(internals) {
   gpuStore.configureGpuDevice(
     internals.device,
     packShaderFactory,
-    (world, pod) => {
+    (world, pod, source) => {
+      if ("resolveAsset" in world) return ok(source);
       const handle = world.allocSharedRef("EquirectAsset", pod);
       return ok(handle);
     },
@@ -47316,7 +46088,6 @@ async function makeWebGPURenderer(internals) {
     currentGeneration: () => activeDeviceScope.generation,
     renderSystem
   });
-  const derivedSystemNames = /* @__PURE__ */ new Map();
   const transformReleases = /* @__PURE__ */ new Map();
   const attachmentOwner = {};
   let frameId = 0;
@@ -47352,6 +46123,13 @@ async function makeWebGPURenderer(internals) {
       renderSystem.setSurfaceDynamicInput(frame);
     },
     attach(world) {
+      if (publicationReceiver !== void 0)
+        return err(
+          new RenderPublicationError({
+            reason: "identity",
+            subject: "publication Renderer has no World attachment"
+          })
+        );
       const attached = this.attachScene(world);
       if (!attached.ok) {
         return err(new RendererContractFailureError("attach", attached.error.hint));
@@ -47368,12 +46146,12 @@ async function makeWebGPURenderer(internals) {
     requestTargetReadback: (target5, request) => renderTargetHost.requestTargetReadback(target5, request),
     destroyRenderTarget: (target5) => renderTargetHost.destroyRenderTarget(target5),
     setProfile(profile) {
-      const invalid6 = validateRenderProfile(profile);
-      if (invalid6 !== void 0) {
+      const invalid4 = validateRenderProfile(profile);
+      if (invalid4 !== void 0) {
         return err(
           new RendererOperationError("frame-input-invalid", {
             operation: "set-profile",
-            cause: new RendererContractFailureError("draw", invalid6)
+            cause: new RendererContractFailureError("draw", invalid4)
           })
         );
       }
@@ -47562,23 +46340,7 @@ async function makeWebGPURenderer(internals) {
       }
       if (attachedWorlds.has(world)) return ok(void 0);
       try {
-        const releaseTransforms = registerPropagateTransforms(world);
-        const derivedSystemName = `renderDerived:${++nextDerivedSystemId}`;
-        const derived = world.addSystem(Update, {
-          name: derivedSystemName,
-          queries: [],
-          fn: (world2) => {
-            tilemapChunkExtractSystem(world2, (guid) => assets.lookup(guid));
-            const glyphResult = glyphTextLayoutSystem(world2, gpuStore);
-            if (!glyphResult.ok) throw glyphResult.error;
-          }
-        });
-        if (!derived.ok) {
-          releaseTransforms();
-          throw new Error(`failed to register ${derivedSystemName}: ${derived.error.code}`);
-        }
-        transformReleases.set(world, releaseTransforms);
-        derivedSystemNames.set(world, derivedSystemName);
+        transformReleases.set(world, registerRenderSourceSystems(world, assets, gpuStore));
         attachedWorlds.add(world);
         return ok(void 0);
       } catch (cause) {
@@ -47609,11 +46371,6 @@ async function makeWebGPURenderer(internals) {
         }
       }
       renderSystem.detachScene(world);
-      const derivedSystemName = derivedSystemNames.get(world);
-      if (derivedSystemName !== void 0) {
-        world.removeSystem(Update, derivedSystemName);
-        derivedSystemNames.delete(world);
-      }
       transformReleases.get(world)?.();
       transformReleases.delete(world);
     },
@@ -47797,8 +46554,26 @@ async function makeWebGPURenderer(internals) {
     },
     draw(worldsOrRequest, options) {
       const isFrameRequest = !Array.isArray(worldsOrRequest);
-      const frameRequest = isFrameRequest ? worldsOrRequest : void 0;
-      const worlds = frameRequest !== void 0 ? frameRequest.leases.map((lease) => attachedLeases.get(lease)).filter((world) => world !== void 0) : worldsOrRequest;
+      const publicationRequest = isFrameRequest && "publication" in worldsOrRequest ? worldsOrRequest : void 0;
+      const frameRequest = isFrameRequest && publicationRequest === void 0 ? worldsOrRequest : void 0;
+      let publication;
+      if (publicationRequest !== void 0) {
+        if (publicationReceiver === void 0)
+          return err(
+            new RenderPublicationError({
+              reason: "identity",
+              subject: "RendererOptions.publicationSource"
+            })
+          );
+      } else if (publicationReceiver !== void 0) {
+        return err(
+          new RenderPublicationError({
+            reason: "identity",
+            subject: "a publication-bound renderer cannot consume local World leases"
+          })
+        );
+      }
+      const worlds = frameRequest !== void 0 ? frameRequest.leases.map((lease) => attachedLeases.get(lease)).filter((world) => world !== void 0) : publicationRequest === void 0 ? worldsOrRequest : [];
       const readLeases = frameRequest !== void 0 ? frameRequest.leases : worlds.map((world) => leasesByWorld.get(world)).every((lease) => lease !== void 0) ? worlds.map((world) => leasesByWorld.get(world)) : void 0;
       const physicsFrameError = derivedPhysicsFrameError(worlds);
       if (physicsFrameError !== void 0) return err(physicsFrameError);
@@ -47833,7 +46608,12 @@ async function makeWebGPURenderer(internals) {
         ...motionBlurDrawOptions(frameRequest),
         ...frameRequest.profileFrame === void 0 ? {} : { profileFrame: frameRequest.profileFrame },
         ...frameRequest.geometryLane === void 0 ? {} : { geometryLane: frameRequest.geometryLane }
-      } : options ?? { cameraOwner: 0, resourceOwner: 0 };
+      } : publicationRequest === void 0 ? options ?? { cameraOwner: 0, resourceOwner: 0 } : {
+        cameraOwner: 0,
+        resourceOwner: 0,
+        sampleTimeSeconds: publicationRequest.publication.sampleTimeSeconds,
+        temporalReset: publicationRequest.publication.temporalReset
+      };
       if (disposed) {
         const e = new RhiError({
           code: "rhi-not-available",
@@ -47881,7 +46661,7 @@ async function makeWebGPURenderer(internals) {
         internals.errorRegistry.fire(e);
         return err(e);
       }
-      const worldCount = Array.isArray(worlds) ? worlds.length : 0;
+      const worldCount = publicationRequest === void 0 ? Array.isArray(worlds) ? worlds.length : 0 : 1;
       if (worldCount === 0 && internals.device.caps.backendKind === "null") {
         return ok(void 0);
       }
@@ -47897,8 +46677,20 @@ async function makeWebGPURenderer(internals) {
         internals.errorRegistry
       );
       if (!contextConfigured.ok) return contextConfigured;
-      renderTargetHost.beginFrame();
       try {
+        if (publicationRequest !== void 0 && publicationReceiver !== void 0) {
+          const accepted = publicationReceiver.accept(publicationRequest.publication);
+          if (!accepted.ok) return accepted;
+          publicationTargets ??= new RenderPublicationTargetReceiver(renderTargetHost);
+          publication = {
+            ...publicationTargets.apply(accepted.value),
+            ...publicationRequest.onFeatureSourceSubmitted === void 0 ? {} : {
+              onFeatureSourceSubmitted: publicationRequest.onFeatureSourceSubmitted
+            }
+          };
+          installPublicationPrograms(assets, publicationRequest.publication.programs);
+        }
+        renderTargetHost.beginFrame();
         const timingHost = internals;
         const timingRequested = isFrameRequest && (frameRequest?.profileFrame !== void 0 || internals.options?.captureGpuTimings === true);
         let volumeTimingCapture;
@@ -47917,7 +46709,13 @@ async function makeWebGPURenderer(internals) {
             graphGeneration: 0
           };
         }
-        const submitted = renderSystem.draw(worlds, drawOptions, readLeases, volumeTimingCapture);
+        const submitted = renderSystem.draw(
+          worlds,
+          drawOptions,
+          readLeases,
+          volumeTimingCapture,
+          publication
+        );
         timingHost.observationFrameId = void 0;
         timingHost.observationCaptureDomains = void 0;
         timingHost.gpuPassTimingFrameIdentity = void 0;
@@ -48097,6 +46895,8 @@ async function makeWebGPURenderer(internals) {
         });
         internals.errorRegistry.fire(e);
         return err(e);
+      } finally {
+        publicationReceiver?.releaseVideoFrames();
       }
     },
     async observe(receipt, request) {
@@ -48301,6 +47101,7 @@ async function makeWebGPURenderer(internals) {
       disposed = true;
       for (const world of attachedWorlds) dynamicGeometryHost.invalidateDynamicGeometryWorld(world);
       dynamicGeometry.dispose();
+      publicationReceiver?.dispose();
       for (const continuation of frameContinuations) {
         continuation.terminate({ code: "disposed" });
       }
@@ -48311,11 +47112,6 @@ async function makeWebGPURenderer(internals) {
       }
       for (const world of attachedWorlds) {
         try {
-          const derivedSystemName = derivedSystemNames.get(world);
-          if (derivedSystemName !== void 0) {
-            world.removeSystem(Update, derivedSystemName);
-            derivedSystemNames.delete(world);
-          }
           transformReleases.get(world)?.();
           transformReleases.delete(world);
         } catch (cause) {