@forgeax/engine-render 0.1.33 → 0.1.35

package/src/__tests__/volumetric-fog-stage-readback.dawn.test.ts

@@ -3,6 +3,7 @@ import { createShaderModule, rhi } from '@forgeax/engine-rhi-webgpu';
 import { buildEngineShaderManifest } from '@forgeax/engine-vite-plugin-shader';
 import { describe, expect, it } from 'vitest';
 import { BYTES_PER_DIRECT_LIGHT_SLOT } from '../light-buffer-layout';
+import { VIEW_UNIFORM_BYTES } from '../record/view-ubo';
 import { VOLUMETRIC_FOG_PARAMS_BYTES } from '../volume/resources';
 
 const MAP_READ = 0x0001;
@@ -42,6 +43,10 @@ interface VolumeStageReadbacks {
 }
 
 interface StageReadbackOptions {
+  readonly owners?: number;
+  readonly secondDensity?: number;
+  readonly thinSeparated?: boolean;
+  readonly reverse?: boolean;
   readonly sceneDepthClear?: number;
   readonly densityByte?: number;
   /** Optional RGBA8 density field for the production integrate stage. */
@@ -232,6 +237,7 @@ async function runInjectReadback(
   const frameIndex = options.frameIndex ?? 0;
   const shadowDepthClear = options.shadowDepthClear ?? 1;
   const integratorStepCount = options.integratorStepCount;
+  const owners = options.owners ?? 1;
   const device = await requestDevice();
   const moduleResult = await createShaderModule(device, {
     code: manifestShader('fn volume_inject'),
@@ -271,9 +277,17 @@ async function runInjectReadback(
     usage: TEXTURE_BINDING | TEXTURE_COPY_DST,
     textureBindingViewDimension: undefined,
   });
+  const secondDensityTexture = device.createTexture({
+    label: 'stage-readback.second-density',
+    size: { width: SIZE, height: SIZE, depthOrArrayLayers: SIZE },
+    dimension: '3d',
+    format: 'rgba8unorm',
+    usage: TEXTURE_BINDING | TEXTURE_COPY_DST,
+    textureBindingViewDimension: undefined,
+  });
   const outputTexture = device.createTexture({
     label: 'stage-readback.froxel',
-    size: { width: SIZE, height: SIZE, depthOrArrayLayers: PACKED_LAYERS },
+    size: { width: SIZE, height: SIZE, depthOrArrayLayers: PACKED_LAYERS * owners },
     dimension: '2d',
     format: 'rgba8unorm',
     usage: STORAGE_BINDING | TEXTURE_COPY_SRC | TEXTURE_BINDING,
@@ -318,6 +332,7 @@ async function runInjectReadback(
     !sceneDepthTexture.ok ||
     !shadowTexture.ok ||
     !densityTexture.ok ||
+    !secondDensityTexture.ok ||
     !outputTexture.ok ||
     !historyTexture.ok ||
     !temporalTexture.ok ||
@@ -331,6 +346,7 @@ async function runInjectReadback(
   if (!sceneDepthView.ok || !shadowView.ok)
     throw new Error('Dawn volume stage readback unavailable: depth view allocation failed');
   const densityView = createView(device, densityTexture.value, '3d');
+  const secondDensityView = createView(device, secondDensityTexture.value, '3d');
   const outputView = createView(device, outputTexture.value, '2d-array');
   const historyView = createView(device, historyTexture.value, '2d');
   const temporalView = createView(device, temporalTexture.value, '2d');
@@ -338,7 +354,7 @@ async function runInjectReadback(
   const projectorView = createView(device, projectorTexture.value, '2d');
   const viewBuffer = device.createBuffer({
     label: 'stage-readback.view',
-    size: 960,
+    size: VIEW_UNIFORM_BYTES,
     usage: 0x0040 | BUFFER_COPY_DST,
   });
   const paramsBuffer = device.createBuffer({
@@ -358,7 +374,7 @@ async function runInjectReadback(
   });
   const injectReadback = device.createBuffer({
     label: 'stage-readback.inject',
-    size: BYTES_PER_ROW * SIZE * PACKED_LAYERS,
+    size: BYTES_PER_ROW * SIZE * PACKED_LAYERS * owners,
     usage: MAP_READ | BUFFER_COPY_DST,
   });
   const temporalReadback = device.createBuffer({
@@ -382,13 +398,16 @@ async function runInjectReadback(
   )
     throw new Error('Dawn volume stage readback unavailable: readback allocation failed');
 
-  const viewData = new Float32Array(240);
+  const viewData = new Float32Array(VIEW_UNIFORM_BYTES / Float32Array.BYTES_PER_ELEMENT);
   for (const offset of [0, 28, 44, 60, 76, 92, 196, 212]) identityMatrix(viewData, offset);
   viewData[44 + 10] = viewDepthScale;
   viewData[24] = 0;
   viewData[25] = 0;
   viewData[26] = -1;
-  viewData[124] = 0;
+  // Enable one real shadow cascade. Otherwise the stability falsifier sees
+  // only unshadowed texels (the old overlong readback supplied fake zeros).
+  viewData[108] = 10;
+  viewData[124] = 1;
   viewData[228] = 0.1;
   viewData[229] = 10;
   viewData[230] = 0;
@@ -402,6 +421,10 @@ async function runInjectReadback(
   paramsData.set([0, -1, 0, frameIndex], 20);
   paramsData.set([1, 1, 1, 0], 24);
   paramsData.set([maxDistance, 0, 0, 0], 28);
+  // `simulation.w` is the renderer-owned selected-sun cloud transmittance
+  // carrier. A fixture without a CloudLayer must retain the unshadowed
+  // #3197 baseline instead of reading the typed-array zero value.
+  paramsData[35] = 1;
   const lightData = new Uint8Array(CLUSTER_LIGHT_DATA_BYTES);
   if (options.localLight !== undefined) {
     paramsData[30] = options.localLight === 'point' ? 1 : 2;
@@ -414,6 +437,24 @@ async function runInjectReadback(
       16,
     );
   }
+  for (let index = 0; index < owners; index++)
+    paramsData.set(paramsData.slice(0, 36), 36 * (index + 1));
+  paramsData[3] = owners;
+  if (options.secondDensity !== undefined || options.thinSeparated) {
+    for (let index = 0; index < owners; index++) paramsData[36 * (index + 1) + 7] = 1;
+  }
+  if (options.thinSeparated) {
+    paramsData[38] = 0.1;
+    paramsData[42] = 0.101;
+    paramsData[74] = 0.899;
+    paramsData[78] = 0.9;
+    for (const offset of [44, 80]) paramsData.set([100, 100, 100], offset);
+  }
+  if (options.reverse) {
+    const first = paramsData.slice(36, 72);
+    paramsData.copyWithin(36, 72, 108);
+    paramsData.set(first, 72);
+  }
   const clusterUniformData = new Float32Array(8);
   const clusterGrid = new Uint32Array(clusterUniformData.buffer);
   clusterGrid[0] = 1;
@@ -444,6 +485,13 @@ async function runInjectReadback(
   );
   if (!densityWrite.ok)
     throw new Error('Dawn volume stage readback unavailable: density upload failed');
+  const secondDensityWrite = device.queue.writeTexture(
+    { texture: secondDensityTexture.value },
+    new Uint8Array(densityData.length).fill(options.secondDensity ?? 255),
+    { offset: 0, bytesPerRow: SIZE * 4, rowsPerImage: SIZE },
+    { width: SIZE, height: SIZE, depthOrArrayLayers: SIZE },
+  );
+  if (!secondDensityWrite.ok) throw secondDensityWrite.error;
   const projectorWrite = device.queue.writeTexture(
     { texture: projectorTexture.value },
     new Uint8Array([255, 255, 255, 255]),
@@ -467,6 +515,7 @@ async function runInjectReadback(
       },
       { binding: 7, visibility: 4, buffer: { type: 'read-only-storage' } },
       { binding: 8, visibility: 4, buffer: { type: 'uniform' } },
+      { binding: 9, visibility: 4, texture: { sampleType: 'depth', viewDimension: '2d' } },
     ],
   });
   if (!layout.ok) throw layout.error;
@@ -533,6 +582,13 @@ async function runInjectReadback(
       { binding: 11, visibility: 4, buffer: { type: 'uniform' } },
       { binding: 12, visibility: 4, texture: { sampleType: 'float', viewDimension: '2d' } },
       { binding: 13, visibility: 4, sampler: { type: 'filtering' } },
+      { binding: 16, visibility: 4, texture: { sampleType: 'float', viewDimension: '2d' } },
+      { binding: 17, visibility: 4, sampler: { type: 'filtering' } },
+      ...Array.from({ length: 7 }, (_, index) => ({
+        binding: 18 + index,
+        visibility: 4,
+        texture: { sampleType: 'float' as const, viewDimension: '3d' as const },
+      })),
     ],
   });
   if (!temporalLayout.ok) throw temporalLayout.error;
@@ -571,6 +627,7 @@ async function runInjectReadback(
       { binding: 6, resource: { kind: 'textureView', value: outputView } },
       { binding: 7, resource: { kind: 'buffer', value: { buffer: lightDataBuffer.value } } },
       { binding: 8, resource: { kind: 'buffer', value: { buffer: clusterUniformBuffer.value } } },
+      { binding: 9, resource: { kind: 'textureView', value: shadowView.value } },
     ],
   });
   if (!bindings.ok) throw bindings.error;
@@ -593,7 +650,10 @@ async function runInjectReadback(
       { binding: 3, resource: { kind: 'buffer', value: { buffer: paramsBuffer.value } } },
       { binding: 4, resource: { kind: 'buffer', value: { buffer: viewBuffer.value } } },
       { binding: 5, resource: { kind: 'sampler', value: densitySampler.value } },
-      { binding: 6, resource: { kind: 'textureView', value: densityView } },
+      {
+        binding: 6,
+        resource: { kind: 'textureView', value: options.reverse ? secondDensityView : densityView },
+      },
       { binding: 7, resource: { kind: 'sampler', value: densitySampler.value } },
       { binding: 8, resource: { kind: 'textureView', value: historyView } },
       { binding: 9, resource: { kind: 'textureView', value: temporalView } },
@@ -601,6 +661,15 @@ async function runInjectReadback(
       { binding: 11, resource: { kind: 'buffer', value: { buffer: clusterUniformBuffer.value } } },
       { binding: 12, resource: { kind: 'textureView', value: projectorView } },
       { binding: 13, resource: { kind: 'sampler', value: densitySampler.value } },
+      { binding: 16, resource: { kind: 'textureView', value: projectorView } },
+      { binding: 17, resource: { kind: 'sampler', value: densitySampler.value } },
+      ...Array.from({ length: 7 }, (_, index) => ({
+        binding: 18 + index,
+        resource: {
+          kind: 'textureView' as const,
+          value: index === 0 && !options.reverse ? secondDensityView : densityView,
+        },
+      })),
     ],
   });
   if (!temporalBindings.ok) throw temporalBindings.error;
@@ -622,12 +691,12 @@ async function runInjectReadback(
   const compute = encoder.value.beginComputePass();
   compute.setPipeline(pipeline.value);
   compute.setBindGroup(0, bindings.value);
-  compute.dispatchWorkgroups(1, 1, PACKED_LAYERS);
+  compute.dispatchWorkgroups(1, 1, PACKED_LAYERS * owners);
   compute.end();
   encoder.value.copyTextureToBuffer(
     { texture: outputTexture.value as never },
     { buffer: injectReadback.value as never, bytesPerRow: BYTES_PER_ROW, rowsPerImage: SIZE },
-    { width: SIZE, height: SIZE, depthOrArrayLayers: PACKED_LAYERS },
+    { width: SIZE, height: SIZE, depthOrArrayLayers: PACKED_LAYERS * owners },
   );
   const integrateCompute = encoder.value.beginComputePass();
   integrateCompute.setPipeline(integratePipeline.value);
@@ -687,7 +756,7 @@ async function runInjectReadback(
     return { red, green, alpha };
   };
   return {
-    inject: await decode(injectReadback.value, SIZE, 4, false),
+    inject: await decode(injectReadback.value, PACKED_LAYERS * owners, 4, false),
     temporal: await decode(temporalReadback.value, 1, BYTES_PER_PIXEL, true),
     integrate: await decode(integrateReadback.value, 1, BYTES_PER_PIXEL, true),
   };
@@ -726,6 +795,7 @@ describe('volumetric fog production stage readback on Dawn', () => {
   it('keeps static shadow visibility stable across renderer frame phases', async () => {
     const first = await runInjectReadback({ frameIndex: 0, shadowDepthClear: 0.5 });
     const next = await runInjectReadback({ frameIndex: 1, shadowDepthClear: 0.5 });
+    expect(first.inject.red).toHaveLength(SIZE * SIZE * PACKED_LAYERS);
     expect(first.inject).toEqual(next.inject);
     expect(first.inject.red.some((value) => value === 0)).toBe(true);
     expect(first.inject.red.some((value) => value > 0.9)).toBe(true);
@@ -799,6 +869,40 @@ describe('volumetric fog production stage readback on Dawn', () => {
     expect(Math.abs(production - reference)).toBeLessThan(0.002);
   });
 
+  it('samples independent density textures and is invariant under owner permutation', async () => {
+    const transparent = await runInjectReadback({
+      sceneDepthClear: 0.57,
+      owners: 2,
+      secondDensity: 0,
+    });
+    const half = await runInjectReadback({ sceneDepthClear: 0.57, owners: 2, secondDensity: 128 });
+    const reversed = await runInjectReadback({
+      sceneDepthClear: 0.57,
+      owners: 2,
+      secondDensity: 128,
+      reverse: true,
+    });
+    expect(transparent.integrate.alpha[0]).toBeCloseTo(Math.exp(-0.47), 3);
+    expect(half.integrate.alpha[0]).toBeCloseTo(Math.exp(-0.47 * (1 + 128 / 255)), 3);
+    expect(reversed.integrate.alpha).toEqual(half.integrate.alpha);
+    expect(reversed.integrate.red).toEqual(half.integrate.red);
+  });
+  it('does not miss thin local volumes separated by empty space', async () => {
+    const values = await runInjectReadback({ owners: 2, thinSeparated: true });
+    expect(values.integrate.alpha[0]).toBeCloseTo(Math.exp(-0.002 * 100), 3);
+  });
+  it('adds overlapping optical depth instead of rejecting or selecting one volume', async () => {
+    const one = await runInjectReadback({ sceneDepthClear: 0.57 });
+    const two = await runInjectReadback({ sceneDepthClear: 0.57, owners: 2 });
+    const expected = Math.exp(-0.47 * (2 * 1.5 ** 3 - 1) * 2);
+    expect(two.integrate.alpha[0]).toBeCloseTo(expected, 3);
+    expect(two.integrate.alpha[0]).toBeLessThan(one.integrate.alpha[0] ?? 0);
+    expect(two.integrate.red[0]).toBeGreaterThan(one.integrate.red[0] ?? 0);
+  });
+  it('integrates all eight admitted owners through the production parameter layout', async () => {
+    const values = await runInjectReadback({ sceneDepthClear: 0.57, owners: 8, extinction: 0.1 });
+    expect(values.integrate.alpha[0]).toBeCloseTo(Math.exp(-0.47 * (2 * 1.5 ** 3 - 1) * 0.8), 3);
+  });
   it('injects raw density then resolves a 2d integrated volume', async () => {
     const values = await runInjectReadback();
     // biome-ignore lint/suspicious/noConsole: stage readback is machine evidence

package/src/__tests__/volumetric-fog-topology.unit.test.ts

@@ -41,7 +41,7 @@ describe('volumetric fog RenderGraph topology', () => {
   it('integrates the ray independently of packed visibility depth', () => {
     const integrate = shaderSource('volume-integrate.wgsl');
     expect(integrate).toContain('for (var step = 0u; step < ray_step_count; step = step + 1u)');
-    expect(integrate).toContain('let visibility_depth = max(textureNumLayers(froxel) * 4u, 1u);');
+    expect(integrate).toContain('let visibility_depth = max(owner_layers * 4u, 1u);');
   });
 
   it('keeps the Beer-Lambert extinction input physically non-negative', () => {
@@ -144,7 +144,7 @@ describe('volumetric fog RenderGraph topology', () => {
     expect(shaderSource('volume-inject.wgsl')).not.toContain('textureSampleLevel(density');
     expect(shaderSource('volume-inject.wgsl')).not.toContain('stratified32');
     expect(shaderSource('volume-inject.wgsl')).not.toContain('dither_unorm8');
-    expect(shaderSource('volume-integrate.wgsl')).toContain('exp(-sigma_scale');
+    expect(shaderSource('volume-integrate.wgsl')).toContain('exp(-extinction * sample_length)');
     expect(shaderSource('volume-integrate.wgsl')).toContain('textureSampleLevel(froxel');
     expect(shaderSource('volume-integrate.wgsl')).toContain('textureStore(resolved');
     expect(shaderSource('volume-temporal.wgsl')).toContain('var lower');
@@ -194,7 +194,9 @@ describe('volumetric fog RenderGraph topology', () => {
     expect(frameSource).toContain('volumetricFogHistorySlot');
     expect(frameSource).toContain('volumetricFogHistorySignature');
     expect(frameSource).toContain('activeVolumetricFogSignature');
-    expect(frameSource).toContain('params[32] = fog.worldTimeSeconds ?? 0');
+    expect(
+      readFileSync(fileURLToPath(new URL('../record/volume-params.ts', import.meta.url)), 'utf8'),
+    ).toContain('params[32] = fog.worldTimeSeconds ?? 0');
     expect(
       readFileSync(fileURLToPath(new URL('../volume/temporal.ts', import.meta.url)), 'utf8'),
     ).toContain("reason: 'simulation-time'");

package/src/assembly/backend-contract.ts

@@ -60,6 +60,36 @@ export interface RhiBackendPack {
   readonly instrumentation?: RhiBackendInstrumentation;
 }
 
+/** Project a backend module into the Render-owned injected pack contract. */
+export function loadRhiPack(
+  mod: Record<string, unknown>,
+  instrumentation?: RhiBackendPack['instrumentation'],
+): RhiBackendPack {
+  const rhi = mod.rhi as unknown as RhiBackendPack['rhi'];
+  const createShaderModule = mod.createShaderModule as
+    | RhiBackendPack['createShaderModule']
+    | undefined;
+  const createShaderModuleImmediate = mod.createShaderModuleImmediate as
+    | RhiBackendPack['createShaderModuleImmediate']
+    | undefined;
+  const translateErrorEventToRhiError = mod.translateErrorEventToRhiError as
+    | RhiBackendPack['translateErrorEventToRhiError']
+    | undefined;
+  const backendHandleAccessor = mod._internal_getRawDevice as unknown as
+    | RhiBackendPack['_internal_getRawDevice']
+    | undefined;
+  return {
+    rhi,
+    ...(createShaderModule === undefined ? {} : { createShaderModule }),
+    ...(createShaderModuleImmediate === undefined ? {} : { createShaderModuleImmediate }),
+    ...(translateErrorEventToRhiError === undefined ? {} : { translateErrorEventToRhiError }),
+    ...(backendHandleAccessor === undefined
+      ? {}
+      : { _internal_getRawDevice: backendHandleAccessor }),
+    ...(instrumentation === undefined ? {} : { instrumentation }),
+  };
+}
+
 export interface EngineEnvironmentErrorDetail {
   readonly webgpuError?: RhiError | Error | undefined;
   readonly wgpuError?: RhiError | Error | undefined;

package/src/assembly/barrel-distortion-inspection.ts

@@ -0,0 +1,22 @@
+import type { BarrelDistortionInspection } from '../inspection-types';
+import { projectBarrelDistortionInspection } from '../inspection-types';
+
+export function inspectBarrelDistortion(
+  disposed: boolean,
+  deviceLost: boolean,
+  surfaceReleased: boolean,
+  frameId: number,
+  deviceGeneration: number,
+  inspection: BarrelDistortionInspection,
+): BarrelDistortionInspection {
+  if (disposed || deviceLost || surfaceReleased) {
+    return projectBarrelDistortionInspection({
+      effectiveMapping: undefined,
+      frameId,
+      deviceGeneration,
+      graphGeneration: 0,
+      lastKnownGood: false,
+    });
+  }
+  return projectBarrelDistortionInspection({ ...inspection, frameId });
+}

package/src/assembly/canvas-draw-guard.ts

@@ -0,0 +1,11 @@
+import { RhiError } from '@forgeax/engine-rhi';
+
+export function rejectZeroCanvasSize(width: number, height: number): RhiError | undefined {
+  return width > 0 && height > 0
+    ? undefined
+    : new RhiError({
+        code: 'rhi-not-available',
+        expected: 'canvas drawing buffer has positive width and height before drawing',
+        hint: 'restore a positive canvas width and height before retrying renderer.draw',
+      });
+}

package/src/assembly/cloud-shadow-entry.ts

@@ -0,0 +1,22 @@
+import type { MaterialShaderManifestEntry } from '@forgeax/engine-shader';
+import type { ManifestEntry } from '@forgeax/engine-types';
+
+/** Keep the cloud-shadow shader and View layout on one capability branch. */
+function hasCloudShadowViewBindings(wgsl: string): boolean {
+  return /@group\(0\)\s*@binding\((?:16|17)\)\s/.test(wgsl);
+}
+
+export function selectCloudShadowCompatibleEntry(
+  entry: ManifestEntry,
+  materialEntry: MaterialShaderManifestEntry | undefined,
+  projectorAvailable: boolean,
+): ManifestEntry {
+  if (projectorAvailable || !hasCloudShadowViewBindings(entry.wgsl)) return entry;
+  const fallback = materialEntry?.variants.find(
+    (variant) =>
+      (!('PROJECTOR_AVAILABLE' in variant.defines) ||
+        variant.defines.PROJECTOR_AVAILABLE === false) &&
+      !hasCloudShadowViewBindings(variant.composedWgsl),
+  );
+  return fallback === undefined ? entry : { ...entry, wgsl: fallback.composedWgsl };
+}

package/src/assembly/device-feature-admission.ts

@@ -21,12 +21,12 @@ export function transmissionBackdropAvailable(limit: number | undefined): boolea
 }
 /**
  * The complete Standard physical root can declare all optional texture slots.
- * Its material group therefore needs one more sampled-texture entry than the
+ * Its material group therefore needs two more sampled-texture entries than the
  * extended-lighting topology alone. Request this ceiling when the adapter can
  * provide it; lower-capability devices remain fail-closed at material
  * pipeline admission instead of receiving an invalid WebGPU layout.
  */
-export const STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 22;
+export const STANDARD_PHYSICAL_REQUIRED_SAMPLED_TEXTURES = 23;
 
 export interface DeviceFeatureAdmissionOptions {
   readonly gpuPassTiming?: object | undefined;

package/src/assembly/dynamic-geometry-host.ts

@@ -15,6 +15,7 @@ import {
   type DynamicGeometryOrdering,
   type DynamicGeometryPrepareInput,
   type DynamicGeometryReceipt,
+  type DynamicGeometryRecordStageLane,
   sameCandidateCredential,
 } from '../dynamic-geometry';
 
@@ -191,11 +192,21 @@ export function createDynamicGeometryHost(options: {
   readonly currentGeneration: () => number;
   /** Renderer record-stage proof for the most recently submitted frame. */
   readonly isConsumedByRenderFrame: (candidate: DynamicGeometryCandidate) => boolean;
+  /** Renderer-owned lane fact for the most recently submitted frame. */
+  readonly recordStageLane?: (
+    candidate: DynamicGeometryCandidate,
+  ) => DynamicGeometryRecordStageLane | undefined;
   /** Existing temporal owner discards the old surface history after an ECS swap. */
   readonly onTopologyChanged?: () => void;
 }): DynamicGeometryHostImplementation {
-  const { lifecycle, attachedWorlds, getGpuStore, currentGeneration, isConsumedByRenderFrame } =
-    options;
+  const {
+    lifecycle,
+    attachedWorlds,
+    getGpuStore,
+    currentGeneration,
+    isConsumedByRenderFrame,
+    recordStageLane = () => undefined,
+  } = options;
   const hostCandidates = new Map<string, HostCandidateRecord>();
   let observedGeneration = -1;
   const releaseMeshLease = (record: HostCandidateRecord): DynamicGeometryError | undefined => {
@@ -858,44 +869,50 @@ export function createDynamicGeometryHost(options: {
         // instead of silently producing zero receipts.
         const publicationFixedStep = fixedStep ?? worldFixedStep;
         receipts.push(
-          ...lifecycle.publishFrame(frame, [world], publicationFixedStep, (candidate) => {
-            const candidateWorld = candidate.world as World;
-            if (candidateWorld !== world || !attachedWorlds.has(candidateWorld)) return false;
-            const hostRecord = candidateRecord(candidate);
-            if (
-              hostRecord === undefined ||
-              !hostRecord.accepted ||
-              !hasRenderableBinding(candidateWorld, candidate.entity) ||
-              meshHandleOf(candidateWorld, candidate.entity) !== candidate.meshHandle ||
-              !hasMaterialIdentity(
-                candidateWorld,
-                candidate.entity,
-                candidate.mesh,
-                candidate.materialIdentity,
-              )
-            )
-              return false;
-            if (!isConsumedByRenderFrame(candidate)) return false;
-            const actualFixedStep = fixedStep ?? worldFixedStep;
-            if (candidate.fixedStep === undefined || actualFixedStep === undefined) return false;
-            // RenderFrameInput.fixedStep is an assertion from the host, not a
-            // second clock. It may name a later World tick in a multi-fixed-step
-            // host frame, but it cannot manufacture a step the attached World
-            // has not actually published. An explicit mismatch remains a hard
-            // rejection; omission uses the World-derived value above.
-            if (worldFixedStep !== actualFixedStep || actualFixedStep < candidate.fixedStep)
-              return false;
-            if (candidate.physicsEntity !== undefined) {
-              const publication = physicsPublicationOf(candidateWorld, candidate.physicsEntity);
+          ...lifecycle.publishFrame(
+            frame,
+            [world],
+            publicationFixedStep,
+            (candidate) => {
+              const candidateWorld = candidate.world as World;
+              if (candidateWorld !== world || !attachedWorlds.has(candidateWorld)) return false;
+              const hostRecord = candidateRecord(candidate);
               if (
-                publication === undefined ||
-                publication.fixedStep < candidate.fixedStep ||
-                publication.revision !== candidate.revision
+                hostRecord === undefined ||
+                !hostRecord.accepted ||
+                !hasRenderableBinding(candidateWorld, candidate.entity) ||
+                meshHandleOf(candidateWorld, candidate.entity) !== candidate.meshHandle ||
+                !hasMaterialIdentity(
+                  candidateWorld,
+                  candidate.entity,
+                  candidate.mesh,
+                  candidate.materialIdentity,
+                )
               )
                 return false;
-            }
-            return true;
-          }),
+              if (!isConsumedByRenderFrame(candidate)) return false;
+              const actualFixedStep = fixedStep ?? worldFixedStep;
+              if (candidate.fixedStep === undefined || actualFixedStep === undefined) return false;
+              // RenderFrameInput.fixedStep is an assertion from the host, not a
+              // second clock. It may name a later World tick in a multi-fixed-step
+              // host frame, but it cannot manufacture a step the attached World
+              // has not actually published. An explicit mismatch remains a hard
+              // rejection; omission uses the World-derived value above.
+              if (worldFixedStep !== actualFixedStep || actualFixedStep < candidate.fixedStep)
+                return false;
+              if (candidate.physicsEntity !== undefined) {
+                const publication = physicsPublicationOf(candidateWorld, candidate.physicsEntity);
+                if (
+                  publication === undefined ||
+                  publication.fixedStep < candidate.fixedStep ||
+                  publication.revision !== candidate.revision
+                )
+                  return false;
+              }
+              return true;
+            },
+            recordStageLane,
+          ),
         );
       }
       for (const receipt of receipts) {
@@ -931,6 +948,11 @@ export function createRendererDynamicGeometryHost(options: {
       entity: number,
       meshHandle: DynamicGeometryCandidate['meshHandle'],
     ) => boolean;
+    readonly dynamicGeometryRecordStageLane: (
+      world: World,
+      entity: number,
+      meshHandle: DynamicGeometryCandidate['meshHandle'],
+    ) => DynamicGeometryRecordStageLane | undefined;
   };
 }): DynamicGeometryHostImplementation {
   const { renderSystem, ...hostOptions } = options;
@@ -943,6 +965,12 @@ export function createRendererDynamicGeometryHost(options: {
         candidate.entity ?? -1,
         candidate.meshHandle,
       ),
+    recordStageLane: (candidate) =>
+      renderSystem.dynamicGeometryRecordStageLane(
+        candidate.world as World,
+        candidate.entity ?? -1,
+        candidate.meshHandle,
+      ),
   });
 }
 

package/src/assembly/dynamic-geometry-runtime.ts

@@ -24,7 +24,7 @@ export function createDynamicGeometryRuntime(options: {
   readonly currentGeneration: () => number;
   readonly renderSystem: Pick<
     RenderSystem,
-    'invalidateGeometryHistory' | 'isDynamicGeometryConsumed'
+    'invalidateGeometryHistory' | 'isDynamicGeometryConsumed' | 'dynamicGeometryRecordStageLane'
   >;
 }): DynamicGeometryRuntime {
   const lifecycle = createDynamicGeometryLifecycle();
@@ -40,6 +40,12 @@ export function createDynamicGeometryRuntime(options: {
         candidate.entity ?? -1,
         candidate.meshHandle,
       ),
+    recordStageLane: (candidate) =>
+      options.renderSystem.dynamicGeometryRecordStageLane(
+        candidate.world as World,
+        candidate.entity ?? -1,
+        candidate.meshHandle,
+      ),
   });
   return { lifecycle, host };
 }

package/src/assembly/factory.ts

@@ -3,7 +3,7 @@
 // and frame work live in webgpu-renderer.ts.
 
 import type { RendererOptions } from '../render-contract';
-import { EngineEnvironmentError, type RhiBackendPack } from './backend-contract';
+import { EngineEnvironmentError, loadRhiPack, type RhiBackendPack } from './backend-contract';
 import type { BundlerOptions } from './bundler-contract';
 import type { RendererAssemblyImplementation } from './host-contract';
 import { toError } from './renderer-facade';
@@ -80,6 +80,7 @@ export {
   selectSkinPrewarmVariants,
   selectStandardPbrTransmissionPrewarmVariants,
   shouldDeferMissingPreparedMaterialShader,
+  stripCloudShadowBindingsForLowLimit,
 } from './webgpu-renderer';
 
 const GPU_ENVIRONMENT_ERROR_CODES = new Set([
@@ -104,35 +105,6 @@ function classifyEnvErrorReason(
     : `engine init failed (${name})`;
 }
 
-function loadRhiPack(
-  mod: Record<string, unknown>,
-  instrumentation?: RhiBackendPack['instrumentation'],
-): RhiBackendPack {
-  const rhi = mod.rhi as unknown as RhiBackendPack['rhi'];
-  const createShaderModule = mod.createShaderModule as
-    | RhiBackendPack['createShaderModule']
-    | undefined;
-  const createShaderModuleImmediate = mod.createShaderModuleImmediate as
-    | RhiBackendPack['createShaderModuleImmediate']
-    | undefined;
-  const translateErrorEventToRhiError = mod.translateErrorEventToRhiError as
-    | RhiBackendPack['translateErrorEventToRhiError']
-    | undefined;
-  const backendHandleAccessor = mod._internal_getRawDevice as unknown as
-    | RhiBackendPack['_internal_getRawDevice']
-    | undefined;
-  return {
-    rhi,
-    ...(createShaderModule === undefined ? {} : { createShaderModule }),
-    ...(createShaderModuleImmediate === undefined ? {} : { createShaderModuleImmediate }),
-    ...(translateErrorEventToRhiError === undefined ? {} : { translateErrorEventToRhiError }),
-    ...(backendHandleAccessor === undefined
-      ? {}
-      : { _internal_getRawDevice: backendHandleAccessor }),
-    ...(instrumentation === undefined ? {} : { instrumentation }),
-  };
-}
-
 /** Build a renderer after selecting the host-supplied backend pack. */
 export async function createRenderer(
   canvas: unknown,