@forgeax/engine-render 0.1.34 → 0.1.35

package/dist/index.mjs

@@ -1,13 +1,21 @@
-export { BARREL_DISTORTION_FEATURE_IDENTITY, BARREL_DISTORTION_POST_PROCESS_ID, BARREL_DISTORTION_WGSL, BARREL_DISTORTION_WGSL_COORDINATE, CLOUD_DENSITY_COMPUTE_WGSL, CLOUD_HISTORY_FULLSCREEN_WGSL, CLOUD_HISTORY_SURFACE_COUNT, CLOUD_LAYER_DENSITY_BINDINGS, CLOUD_LAYER_DENSITY_CACHE, CLOUD_LAYER_DENSITY_OUTPUT, CLOUD_LAYER_DENSITY_PROGRAM, CLOUD_LAYER_FEATURE_IDENTITY, CLOUD_RGBA16FLOAT_BYTES_PER_TEXEL, CLOUD_VIEW_FULLSCREEN_WGSL, CLOUD_VIEW_PARAMS_BYTES, CloudHistoryStore, DEFAULT_REFLECTION_PROBE_LIMITS, DynamicGeometryError, DynamicInputError, LOD_OCCLUSION_INSPECTION_MAX_BYTES, LOD_OCCLUSION_INSPECTION_SCHEMA, ReadonlyDynamicInputPage, ReflectionProbeProjection, SSR_FORMAT_PROFILE, SSR_FORMAT_STAGES, acceptCloudLayerGeneration, admitPointsLines, admitReflectionProbe, admitSingleLayerMediumSubmission, admitSsrM0, admitSsrSpatial, advanceProbeFilter, applyCloudSolarTransmittance, boxProjectReflectionDirection, buildCloudDensityCache, buildReflectionProbeTable, cloudCapabilitiesFromRhi, cloudTemporalResetReasons, cloudTemporalSignature, commitProbeFilterStep, compositeCloudRadiance, consumeLodOcclusionInspection, createBarrelDistortionRenderFeature, createCloudHistory, createCloudLayerFeature, createCloudShadowProjection, createDynamicGeometryLifecycle, createProbeFilterState, estimateReflectionProbeBytes, evaluateCloudDensity, inspectCloudLayer, inspectCloudLayerResources, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, integrateCloudCameraPath, integrateCloudInterior, integrateCloudPath, integrateCloudSolarColumn, intersectCloudLayer, probeFilterIsSteady, projectCloudShadowUv, projectSsrDependencies, projectSsrSpatialInspection, reconstructCloudDensityCache, reflectionProbeTableBytes, reprojectCloudHistory, resolveSsrAdmissionGeneration, retainCloudLayerAfterFailure, sampleCloudDensity, sampleCloudShadow, selectReflectionProbe, serializeLodOcclusionInspection, serializeSsrSpatialInspection, snapshotCloudDensityCache, validateReflectionProbeInput, validateScreenSpaceReflection, zeroSsrAdmissionWork } from './chunk-ODZWR6JQ.mjs';
-import { Atmosphere, BarrelDistortion, Camera, CloudLayer, DirectionalLight, DynamicResolution, DepthOfField, Instances, Layer, LightProbe, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, Points, Lines, PostProcessParams, RectAreaLight, SceneInstance, SkyboxBackground, Skylight, SortKey, SpotLight, Visibility } from './chunk-UINHLCZA.mjs';
-export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, BarrelDistortion, CAMERA_BLOOM_INTENSITY_MAX, CAMERA_BLOOM_INTENSITY_MIN, CAMERA_BLOOM_SCATTER_MAX, CAMERA_BLOOM_SCATTER_MIN, CAMERA_BLOOM_SOFT_KNEE_MAX, CAMERA_BLOOM_SOFT_KNEE_MIN, CAMERA_BLOOM_THRESHOLD_MAX, CAMERA_BLOOM_THRESHOLD_MIN, CAMERA_EXPOSURE_MODE_AUTO, CAMERA_EXPOSURE_MODE_MANUAL, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CAMERA_TEMPERATURE_MAX, CAMERA_TEMPERATURE_MIN, CAMERA_TINT_MAX, CAMERA_TINT_MIN, CLOUD_QUALITY_PROFILES, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CameraError, CloudLayer, CloudLayerCacheInvalidError, CloudLayerCapabilityMissingError, CloudLayerInvalidParameterError, CloudLayerOwnerConflictError, CloudLayerResourceFailureError, CloudQualityValue, CubeCamera, DEFAULT_CLOUD_LAYER, DEFAULT_DEPTH_OF_FIELD_PARAMS, DEPTH_OF_FIELD_PARAMS_BYTE_SIZE, DepthOfField, DepthOfFieldQualityValue, DepthOfFieldSideValue, DepthOfFieldValidationError, DirectionalLight, DirectionalShadowFilterValue, DynamicResolution, Fog, Instances, Layer, LightProbe, Lines, MAX_VOLUMETRIC_FOG_OWNERS, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, REFLECTION_PROBE_UPDATE_CONTINUOUS, REFLECTION_PROBE_UPDATE_ONCE, REFLECTION_PROBE_UPDATE_ON_CHANGE, RectAreaLight, ReflectionProbe, SKYBOX_MODE_CUBEMAP, SceneInstance, ScreenSpaceReflection, SkyboxBackground, Skylight, SortKey, SpotLight, SunCardinalityError, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, VolumetricFogSamplingValue, attachBarrelDistortionCameraFrame, buildCubeCameraFaceViews, cameraExposureFromColumns, cameraProjectionFromF32, cloudLayerSourceKey, cloudQualityFromF32, computeInvRangeSquared, createBarrelDistortionMapping, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, depthOfFieldQualityCode, depthOfFieldQualityFromF32, depthOfFieldRequestFailure, depthOfFieldSideCode, depthOfFieldSideFromF32, depthOfFieldTapCount, directionalShadowQualityFromF32, extractCloudLayer, extractVolumetricFog, freezeBarrelDistortionMapping, hasVolumetricFogCapability, mapDisplayToScene, mapDisplayUvToSceneUv, mapSceneToDisplay, mapSceneUvToDisplayUv, orthographic, packDepthOfFieldParams, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveDepthOfFieldParams, resolveIntegratedVolumeConsumer, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, selectCloudLayerFrame, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, validateBarrelDistortionParameters, validateCameraBloom, validateCameraColorGrading, validateCameraExposure, validateCloudLayer, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 } from './chunk-UINHLCZA.mjs';
-import { SpriteAnimation, SpriteInstances, SpriteRegionOverride, TileLayer, Tilemap } from './chunk-ELJFJ2BU.mjs';
-export { getActiveCamera, setActiveCamera } from './chunk-ELJFJ2BU.mjs';
-export { DEFAULT_STANDARD_PROFILE, REFLECTION_PROBE_IBL_STAGES, SCENE_DATA_TEMPORAL_V1_DESCRIPTOR, SCENE_DATA_TEMPORAL_V1_SCHEMA, beginProbeIblUpdate, createIblKernelCache, createProbeIblOutput, createSceneDataCatalog, publishProbeIblOutput, resetIblKernelCaches } from './chunk-OCDLEI6I.mjs';
-export { MaterialAuthoringContractError, MaterialTransmissionContractError, Materials, srgb } from './chunk-BLXGONR2.mjs';
-export { AtmosphereInvalidParameterError, AutoExposureCapabilityUnavailableError, AutoExposureInvalidParameterError, AutoExposureStageFailedError, AutoExposureStaleGenerationError, BarrelDistortionInvalidParameterError, DEFAULT_MOTION_BLUR_PARAMS, DynamicResolutionInvalidParameterError, DynamicResolutionRequiresTaaError, DynamicResolutionTimingUnavailableError, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, FogCardinalityError, GpuDrivenPreparationError, InstanceTransformsError, MotionBlurValidationError, OwnerStageFailedError, RENDER_PHASE_CATALOG, RendererOperationError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, SceneDataUnavailableError, ShadowAtlas, TaaCapsInsufficientError, createAutoExposureError, createAutoExposureInspection, effectiveMotionBlurSampleCount, isMotionBlurIntervalValid, motionBlurExposureScale, motionBlurSampleDelta, motionBlurTemporalDemand, resolveMotionBlurParams, validateMotionBlurParams } from './chunk-WEX45HKH.mjs';
+import { registerRenderSourceSystems, createRenderSourceState, createGlobalTransformChangeQuery, isRenderableMember, renderMaterialContext, publicationDependencies, publicationFrameDependencies, publicationTargetSources, RenderPublicationError, RENDERABLE_SOURCE_COMPONENTS } from './chunk-MZ4C7EHF.mjs';
+export { BARREL_DISTORTION_FEATURE_IDENTITY, BARREL_DISTORTION_POST_PROCESS_ID, BARREL_DISTORTION_WGSL, BARREL_DISTORTION_WGSL_COORDINATE, CLOUD_DENSITY_COMPUTE_WGSL, CLOUD_HISTORY_FULLSCREEN_WGSL, CLOUD_HISTORY_SURFACE_COUNT, CLOUD_LAYER_DENSITY_BINDINGS, CLOUD_LAYER_DENSITY_CACHE, CLOUD_LAYER_DENSITY_OUTPUT, CLOUD_LAYER_DENSITY_PROGRAM, CLOUD_LAYER_FEATURE_IDENTITY, CLOUD_RGBA16FLOAT_BYTES_PER_TEXEL, CLOUD_VIEW_FULLSCREEN_WGSL, CLOUD_VIEW_PARAMS_BYTES, CloudHistoryStore, DEFAULT_REFLECTION_PROBE_LIMITS, DynamicGeometryError, DynamicInputError, LOD_OCCLUSION_INSPECTION_MAX_BYTES, LOD_OCCLUSION_INSPECTION_SCHEMA, ReadonlyDynamicInputPage, ReflectionProbeProjection, RenderPublicationError, RenderPublicationTargetOwner, SSR_FORMAT_PROFILE, SSR_FORMAT_STAGES, acceptCloudLayerGeneration, admitPointsLines, admitReflectionProbe, admitSingleLayerMediumSubmission, admitSsrM0, admitSsrSpatial, advanceProbeFilter, applyCloudSolarTransmittance, boxProjectReflectionDirection, buildCloudDensityCache, buildReflectionProbeTable, cloudCapabilitiesFromRhi, cloudTemporalResetReasons, cloudTemporalSignature, commitProbeFilterStep, compositeCloudRadiance, consumeLodOcclusionInspection, createBarrelDistortionRenderFeature, createCloudHistory, createCloudLayerFeature, createCloudShadowProjection, createDynamicGeometryLifecycle, createProbeFilterState, estimateReflectionProbeBytes, evaluateCloudDensity, inspectCloudLayer, inspectCloudLayerResources, inspectLodOcclusion, inspectPointShadow, inspectReflectionFallback, inspectVolumetricFog, integrateCloudCameraPath, integrateCloudInterior, integrateCloudPath, integrateCloudSolarColumn, intersectCloudLayer, probeFilterIsSteady, projectCloudShadowUv, projectSsrDependencies, projectSsrSpatialInspection, reconstructCloudDensityCache, reflectionProbeTableBytes, renderPublicationTransfers, reprojectCloudHistory, resolveSsrAdmissionGeneration, retainCloudLayerAfterFailure, sampleCloudDensity, sampleCloudShadow, selectReflectionProbe, serializeLodOcclusionInspection, serializeSsrSpatialInspection, snapshotCloudDensityCache, validateReflectionProbeInput, validateScreenSpaceReflection, zeroSsrAdmissionWork } from './chunk-MZ4C7EHF.mjs';
+import { Visibility, extractFrames, internSharedRefFromGuid, resolveMaterialSnapshot, Atmosphere, BarrelDistortion, Camera, CloudLayer, DirectionalLight, DynamicResolution, DepthOfField, Instances, Layer, LightProbe, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, Points, Lines, PostProcessParams, RectAreaLight, SceneInstance, SkyboxBackground, Skylight, SortKey, SpotLight } from './chunk-G6HDNGY7.mjs';
+export { ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_NONE, ANTIALIAS_TAA, Atmosphere, BLOOM_DISABLED, BLOOM_ENABLED, BarrelDistortion, CAMERA_BLOOM_INTENSITY_MAX, CAMERA_BLOOM_INTENSITY_MIN, CAMERA_BLOOM_SCATTER_MAX, CAMERA_BLOOM_SCATTER_MIN, CAMERA_BLOOM_SOFT_KNEE_MAX, CAMERA_BLOOM_SOFT_KNEE_MIN, CAMERA_BLOOM_THRESHOLD_MAX, CAMERA_BLOOM_THRESHOLD_MIN, CAMERA_EXPOSURE_MODE_AUTO, CAMERA_EXPOSURE_MODE_MANUAL, CAMERA_PROJECTION_ORTHOGRAPHIC, CAMERA_PROJECTION_PERSPECTIVE, CAMERA_TEMPERATURE_MAX, CAMERA_TEMPERATURE_MIN, CAMERA_TINT_MAX, CAMERA_TINT_MIN, CLOUD_QUALITY_PROFILES, CUBE_CAMERA_FACE_ORDER, CUBE_CAMERA_UPDATE_CONTINUOUS, CUBE_CAMERA_UPDATE_ONCE, CUBE_CAMERA_UPDATE_ON_DEMAND, Camera, CameraError, CloudLayer, CloudLayerCacheInvalidError, CloudLayerCapabilityMissingError, CloudLayerInvalidParameterError, CloudLayerOwnerConflictError, CloudLayerResourceFailureError, CloudQualityValue, CubeCamera, DEFAULT_CLOUD_LAYER, DEFAULT_DEPTH_OF_FIELD_PARAMS, DEPTH_OF_FIELD_PARAMS_BYTE_SIZE, DepthOfField, DepthOfFieldQualityValue, DepthOfFieldSideValue, DepthOfFieldValidationError, DirectionalLight, DirectionalShadowFilterValue, DynamicResolution, Fog, Instances, Layer, LightProbe, Lines, MAX_VOLUMETRIC_FOG_OWNERS, MeshFilter, MeshRenderer, MotionBlur, PointLight, PointLightShadow, PointShapeValue, Points, PostProcessParams, REFLECTION_PROBE_UPDATE_CONTINUOUS, REFLECTION_PROBE_UPDATE_ONCE, REFLECTION_PROBE_UPDATE_ON_CHANGE, RectAreaLight, ReflectionProbe, SKYBOX_MODE_CUBEMAP, SceneInstance, ScreenSpaceReflection, SkyboxBackground, Skylight, SortKey, SpotLight, SunCardinalityError, TONEMAP_ACES_FILMIC, TONEMAP_AGX, TONEMAP_CINEON, TONEMAP_LINEAR, TONEMAP_NEUTRAL, TONEMAP_NONE, TONEMAP_REINHARD, TONEMAP_REINHARD_EXTENDED, Visibility, VisibilityStateValue, VolumetricFog, VolumetricFogSamplingValue, attachBarrelDistortionCameraFrame, buildCubeCameraFaceViews, cameraExposureFromColumns, cameraProjectionFromF32, cloudLayerSourceKey, cloudQualityFromF32, computeInvRangeSquared, createBarrelDistortionMapping, cubeCameraUpdateIntentFromF32, cubeCameraUpdateIntentToF32, degToCos, depthOfFieldQualityCode, depthOfFieldQualityFromF32, depthOfFieldRequestFailure, depthOfFieldSideCode, depthOfFieldSideFromF32, depthOfFieldTapCount, directionalShadowQualityFromF32, extractCloudLayer, extractVolumetricFog, freezeBarrelDistortionMapping, hasVolumetricFogCapability, mapDisplayToScene, mapDisplayUvToSceneUv, mapSceneToDisplay, mapSceneUvToDisplayUv, orthographic, packDepthOfFieldParams, perspective, pointShapeFromU32, projectMeshMaterialBindingObservation, reflectionProbeUpdateIntentFromF32, reflectionProbeUpdateIntentToF32, resolveDepthOfFieldParams, resolveIntegratedVolumeConsumer, resolveSelectedVolumetricLight, resolveVisibility, resolveVolumetricFogLightPair, selectCloudLayerFrame, signedDepthOfFieldCoC, summarizeMeshMaterialBindings, validateBarrelDistortionParameters, validateCameraBloom, validateCameraColorGrading, validateCameraExposure, validateCloudLayer, validateDepthOfFieldFrameParams, validateDepthOfFieldParams, validateDirection, validateDirectionalLightData, validateDynamicResolutionCamera, validateDynamicResolutionParameters, validateLightProbeData, validatePointLightData, validatePointLightShadowData, validateRectAreaLightData, validateSpotLightData, validateVolumetricFog, visibilityStateFromU32 } from './chunk-G6HDNGY7.mjs';
+import { SpriteAnimation, SpriteInstances, SpriteRegionOverride, TileLayer, Tilemap } from './chunk-X2KA6WHM.mjs';
+export { getActiveCamera, setActiveCamera } from './chunk-X2KA6WHM.mjs';
+export { DEFAULT_STANDARD_PROFILE, REFLECTION_PROBE_IBL_STAGES, SCENE_DATA_TEMPORAL_V1_DESCRIPTOR, SCENE_DATA_TEMPORAL_V1_SCHEMA, beginProbeIblUpdate, createIblKernelCache, createProbeIblOutput, createSceneDataCatalog, publishProbeIblOutput, resetIblKernelCaches } from './chunk-SGPUJW3F.mjs';
+import { getTransparentSortConfig } from './chunk-XSFB7XXQ.mjs';
+export { MaterialAuthoringContractError, MaterialTransmissionContractError, Materials, srgb } from './chunk-XSFB7XXQ.mjs';
+import { renderTargetMaterialSourceIdentity } from './chunk-MXTWKZO4.mjs';
+export { AtmosphereInvalidParameterError, AutoExposureCapabilityUnavailableError, AutoExposureInvalidParameterError, AutoExposureStageFailedError, AutoExposureStaleGenerationError, BarrelDistortionInvalidParameterError, DEFAULT_MOTION_BLUR_PARAMS, DynamicResolutionInvalidParameterError, DynamicResolutionRequiresTaaError, DynamicResolutionTimingUnavailableError, EnvironmentGenerationFailedError, EnvironmentSourceConflictError, FogCardinalityError, GpuDrivenPreparationError, InstanceTransformsError, MotionBlurValidationError, OwnerStageFailedError, RENDER_PHASE_CATALOG, RendererOperationError, SHADOW_ATLAS_DEFAULT_FACE_SIZE, SHADOW_ATLAS_DEFAULT_LAYERS, SceneDataUnavailableError, ShadowAtlas, TaaCapsInsufficientError, createAutoExposureError, createAutoExposureInspection, effectiveMotionBlurSampleCount, isMotionBlurIntervalValid, motionBlurExposureScale, motionBlurSampleDelta, motionBlurTemporalDemand, resolveMotionBlurParams, validateMotionBlurParams } from './chunk-MXTWKZO4.mjs';
 import { validateCookedMaterialRecord } from '@forgeax/engine-pack';
 import { ok, err, MATERIAL_TEXTURE_SLOTS } from '@forgeax/engine-types';
