@forgeax/engine-render 0.1.20 → 0.1.21

package/src/record/frame.ts

@@ -21,8 +21,14 @@ import {
 } from '@forgeax/engine-rhi';
 import type { MaterialRenderState, MeshAsset } from '@forgeax/engine-types';
 import { handleSlot, toShared } from '@forgeax/engine-types';
+import { CUBE_CAMERA_FACE_ORDER } from '../components/cube-camera';
+import type { DirectionalShadowQuality } from '../components/directional-shadow-filter';
 import type { MeshGpuHandles } from '../device/gpu-residency';
-import { ObservationUnavailableError, type ObservationUnavailableReason } from '../errors/render';
+import {
+  ObservationUnavailableError,
+  type ObservationUnavailableReason,
+  RendererOperationError,
+} from '../errors/render';
 import type { FogFrame } from '../extract/environment';
 import type { GpuDrivenProduction, PreparedGpuDrivenFrame } from '../gpu-driven/production-raster';
 import { GpuBuffer } from '../gpu-resource';
@@ -32,8 +38,12 @@ import {
   GPU_BUFFER_USAGE_VERTEX,
 } from '../gpu-usage';
 import { disposeTransientInstanceBuffers } from '../instance-buffer-cache';
+import { inspectStandardLighting } from '../pipeline/standard-lighting/inspection';
+import { standardLightingTopologySignature } from '../pipeline/standard-lighting/topology';
+import { inspectPointShadow } from '../point-shadow-inspection';
 import type {
   CameraSnapshot,
+  CubeCameraSnapshot,
   RenderRecordPhase,
   SpotLightProjectorFrameContext,
   VolumetricFogFrameContext,
@@ -48,6 +58,7 @@ import type {
   SkylightSnapshot,
 } from '../render-system-extract';
 import type { PersistentGpuDrivenState } from '../scene/render-scene';
+import { SHADOW_ATLAS_DEFAULT_LAYERS } from '../shadow-atlas';
 import {
   getTransparentSortConfig,
   TRANSPARENT_SORT_MODE_LAYER_Y,
@@ -63,7 +74,6 @@ import {
   resolveSkyboxActive,
   warnZeroLightStandard,
   writeHdrpClusterAndSsaoBuffers,
-  writePointSpotLightBuffers,
   writeShadowParamsBuffer,
 } from './frame-lighting';
 import {
@@ -223,12 +233,18 @@ import { computeSplitLdrSprite } from './main-pass-sprite-draws';
 import { cleanPerEntityCache, ensureMeshSsboCapacity, uploadMeshSsboBatch } from './mesh-ssbo';
 import { writeShadowCasterUniforms } from './shadow-pass';
 import {
+  type CubeCaptureGraphState,
   ensureCompiledFrameGraph,
   executeCompiledFrameGraph,
   type RenderFeatureGraphCandidate,
   settleVolumetricFogGraphCandidate,
 } from './typed-frame-graph';
-import { writePointsLinesViewUbo, writeViewUbo } from './view-ubo';
+import {
+  CUBE_CAPTURE_VIEW_SLOT_BASE,
+  VIEW_UNIFORM_SLOT_STRIDE,
+  writePointsLinesViewUbo,
+  writeViewUbo,
+} from './view-ubo';
 
 /**
  * A frame-local material table. Repeated snapshot objects share one UBO slot;
@@ -301,6 +317,67 @@ export function materialSlotCountForPrefix(
 
 export type RecordProfileRunner = <T>(phase: RenderRecordPhase, action: () => T) => T;
 
+export interface CubeCaptureFrameInput {
+  readonly snapshots: readonly CubeCameraSnapshot[];
+  readonly scheduler: import('../capture/scheduler').CubeCaptureScheduler;
+  readonly state: CubeCaptureGraphState;
+  readonly reflectionProbes?: import('./render-context').ReflectionProbeRecordState;
+}
+
+function prepareCubeCapture(
+  internals: RenderSystemInternals,
+  input: CubeCaptureFrameInput | undefined,
+  displayCamera: CameraSnapshot,
+): readonly import('./typed-frame-graph').CubeCaptureGraphWork[] {
+  if (input === undefined) return [];
+  if (input.reflectionProbes === undefined) delete input.state.reflectionProbes;
+  else input.state.reflectionProbes = input.reflectionProbes.graph;
+  input.scheduler.beginFrame();
+  for (const snapshot of input.snapshots) {
+    const inspection = input.scheduler.inspect(snapshot.target);
+    if (inspection.candidateGeneration !== undefined) continue;
+    const requested = input.scheduler.request({
+      target: snapshot.target,
+      position: snapshot.position,
+      near: snapshot.near,
+      far: snapshot.far,
+      updateIntent: snapshot.updateIntent,
+      requestVersion: snapshot.requestVersion,
+      faceBudget: snapshot.faceBudget,
+    });
+    if (!requested.ok) internals.errorRegistry.fire(requested.error);
+  }
+  const work = input.scheduler.nextWork();
+  const physicalWork: import('./typed-frame-graph').CubeCaptureGraphWork[] = [];
+  for (const item of work) {
+    const physical = internals.getRenderTargetPhysical?.(item.target);
+    if (physical === undefined) continue;
+    const faceIndex = CUBE_CAMERA_FACE_ORDER.indexOf(item.face);
+    if (faceIndex < 0) continue;
+    const faceWorld = mat4.create();
+    mat4.invert(faceWorld, item.view);
+    physicalWork.push({
+      target: item.target,
+      faceIndex,
+      physical,
+      faceCamera: {
+        ...displayCamera,
+        position: vec3.create(item.position[0] ?? 0, item.position[1] ?? 0, item.position[2] ?? 0),
+        world: faceWorld,
+        fov: Math.PI / 2,
+        aspect: 1,
+        near: item.near,
+        far: item.far,
+        projection: 'perspective',
+      },
+      viewBindGroupDynamicOffset:
+        (CUBE_CAPTURE_VIEW_SLOT_BASE + physicalWork.length) * VIEW_UNIFORM_SLOT_STRIDE,
+    });
+  }
+  input.state.work = physicalWork;
+  return physicalWork;
+}
+
 const EMPTY_ENTITY_KEYS: ReadonlySet<number> = new Set<number>();
 
 function runRecordProfilePhase<T>(
@@ -739,6 +816,8 @@ function prepareSpotLightProjectorFrame(
     texture: resident.value.texture.handle,
     view: resident.value.view,
     sampler: sampler.value,
+    spotIndex: lights.spot.indexOf(source),
+    lightSlotIndex: lights.point.length + lights.spot.indexOf(source),
   };
 }
 
@@ -1036,11 +1115,12 @@ export function recordFrame(
   gpuDriven?: {
     readonly owner: GpuDrivenProduction;
     readonly scene: PersistentGpuDrivenState | undefined;
-    readonly onCoverage: (ownsAll: boolean) => void;
+    readonly onCoverage: (ownsAll: boolean, clusteredLighting: boolean) => void;
   },
   renderReadLeases?: readonly RenderReadLease[],
   featureGraphCandidate?: RenderFeatureGraphCandidate,
   pointsLinesOwner?: import('./render-context').PointsLinesRecordOwner,
+  cubeCapture?: CubeCaptureFrameInput,
   environmentSignature = '',
   fogSignature = '',
   environmentReady = true,
@@ -1097,6 +1177,23 @@ export function recordFrame(
     if (!camera) return false;
     const pipelineState = internals.getPipelineState();
     if (pipelineState === null) return false;
+    if (pipelineState.device !== internals.device) {
+      internals.errorRegistry.fire(
+        new RendererOperationError('device-operation-failed', {
+          operation: 'draw',
+          cause: {
+            code: 'pipeline-device-mismatch',
+            expected: 'pipelineState.device === runtime.device',
+            hint: 'discard stale pipeline state before recording the next frame',
+            detail: {
+              expected: 'pipelineState.device === runtime.device',
+              hint: 'discard stale pipeline state before recording the next frame',
+            },
+          },
+        }),
+      );
+      return false;
+    }
     frameState.currentFrameObservationSource = undefined;
     frameState.currentDirectionalShadowView = null;
     frameState.currentSpotShadowView = null;
@@ -1104,7 +1201,7 @@ export function recordFrame(
     // Record-stage fold operator linear scan (groups transparent-sort entries
     // into fold buckets + records the fold-eligible count metric). Extracted to
     // computeFoldBuckets (M3/w18).
-    const { foldBuckets, light } = runRecordProfilePhase(profilePhase, 'record/scene-state', () => {
+    const lightingPreparation = runRecordProfilePhase(profilePhase, 'record/scene-state', () => {
       const foldBuckets = runRecordProfilePhase(
         profilePhase,
         'record/scene-state/fold-buckets',
@@ -1115,11 +1212,11 @@ export function recordFrame(
       // ensure + ExtractedLights three-arm destructure (directional fallback,
       // point/spot arrays, totalLightCount). Extracted to prepareFrameLighting
       // (M3/w18) so recordFrame stays a skeleton.
-      const { light, pointLights, spotLights, totalLightCount } = runRecordProfilePhase(
-        profilePhase,
-        'record/scene-state/lighting-prep',
-        () => prepareFrameLighting(internals, frameState, lights),
+      const lighting = runRecordProfilePhase(profilePhase, 'record/scene-state/lighting-prep', () =>
+        prepareFrameLighting(internals, frameState, lights, camera, pipelineState),
       );
+      if (!lighting.ok) return lighting;
+      const { light, totalLightCount, standard } = lighting.value;
 
       runRecordProfilePhase(profilePhase, 'record/scene-state/ambient-resolution', () => {
         // feat-20260520-skylight-ibl-cubemap M4 / t27 (AC-10 + F-4 nit):
@@ -1166,31 +1263,17 @@ export function recordFrame(
         }
       });
 
-      // feat-20260608-cluster-lighting M5 / w21 + M6 / w23: HDRP per-frame CPU
-      // cluster binning + light-data / cluster-grid / SSAO buffer uploads. Runs
-      // only when the HDRP pipeline is active and there is at least one punctual
-      // light. Extracted to a sub-function (M3/w18) so recordFrame stays a
-      // skeleton; fail-soft error semantics are preserved verbatim.
-      runRecordProfilePhase(profilePhase, 'record/scene-state/hdrp-cluster', () => {
-        writeHdrpClusterAndSsaoBuffers(
-          internals,
-          frameState,
-          camera,
-          pointLights,
-          spotLights,
-          profilePhase,
-          pipelineState.hdrpClusterMembershipPipeline !== null &&
-            internals.device.caps?.compute === true,
-          pipelineState.hdrpClusterMembershipBindGroupLayout,
-        );
-      });
-
       // Zero-light standard-material once-warn (no Skylight + 0 direct light +
       // >=1 lit material -> black). Extracted to warnZeroLightStandard (M3/w18).
       warnZeroLightStandard(frameState, renderables, skylight, totalLightCount);
 
-      return { foldBuckets, light };
+      return { ok: true as const, value: { foldBuckets, light, standard } };
     });
+    if (!lightingPreparation.ok) {
+      internals.errorRegistry.fire(lightingPreparation.error);
+      return false;
+    }
+    const { foldBuckets, light, standard } = lightingPreparation.value;
 
     // Case E (this commit): 0 renderables = legitimate scene (LO §1.1
     // hello-window minimum semantic). Mirrors the Case C softening for
@@ -1282,7 +1365,6 @@ export function recordFrame(
         meshes: pipelineState.meshes,
         viewBindGroupLayout: pipelineState.viewBindGroupLayout,
         meshResidencyEpoch: internals.gpuStore.meshResidencyEpoch,
-        hdrp: frameState.isHdrpActive,
       });
       if (prepared.ok) preparedGpuDriven = prepared.value;
       else if (prepared.error.code !== 'rhi-not-available')
@@ -1296,7 +1378,36 @@ export function recordFrame(
       lights.pointShadow.length > 0 ||
       lights.spot.some((spot) => spot.castShadow);
     const gpuOwnsAllPrimaryRaster = preparedGpuDriven?.ownsAllRenderables === true;
-    gpuDriven?.onCoverage(gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive);
+    gpuDriven?.onCoverage(
+      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive,
+      standard.kind === 'clustered',
+    );
+
+    const cubeCaptureWork = prepareCubeCapture(internals, cubeCapture, camera);
+
+    // Validate renderables before graph admission. Besides producing the draw
+    // plan, this is the owner of per-frame cache eviction; running it before a
+    // graph candidate can fail guarantees despawned instance buffers are
+    // released even when the frame cannot be submitted.
+    const gpuOwnedEntityKeys = preparedGpuDriven?.entityKeys ?? EMPTY_ENTITY_KEYS;
+    const validated = runRecordProfilePhase(profilePhase, 'record/validation', () =>
+      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive && cubeCaptureWork.length === 0
+        ? []
+        : validateRenderables(
+            internals,
+            world,
+            worlds,
+            pipelineState,
+            frameState,
+            renderables,
+            transparentDispatch,
+            cpuShadowCastersActive || cubeCaptureWork.length > 0
+              ? EMPTY_ENTITY_KEYS
+              : gpuOwnedEntityKeys,
+          ),
+    );
+    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys);
+    cleanPerFrameCaches(internals, frameState, validated, gpuOwnedEntityKeys);
 
     const preflightGraph = runRecordProfilePhase(profilePhase, 'record/render-graph', () =>
       ensureCompiledFrameGraph(
@@ -1310,14 +1421,60 @@ export function recordFrame(
         graphShadowMapSize,
         preparedGpuDriven,
         featureGraphCandidate,
+        cubeCapture?.state,
         cameras.length === 0,
         transmissionDemand,
         graphVolumetricFog,
         volumeTopologyCandidate,
+        standard,
       ),
     );
     if (preflightGraph === null) return false;
 
+    // The compiled graph is the acceptance boundary for the prepared
+    // Standard lighting declaration. Upload the same declaration only after
+    // that graph is current; a failed candidate therefore cannot leave an old
+    // graph consuming a new buffer generation.
+    if (frameState.standardLightingGraphSignature !== standardLightingTopologySignature(standard)) {
+      internals.errorRegistry.fire(
+        new RendererOperationError('device-operation-failed', {
+          operation: 'draw',
+          cause: {
+            code: 'standard-graph-generation-mismatch',
+            expected: 'compiled graph and prepared Standard lighting share one topology signature',
+            hint: 'retry the frame after the Standard graph candidate is accepted',
+            detail: {
+              expected: standardLightingTopologySignature(standard),
+              actual: frameState.standardLightingGraphSignature,
+            },
+          },
+        }),
+      );
+      return false;
+    }
+    if (standard.kind === 'clustered') {
+      const clusterWrite = runRecordProfilePhase(
+        profilePhase,
+        'record/scene-state/hdrp-cluster',
+        () =>
+          writeHdrpClusterAndSsaoBuffers(
+            internals,
+            frameState,
+            camera,
+            standard.prepared,
+            standard.transport,
+            profilePhase,
+            pipelineState.hdrpClusterMembershipPipeline !== null,
+            pipelineState.hdrpClusterMembershipBindGroupLayout,
+            preparedSpotLightProjector?.lightSlotIndex,
+          ),
+      );
+      if (!clusterWrite.ok) {
+        internals.errorRegistry.fire(clusterWrite.error);
+        return false;
+      }
+    }
+
     // Acquire the swap-chain texture + colour view + target dimensions (with
     // one reconfigure-and-retry on surface-outdated). Extracted to
     // acquireSwapChainTarget (M3/w18); returns null on unrecoverable failure
@@ -1501,41 +1658,6 @@ export function recordFrame(
     const geometryColorResolveView: TextureView | null = null;
     const ldrSpriteColorView: TextureView | null = null;
 
-    // Validate renderable handles + collect render plan. Empty `renderables`
-    // input or all-unregistered handles both produce `validatedOrdered.length === 0`,
-    // which is the Case E (clear-pass-only) path.
-    //
-    // feat-20260520-2d-sprite-layer-mvp M-3 / w25 (@new-surface): per-entry
-    // `renderableIndex` tracks the position into the original renderables[]
-    // array so the bucket-aware reordering below can correlate
-    // transparent-sort output (TransparentEntry.renderableIndex) back to
-    // the validated row.
-    // bug-20260527-renderstate-pipeline-dispatch-gap D-4:
-    // build a renderableIndex -> renderState map from dispatch entries
-    // so each ValidatedRenderable carries its per-material renderState
-    // override without an O(n^2) back-scan in the draw loop.
-    const gpuOwnedEntityKeys = preparedGpuDriven?.entityKeys ?? EMPTY_ENTITY_KEYS;
-    const validated = runRecordProfilePhase(profilePhase, 'record/validation', () =>
-      gpuOwnsAllPrimaryRaster && !cpuShadowCastersActive
-        ? []
-        : validateRenderables(
-            internals,
-            world,
-            worlds,
-            pipelineState,
-            frameState,
-            renderables,
-            transparentDispatch,
-            cpuShadowCastersActive ? EMPTY_ENTITY_KEYS : gpuOwnedEntityKeys,
-          ),
-    );
-    gpuDriven?.owner.recordCpuValidation(validated, gpuOwnedEntityKeys);
-
-    // Per-frame cache clean-up: drop per-entity BG cache entries + instance
-    // buffers whose entityKey is absent from the current validated set (despawn
-    // eviction). Extracted to cleanPerFrameCaches (M3/w18).
-    cleanPerFrameCaches(internals, frameState, validated, gpuOwnedEntityKeys);
-
     // Dispatch-ordered render plan: reorder validated renderables to dispatch
     // order, run the mesh-SSBO capacity gate (graceful truncation), and build
     // the fold dispatch plan. Extracted to buildDispatchPlan (M3/w18).
@@ -1607,6 +1729,7 @@ export function recordFrame(
           frameState.spotShadowSnapshots,
           fog,
           temporalView,
+          preparedSpotLightProjector?.spotIndex,
         );
         if (pipelineState.pointsLinesViewBuffer !== undefined) {
           writePointsLinesViewUbo(
@@ -1623,11 +1746,6 @@ export function recordFrame(
           lights,
         );
 
-        // Per-frame full rewrite of the PointLight + SpotLight std430 storage
-        // buffers (header + first-slice cap N=4 slots). Extracted to
-        // writePointSpotLightBuffers (M3/w18).
-        writePointSpotLightBuffers(internals, pipelineState, lights);
-
         // Per-renderable entity_world upload (batched): all N mat4+normalMatrix
         // slots assembled into a single contiguous scratch buffer, then flushed
         // as one writeBuffer call. Extracted to mesh-ssbo.ts (M3/w21) so its
@@ -1676,10 +1794,40 @@ export function recordFrame(
           validated.length > 0 || preparedGpuDriven !== undefined,
           bindGroupCounts,
           undefined,
-          false,
+          true,
+          standard,
         ),
       );
 
+    for (const capture of cubeCaptureWork) {
+      writeViewUbo(
+        internals.device.queue,
+        pipelineState.viewUniformBuffer,
+        capture.faceCamera,
+        light,
+        lights,
+        frameState.spotShadowSnapshots,
+        capture.viewBindGroupDynamicOffset,
+        undefined,
+        preparedSpotLightProjector?.spotIndex,
+      );
+    }
+    for (const probe of cubeCapture?.reflectionProbes?.graph.work ?? []) {
+      if (probe.faceCamera === undefined || probe.viewBindGroupDynamicOffset === undefined)
+        continue;
+      writeViewUbo(
+        internals.device.queue,
+        pipelineState.viewUniformBuffer,
+        probe.faceCamera,
+        light,
+        lights,
+        frameState.spotShadowSnapshots,
+        probe.viewBindGroupDynamicOffset,
+        undefined,
+        preparedSpotLightProjector?.spotIndex,
+      );
+    }
+
     // ── feat-20260529-rendergraph-pass-abstraction M4 / w13b ───────────
     // The compiled typed graph is the sole per-frame pass owner.
     //
@@ -1755,16 +1903,21 @@ export function recordFrame(
       dispatch: transparentDispatch,
       hdrpClusterBindGroup,
       hdrpClusterMembershipBindGroup,
+      standardLighting: standard,
       foldDispatchPlan,
       materialSlotIndices,
       materialSlots,
       materialSlotOwners,
       materialSlotCount,
+      ...(cubeCapture?.reflectionProbes === undefined
+        ? {}
+        : { reflectionProbes: cubeCapture.reflectionProbes }),
       pointsLines: pointsLinesOwner,
       materialBgAssemblyCache: frameState.materialBgAssemblyCache,
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...(profilePhase !== undefined ? { profilePhase } : {}),
     };
+    let completion: Promise<unknown> | undefined;
     const stagedTemporalFrame = {
       frameId: frameState.frameNumber,
       currentViewProjection: new Float32Array(currentViewProjection),
@@ -1788,9 +1941,18 @@ export function recordFrame(
         profilePhase === undefined
           ? undefined
           : (pass, encode) => profilePhase(graphExecutionPhase(pass.name), encode),
+        cubeCaptureWork.length === 0 ? undefined : cubeCaptureWork.map((work) => work.faceIndex),
+        (done) => {
+          completion = done;
+        },
         timingCapture,
       ),
     );
+    if (cubeCapture !== undefined && cubeCaptureWork.length > 0) {
+      const completed = cubeCapture.scheduler.completeSubmission(submitted, completion);
+      if (!completed.ok) internals.errorRegistry.fire(completed.error);
+    }
+    cubeCapture?.reflectionProbes?.completeSubmission(submitted, completion);
     if (submitted && !directionalShadowCache.reuse) {
       frameState.directionalShadowCache = frameState.directionalShadowCacheRecorded
         ? directionalShadowCache.next
@@ -1837,6 +1999,11 @@ export function recordFrame(
         frameState.volumetricFogAccepted = volumetricFog;
         frameState.volumetricFogAcceptedContext = preparedVolumetricFog;
       }
+      frameState.standardLightingInspection = inspectStandardLighting(standard);
+      frameState.pointShadowInspection = inspectPointShadow(
+        lights.pointShadow,
+        SHADOW_ATLAS_DEFAULT_LAYERS,
+      );
     }
     return submitted;
   } finally {
@@ -1857,9 +2024,9 @@ export function recordFrame(
       );
     }
     frameState.frameNumber += 1;
-    // feat-20260608-cluster-lighting M5 / w22: clear HDRP once-per-frame fired
+    // feat-20260608-cluster-lighting M5 / w22: clear Standard once-per-frame fired
     // set so the next frame re-fires if the condition persists.
-    frameState.hdrpOncePerFrameFired.clear();
+    frameState.standardOncePerFrameFired.clear();
   }
 }
 
@@ -1927,6 +2094,20 @@ function sameLightViewProj(
   return true;
 }
 
+function sameDirectionalShadowQuality(
+  previous: DirectionalShadowQuality,
+  next: DirectionalShadowQuality,
+): boolean {
+  if (previous.kind !== next.kind) return false;
+  if (previous.kind === 'pcf' && next.kind === 'pcf') return previous.kernel === next.kernel;
+  if (previous.kind !== 'pcss' || next.kind !== 'pcss') return false;
+  return (
+    previous.preset === next.preset &&
+    previous.angularRadiusRadians === next.angularRadiusRadians &&
+    previous.maxPenumbraTexels === next.maxPenumbraTexels
+  );
+}
+
 function prepareDirectionalShadowCache(
   internals: RenderSystemInternals,
   frameState: RenderFrameState,
@@ -1946,6 +2127,7 @@ function prepareDirectionalShadowCache(
     cascadeCount === undefined ||
     cascadeCount <= 0 ||
     lightViewProj === undefined ||
+    lights.directionalShadowQuality === undefined ||
     validatedOrdered.length === 0
   ) {
     return { reuse: false, next: null };
@@ -1958,6 +2140,10 @@ function prepareDirectionalShadowCache(
     cached !== null &&
     cached.shadowMapSize === shadowMapSize &&
     cached.cascadeCount === cascadeCount &&
+    sameDirectionalShadowQuality(
+      cached.directionalShadowQuality,
+      lights.directionalShadowQuality,
+    ) &&
     cached.pipelineHandle === frameState.installedPipelineHandle &&
     cached.graphTopologyKey === frameState.compiledFrameGraphTopologyKey &&
     cached.assetCatalogEpoch === assetCatalogEpoch &&
@@ -1986,6 +2172,7 @@ function prepareDirectionalShadowCache(
       graphTopologyKey: frameState.compiledFrameGraphTopologyKey,
       shadowMapSize,
       cascadeCount,
+      directionalShadowQuality: lights.directionalShadowQuality,
       lightViewProj: lightViewProj.map((matrix) => new Float32Array(matrix)),
       meshResidencyEpoch,
     },