+import { RuntimeMaterialValue, RuntimeMeshVertices, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import { Time } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { ChildOf, Children, GlobalTransform } from '@forgeax/engine-scene';
+import { VIDEO_SOURCE_PROVIDER_KEY, videoSourceExtent } from '@forgeax/engine-graphics-extras';
 
 function invalid(guid, expected, reason) {
   return err({
@@ -245,6 +253,519 @@ function renderComponentsPlugin() {
     }
   };
 }
+function publicationVideoFrames(world, consumers) {
+  if (consumers.size === 0 || !world.hasResource(VIDEO_SOURCE_PROVIDER_KEY)) return [];
+  const provider = world.getResource(VIDEO_SOURCE_PROVIDER_KEY);
+  const frames = [];
+  try {
+    for (const [entity, clips] of consumers)
+      for (const clip of clips) {
+        const source = provider.getSource(
+          entity,
+          clip
+        );
+        if (source === void 0 || videoSourceExtent(source) === void 0) continue;
+        frames.push({ entity, clip, frame: new VideoFrame(source) });
+      }
+    return frames;
+  } catch (cause) {
+    for (const row of frames) row.frame.close();
+    throw cause;
+  }
+}
+
+// src/publication/publisher.ts
+function createRenderPublisher(world, assets, identity, capabilities, features = [], targetOwner) {
+  const pendingMeshContent = /* @__PURE__ */ new Set();
+  const releaseTransforms = registerRenderSourceSystems(world, assets, {
+    updateMesh: (handle) => pendingMeshContent.add(handle)
+  });
+  const source = createRenderSourceState(world);
+  const transforms = createGlobalTransformChangeQuery(world);
+  const caches = /* @__PURE__ */ new WeakMap();
+  const members = /* @__PURE__ */ new Set();
+  const publishedPrograms = /* @__PURE__ */ new Set();
+  const dependencies = /* @__PURE__ */ new Map();
+  const consumers = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  let videoConsumers = /* @__PURE__ */ new Map();
+  let pendingFeatures = [];
+  let pendingFeatureOwners = [];
+  const acknowledgedFeatures = /* @__PURE__ */ new Set();
+  const jointsByEntity = /* @__PURE__ */ new Map();
+  const skinConsumers = /* @__PURE__ */ new Map();
+  let frameDependencies = /* @__PURE__ */ new Set();
+  let catalogEpoch = -1, revision = 0, disposed = false, active = false;
+  let lastScannedRows = 0, inFlight = false, allocations = 0;
+  let storage = [new ArrayBuffer(0), new ArrayBuffer(0), new ArrayBuffer(0), new ArrayBuffer(0)];
+  const buffer = (index, bytes) => {
+    let value = storage[index];
+    if (value.byteLength < bytes) {
+      let capacity = Math.max(16, value.byteLength);
+      while (capacity < bytes) capacity *= 2;
+      value = new ArrayBuffer(capacity);
+      storage[index] = value;
+      allocations++;
+    }
+    return value;
+  };
+  const fail = (reason, subject) => err(new RenderPublicationError({ reason, subject }));
+  return {
+    identity,
+    inspect: () => ({
+      revision,
+      members: members.size,
+      assetCount: consumers.size,
+      scannedRows: lastScannedRows,
+      inFlight,
+      allocations
+    }),
+    prepare(sampleTimeSeconds, temporalReset = false) {
+      if (disposed) return fail("disposed", "publisher");
+      if (active || inFlight) return fail("in-flight", "publication storage has not been returned");
+      const baseline = revision === 0;
+      const featureSources = [...features];
+      const batch = source.projection.read();
+      lastScannedRows = batch.scannedRows;
+      const changed = new Set(pending), removed = /* @__PURE__ */ new Set();
+      const invalidated = new Set(pendingMeshContent);
+      const runtimeChanged = batch.membershipChanged || batch.changedComponents.includes(RuntimeMaterialValue) || batch.changedComponents.includes(RuntimeMeshVertices);
+      for (const index of batch.indices) {
+        const previous = source.entities.get(index), current = source.projection.entity(index);
+        if (previous !== void 0 && members.has(previous) && (current !== previous || !isRenderableMember(world, previous)))
+          removed.add(previous);
+        if (runtimeChanged) {
+          for (const handle of source.contentHandles.get(index) ?? [])
+            invalidated.add(handle);
+          if (current !== void 0) {
+            if (world.hasComponent(current, RuntimeMaterialValue))
+              invalidated.add(world.get(current, RuntimeMaterialValue).unwrap().asset);
+            if (world.hasComponent(current, RuntimeMeshVertices))
+              invalidated.add(world.get(current, RuntimeMeshVertices).unwrap().asset);
+          }
+        }
+        if (previous !== void 0)
+          for (const consumer of skinConsumers.get(previous) ?? []) changed.add(consumer);
+        if (current === void 0) continue;
+        if (isRenderableMember(world, current) && (baseline || !members.has(current) || RENDERABLE_SOURCE_COMPONENTS.some(
+          (component) => source.projection.changed(current, component)
+        )))
+          changed.add(current);
+        if (batch.membershipChanged || source.projection.changed(current, ChildOf) || source.projection.changed(current, Visibility)) {
+          const queue = [current], visited = /* @__PURE__ */ new Set();
+          while (queue.length) {
+            const entity = queue.pop();
+            if (visited.has(entity)) continue;
+            visited.add(entity);
+            if (isRenderableMember(world, entity)) changed.add(entity);
+            if (world.hasComponent(entity, Children))
+              queue.push(
+                ...Array.from(
+                  world.get(entity, Children).unwrap().entities,
+                  (child) => child
+                )
+              );
+          }
+        }
+      }
+      if (baseline || catalogEpoch !== assets.catalogEpoch) {
+        for (const entity of members) changed.add(entity);
+        for (const entity of source.entities.values())
+          if (isRenderableMember(world, entity)) changed.add(entity);
+      }
+      for (const handle of invalidated)
+        for (const entity of consumers.get(handle) ?? []) changed.add(entity);
+      const matrixRows = /* @__PURE__ */ new Map();
+      for (const span of transforms.spans().unwrap()) {
+        const values = span.get(GlobalTransform).world;
+        for (let row = 0; row < span.entities.length; row++) {
+          const entity = span.entities[row];
+          for (const consumer of skinConsumers.get(entity) ?? []) changed.add(consumer);
+          if (members.has(entity) && !removed.has(entity)) {
+            matrixRows.set(entity, values.subarray(row * 16, row * 16 + 16));
+            pending.add(entity);
+          }
+        }
+      }
+      for (const entity of changed) pending.add(entity);
+      let videoFrames = [];
+      try {
+        const frame = extractFrames(
+          [world],
+          { cameraOwner: 0, resourceOwner: 0 },
+          assets,
+          void 0,
+          caches,
+          {
+            ...capabilities === void 0 ? {} : renderMaterialContext(capabilities),
+            cull: "none",
+            retainHidden: true,
+            renderables: changed.size ? { kind: "partial", entitiesByWorld: [changed] } : "none"
+          }
+        );
+        const templates = [], templateIds = /* @__PURE__ */ new Map();
+        const upserts = [];
+        const programs = /* @__PURE__ */ new Map();
+        const nextDependencies = /* @__PURE__ */ new Map();
+        const assetRows = /* @__PURE__ */ new Map();
+        const byRenderable = /* @__PURE__ */ new Map();
+        for (const { entityIndex: _entity, renderableIndex, ...dispatch } of frame.dispatch) {
+          const rows = byRenderable.get(renderableIndex) ?? [];
+          rows.push(dispatch);
+          byRenderable.set(renderableIndex, rows);
+        }
+        const publishPrograms = (materials) => {
+          for (const material of materials) {
+            const keys = /* @__PURE__ */ new Set([
+              ...Object.values(material.materialProgramKeys ?? {}),
+              ...Object.values(material.materialSceneIndexProgramKeys ?? {}).map(
+                (program) => program.specializationKey
+              ),
+              ...material.materialShaderId === void 0 || material.materialShaderId.startsWith("forgeax::") ? [] : [material.materialShaderId]
+            ]);
+            for (const key of keys) {
+              if (publishedPrograms.has(key) || programs.has(key)) continue;
+              const shader = assets.shaderRegistry.findMaterialArtifact(key);
+              if (!shader.ok) throw shader.error;
+              const artifact = assets.getMaterialArtifact(key);
+              programs.set(key, {
+                key,
+                shader: {
+                  source: shader.value.source,
+                  paramSchema: shader.value.paramSchema,
+                  ...shader.value.receipt === void 0 ? {} : { receipt: shader.value.receipt }
+                },
+                ...artifact === void 0 ? {} : { artifact }
+              });
+            }
+          }
+        };
+        for (let i = 0; i < frame.renderables.length; i++) {
+          const row = frame.renderables[i];
+          if (row.skin) return fail("unsupported", "source GPU skin receipt");
+          const { worldId: _world, entityKey, transform, ...snapshot } = row;
+          const template = { snapshot, dispatch: byRenderable.get(i) ?? [] };
+          const key = JSON.stringify(
+            template,
+            (_key, value) => value instanceof Map ? _key === "textureSources" ? [...value].map(([name, source2]) => [
+              name,
+              renderTargetMaterialSourceIdentity(source2)
+            ]) : [...value] : ArrayBuffer.isView(value) ? Array.from(value) : value
+          );
+          let templateId = templateIds.get(key);
+          if (templateId === void 0) {
+            templateId = templates.length;
+            templateIds.set(key, templateId);
+            templates.push(template);
+          }
+          upserts.push(entityKey, templateId);
+          matrixRows.set(entityKey, transform.world);
+          publishPrograms(row.materials);
+          const handles = publicationDependencies(row);
+          for (const lod of row.lods ?? []) {
+            const handle = internSharedRefFromGuid(
+              world,
+              assets,
+              AssetGuid.format(lod.mesh),
+              "MeshAsset"
+            );
+            if (handle !== void 0) handles.push(handle);
+          }
+          nextDependencies.set(entityKey, handles);
+          for (const handle of handles) {
+            if (!baseline && (consumers.has(handle) || frameDependencies.has(handle)) && !invalidated.has(handle) && catalogEpoch === assets.catalogEpoch)
+              continue;
+            const value = resolveAssetHandle(world, handle);
+            if (!value.ok) throw value.error;
+            assetRows.set(handle, value.value);
+          }
+        }
+        const featureRows = featureSources.map((feature) => {
+          const data = feature.extract({
+            worlds: [world],
+            owner: 0,
+            frameNumber: revision + 1,
+            ...capabilities === void 0 ? {} : { caps: capabilities },
+            ...frame.cameras[0] === void 0 ? {} : { selectedCamera: frame.cameras[0] },
+            visibilitySnapshots: frame.featureVisibilitySnapshots,
+            ...frame.cloudLayer === void 0 ? {} : { frame: { cloudLayer: frame.cloudLayer } }
+          }).unwrap();
+          return { identity: feature.identity, data };
+        });
+        const nextFrameDependencies = new Set(publicationFrameDependencies(frame));
+        const pendingGuids = featureSources.flatMap((feature) => {
+          const row = featureRows.find((row2) => row2.identity === feature.identity);
+          return row === void 0 ? [] : [...feature.assetDependencies?.(row.data) ?? []];
+        });
+        const seenGuids = /* @__PURE__ */ new Set();
+        for (const guid of pendingGuids) {
+          const key = guid.toLowerCase();
+          if (seenGuids.has(key)) continue;
+          seenGuids.add(key);
+          const asset = assets.lookup(key);
+          const handle = internSharedRefFromGuid(world, assets, key, "RenderFeatureAsset");
+          if (asset === void 0 || handle === void 0)
+            throw new Error(`Missing feature asset ${guid}`);
+          nextFrameDependencies.add(handle);
+          for (const ref of assets.assetCatalog.get(key)?.refs ?? []) pendingGuids.push(ref.guid);
+          if (asset.kind === "material") {
+            const material = resolveMaterialSnapshot(
+              handle,
+              world,
+              assets,
+              void 0,
+              void 0,
+              capabilities === void 0 ? void 0 : renderMaterialContext(capabilities).materialContext
+            );
+            publishPrograms([material]);
+            for (const dependency of publicationDependencies({
+              assetHandle: handle,
+              materials: [material]
+            }))
+              nextFrameDependencies.add(dependency);
+          }
+        }
+        for (const handle of nextFrameDependencies) {
+          if (!baseline && (consumers.has(handle) || frameDependencies.has(handle)) && !invalidated.has(handle) && catalogEpoch === assets.catalogEpoch)
+            continue;
+          const value = resolveAssetHandle(world, handle);
+          if (!value.ok) throw value.error;
+          assetRows.set(handle, value.value);
+        }
+        const emitted = new Set(frame.renderables.map((row) => row.entityKey));
+        for (const entity of changed)
+          if (members.has(entity) && !emitted.has(entity)) removed.add(entity);
+        for (const entity of removed) matrixRows.delete(entity);
+        const nextVideoConsumers = new Map(videoConsumers);
+        for (const entity of removed) nextVideoConsumers.delete(entity);
+        for (const row of frame.renderables) {
+          const clips = [
+            ...new Set(
+              row.materials.flatMap((material) => [
+                ...material.videoTextureFields?.values() ?? []
+              ])
+            )
+          ];
+          if (clips.length > 0) nextVideoConsumers.set(row.entityKey, clips);
+          else nextVideoConsumers.delete(row.entityKey);
+        }
+        videoFrames = publicationVideoFrames(world, nextVideoConsumers);
+        const transformEntities = new Uint32Array(
+          buffer(2, matrixRows.size * 4),
+          0,
+          matrixRows.size
+        ), matrices = new Float32Array(buffer(3, matrixRows.size * 64), 0, matrixRows.size * 16);
+        let index = 0;
+        for (const [entity, matrix] of matrixRows) {
+          transformEntities[index] = entity;
+          matrices.set(matrix, index * 16);
+          index++;
+        }
+        const {
+          renderables: _rows,
+          dispatch: _dispatch,
+          visibilitySnapshots: _visibility,
+          featureVisibilitySnapshots: _features,
+          hiddenEntityReports: _hidden,
+          shadowCasterEntityKeys: _casters,
+          shadowCasterDrawKeys: _draws,
+          shadowCasterMembership: _membership,
+          ...metadata
+        } = frame;
+        const retired = /* @__PURE__ */ new Set();
+        const removedConsumers = /* @__PURE__ */ new Set([...removed, ...nextDependencies.keys()]);
+        const nextHandles = new Set([...nextDependencies.values()].flat());
+        const removedCounts = /* @__PURE__ */ new Map();
+        for (const entity of removedConsumers)
+          for (const handle of dependencies.get(entity) ?? [])
+            removedCounts.set(handle, (removedCounts.get(handle) ?? 0) + 1);
+        for (const [handle, count] of removedCounts)
+          if (count === consumers.get(handle)?.size && !nextHandles.has(handle) && !nextFrameDependencies.has(handle))
+            retired.add(handle);
+        for (const handle of frameDependencies) {
+          if (!nextFrameDependencies.has(handle) && !nextHandles.has(handle) && (consumers.get(handle)?.size ?? 0) === (removedCounts.get(handle) ?? 0))
+            retired.add(handle);
+        }
+        const upsertColumn = new Uint32Array(buffer(0, upserts.length * 4), 0, upserts.length);
+        upsertColumn.set(upserts);
+        const removedColumn = new Uint32Array(buffer(1, removed.size * 4), 0, removed.size);
+        removedColumn.set([...removed]);
+        const packet = {
+          ...identity,
+          revision: revision + 1,
+          base: revision,
+          baseline,
+          time: { ...world.getResource(Time) },
+          sampleTimeSeconds,
+          temporalReset,
+          transparentSort: getTransparentSortConfig(world),
+          metadata,
+          templates,
+          videoFrames,
+          targets: targetOwner?.snapshot() ?? [],
+          targetSources: publicationTargetSources(templates),
+          features: featureRows,
+          programs: [...programs.values()],
+          upserts: upsertColumn,
+          removed: removedColumn,
+          transformEntities,
+          transforms: matrices,
+          assets: [...assetRows].map(([handle, value]) => {
+            const guid = assets.guidOf(value);
+            return { handle, value, ...guid === void 0 ? {} : { guid } };
+          }),
+          retiredAssets: [...retired],
+          invalidatedAssets: [...invalidated]
+        };
+        batch.validate();
+        active = true;
+        let closed = false;
+        return ok({
+          packet,
+          accept: () => {
+            if (closed)
+              throw new RenderPublicationError({ reason: "revision", subject: "closed candidate" });
+            batch.accept();
+            for (const handle of invalidated) pendingMeshContent.delete(handle);
+            for (const key of programs.keys()) publishedPrograms.add(key);
+            closed = true;
+            active = false;
+            inFlight = true;
+            revision++;
+            for (const row of videoFrames) row.frame.close();
+            videoConsumers = nextVideoConsumers;
+            pendingFeatures = featureRows;
+            pendingFeatureOwners = featureSources;
+            acknowledgedFeatures.clear();
+            frameDependencies = nextFrameDependencies;
+            catalogEpoch = assets.catalogEpoch;
+            for (const entity of removedConsumers) {
+              for (const handle of dependencies.get(entity) ?? []) {
+                consumers.get(handle)?.delete(entity);
+                if (consumers.get(handle)?.size === 0) consumers.delete(handle);
+              }
+              dependencies.delete(entity);
+            }
+            for (const entity of removedConsumers) {
+              for (const joint of jointsByEntity.get(entity) ?? []) {
+                const users = skinConsumers.get(joint);
+                users?.delete(entity);
+                if (users?.size === 0) skinConsumers.delete(joint);
+              }
+              jointsByEntity.delete(entity);
+            }
+            for (const row of frame.renderables) {
+              if (row.skinJointEntities === void 0) continue;
+              jointsByEntity.set(row.entityKey, row.skinJointEntities);
+              for (const joint of row.skinJointEntities) {
+                let users = skinConsumers.get(joint);
+                if (users === void 0) {
+                  users = /* @__PURE__ */ new Set();
+                  skinConsumers.set(joint, users);
+                }
+                users.add(row.entityKey);
+              }
+            }
+            for (const entity of removed) members.delete(entity);
+            for (const [entity, handles] of nextDependencies) {
+              members.add(entity);
+              dependencies.set(entity, handles);
+              for (const handle of handles) {
+                let users = consumers.get(handle);
+                if (!users) {
+                  users = /* @__PURE__ */ new Set();
+                  consumers.set(handle, users);
+                }
+                users.add(entity);
+              }
+            }
+            for (const entity of matrixRows.keys()) pending.delete(entity);
+            for (const entity of removed) pending.delete(entity);
+            for (const sourceIndex of batch.indices) {
+              const entity = source.projection.entity(sourceIndex);
+              if (entity === void 0) {
+                source.entities.delete(sourceIndex);
+                source.contentHandles.delete(sourceIndex);
+              } else {
+                source.entities.set(sourceIndex, entity);
+                const handles = [];
+                if (world.hasComponent(entity, RuntimeMaterialValue))
+                  handles.push(world.get(entity, RuntimeMaterialValue).unwrap().asset);
+                if (world.hasComponent(entity, RuntimeMeshVertices))
+                  handles.push(world.get(entity, RuntimeMeshVertices).unwrap().asset);
+                if (handles.length) source.contentHandles.set(sourceIndex, handles);
+                else source.contentHandles.delete(sourceIndex);
+              }
+            }
+          },
+          discard: () => {
+            if (!closed) {
+              closed = true;
+              active = false;
+              for (const row of videoFrames) row.frame.close();
+            }
+          }
+        });
+      } catch (cause) {
+        for (const row of videoFrames) row.frame.close();
+        return fail("unsupported", cause instanceof Error ? cause.message : String(cause));
+      }
+    },
+    acknowledgeFeatures(acceptedRevision, receipts) {
+      if (disposed) return fail("disposed", "publisher");
+      if (!inFlight || revision !== acceptedRevision)
+        return fail("revision", "feature acknowledgment");
+      const identities = /* @__PURE__ */ new Set();
+      for (const receipt of receipts) {
+        if (identities.has(receipt.identity) || acknowledgedFeatures.has(receipt.identity))
+          return fail("revision", "duplicate feature acknowledgment");
+        const row = pendingFeatures.find((row2) => row2.identity === receipt.identity);
+        const feature = pendingFeatureOwners.find(
+          (feature2) => feature2.identity === receipt.identity
+        );
+        if (row === void 0 || feature === void 0)
+          return fail("shape", "unknown feature acknowledgment");
+        identities.add(receipt.identity);
+      }
+      for (const receipt of receipts) {
+        acknowledgedFeatures.add(receipt.identity);
+        const row = pendingFeatures.find((row2) => row2.identity === receipt.identity);
+        const feature = pendingFeatureOwners.find(
+          (feature2) => feature2.identity === receipt.identity
+        );
+        feature?.onSourceFrameSubmitted?.(row?.data, receipt.feedback);
+      }
+      return ok(void 0);
+    },
+    recycle(acceptedRevision, buffers) {
+      if (disposed) return fail("disposed", "publisher");
+      if (!inFlight || acceptedRevision !== revision)
+        return fail("revision", "returned storage revision");
+      if (buffers.length !== 4 || buffers.some((value) => !(value instanceof ArrayBuffer)))
+        return fail("shape", "returned storage");
+      storage = [...buffers];
+      inFlight = false;
+      return ok(void 0);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      releaseTransforms();
+      members.clear();
+      dependencies.clear();
+      consumers.clear();
+      pending.clear();
+      pendingMeshContent.clear();
+      videoConsumers.clear();
+      pendingFeatures = [];
+      pendingFeatureOwners = [];
+      acknowledgedFeatures.clear();
+      frameDependencies.clear();
+      jointsByEntity.clear();
+      skinConsumers.clear();
+    }
+  };
+}
 
 // src/scene/visibility/gpu-frame-timing.ts
 var PROTOCOL = Object.freeze({
@@ -523,6 +1044,6 @@ function estimateSingleLayerPathLength(input) {
   };
 }
 
-export { SINGLE_LAYER_MEDIUM_SURFACE_EXAMPLE, SINGLE_LAYER_MEDIUM_SURFACE_EXAMPLES, composeSingleLayerMediumColor, composeSsrReflection, createGpuFrameTiming, estimateSingleLayerPathLength, integrateSingleLayerMedium, materialContribution, recordGpuFrameTiming, renderComponentsPlugin, renderPipelineContribution, resolveSingleLayerMediumBackground, samplerContribution, summarizeGpuFrameTiming };
+export { SINGLE_LAYER_MEDIUM_SURFACE_EXAMPLE, SINGLE_LAYER_MEDIUM_SURFACE_EXAMPLES, composeSingleLayerMediumColor, composeSsrReflection, createGpuFrameTiming, createRenderPublisher, estimateSingleLayerPathLength, integrateSingleLayerMedium, materialContribution, recordGpuFrameTiming, renderComponentsPlugin, renderPipelineContribution, resolveSingleLayerMediumBackground, samplerContribution, summarizeGpuFrameTiming };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map