@forgeax/engine-render 0.1.32 → 0.1.34

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

@@ -8,6 +8,7 @@ const signature: VolumeTemporalSignature = {
   densityGeneration: 3,
   width: 1280,
   height: 720,
+  worldTimeSeconds: 4,
 };
 
 describe('volumetric fog temporal contract', () => {
@@ -23,11 +24,37 @@ describe('volumetric fog temporal contract', () => {
     ['fog-revision', { ...signature, fogRevision: 3 }],
     ['light-revision', { ...signature, lightRevision: 8 }],
     ['density-generation', { ...signature, densityGeneration: 4 }],
+    ['simulation-time', { ...signature, worldTimeSeconds: 4.5 }],
     ['resize', { ...signature, width: 640, height: 360 }],
   ] as const)('resets history for %s', (reason, next) => {
     expect(resolveVolumeTemporalReset(signature, next)).toEqual({ reset: true, reason });
   });
 
+  it.each([1 / 144, 1 / 60, 1 / 30, 1 / 15])('retains animated history at dt=%s', (delta) => {
+    expect(
+      resolveVolumeTemporalReset(signature, { ...signature, worldTimeSeconds: 4 + delta }),
+    ).toEqual({ reset: false });
+  });
+
+  it.each([3.9, 4.101, NaN, Infinity])('rejects discontinuous time %s', (worldTimeSeconds) => {
+    expect(resolveVolumeTemporalReset(signature, { ...signature, worldTimeSeconds })).toEqual({
+      reset: true,
+      reason: 'simulation-time',
+    });
+  });
+
+  it('rejects changed clock availability', () => {
+    const { worldTimeSeconds: _time, ...withoutTime } = signature;
+    expect(resolveVolumeTemporalReset(signature, withoutTime)).toEqual({
+      reset: true,
+      reason: 'simulation-time',
+    });
+    expect(resolveVolumeTemporalReset(withoutTime, signature)).toEqual({
+      reset: true,
+      reason: 'simulation-time',
+    });
+  });
+
   it('rejects out-of-screen reprojection and depth discontinuity without NaN', () => {
     expect(
       resolveVolumeTemporalReset(signature, signature, { reprojection: 'out-of-screen' }),

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

@@ -8,6 +8,10 @@ const pipelineSource = readFileSync(
   fileURLToPath(new URL('../pipeline/standard-pipeline.ts', import.meta.url)),
   'utf8',
 );
+const forwardPipelineSource = readFileSync(
+  fileURLToPath(new URL('../pipeline/standard-forward-lane.ts', import.meta.url)),
+  'utf8',
+);
 const shaderSource = (name: string): string =>
   readFileSync(
     fileURLToPath(new URL(`../../../shader/src/volume/${name}`, import.meta.url)),
@@ -34,17 +38,16 @@ describe('volumetric fog RenderGraph topology', () => {
     expect(composite).toContain('abs(neighbor.a - center.a) * 6.0');
   });
 
-  it('derives deterministic integration density from the authored froxel depth', () => {
+  it('integrates the ray independently of packed visibility depth', () => {
     const integrate = shaderSource('volume-integrate.wgsl');
-    expect(integrate).toContain('let ray_step_count = visibility_depth;');
     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', () => {
     const integrate = shaderSource('volume-integrate.wgsl');
     expect(integrate).toContain(
-      'let density_value = max(volume_scattering_density(world_position), 0.0);',
+      'let density_value = max(volume_scattering_density(world_position, volume_params.simulation.x), 0.0);',
     );
   });
 
@@ -114,6 +117,15 @@ describe('volumetric fog RenderGraph topology', () => {
     );
   });
 
+  it('keeps mesh CSM visibility on the shared volume owner in both Standard lanes', () => {
+    for (const source of [pipelineSource, forwardPipelineSource]) {
+      expect(source).toContain('addAuthoredVolumetricFogPasses');
+      expect(source).toContain('shadows.value.directional?.view');
+    }
+    expect(shaderSource('volume-inject.wgsl')).toContain('fn volume_cascade');
+    expect(shaderSource('volume-inject.wgsl')).toContain('sample_shadow_2d_kernel');
+  });
+
   it('encodes real volume work and non-constant optical semantics', () => {
     const passes = readFileSync(
       fileURLToPath(new URL('../volume/passes.ts', import.meta.url)),
@@ -132,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');
@@ -182,6 +194,12 @@ describe('volumetric fog RenderGraph topology', () => {
     expect(frameSource).toContain('volumetricFogHistorySlot');
     expect(frameSource).toContain('volumetricFogHistorySignature');
     expect(frameSource).toContain('activeVolumetricFogSignature');
+    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'");
   });
 
   it('advances temporal history only after the accepted queue submit', () => {

package/src/assembly/analytic-fog-registration.ts

@@ -0,0 +1,14 @@
+import type { RenderSystem } from '../render-system';
+
+export function registerAnalyticFogPostProcess(
+  renderSystem: Pick<RenderSystem, 'registerBuiltinPostProcess'>,
+  source: string,
+  candidate: boolean,
+): void {
+  if (candidate) return;
+  renderSystem.registerBuiltinPostProcess('forgeax.analytic-fog', {
+    source,
+    params: { byteSize: 112, defaultValue: new Uint8Array(112) },
+    reads: ['scene-color', { key: 'scene-depth', sampleType: 'depth' }],
+  });
+}

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/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,

package/src/assembly/fxaa-registration.ts

@@ -0,0 +1,17 @@
+import { FXAA_POST_PROCESS_ID } from '../render-contract';
+import type { RenderSystem } from '../render-system';
+
+/** Register the built-in FXAA post-process once for the active generation. */
+export function registerFxaaPostProcess(
+  renderSystem: Pick<RenderSystem, 'registerBuiltinPostProcess'>,
+  source: string,
+  registered: boolean,
+): boolean {
+  if (registered) return true;
+  renderSystem.registerBuiltinPostProcess(FXAA_POST_PROCESS_ID, {
+    source,
+    params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+    reads: ['ldrColor'],
+  });
+  return true;
+}

package/src/assembly/host-contract.ts

@@ -13,7 +13,6 @@ import type { RecoverFailure } from '../errors/recover';
 import type { ObservationUnavailableError, RenderError } from '../errors/render';
 import type { RenderFeature, RenderFeatureDiagnostics } from '../features/types';
 import type { GpuDrivenProductionInspection, LodOcclusionInspection } from '../inspection-types';
-import type { InstanceCollectionStore } from '../instances';
 import type { MeshMaterialBindingObservation } from '../mesh-material-bindings';
 import type { FrameObservation, FrameObservationOptions } from '../record/frame';
 import type { CurrentGraphTarget, GraphTargetCaptureRequest } from '../record/frame-snapshot';
@@ -35,6 +34,7 @@ import type {
 } from '../render-contract';
 import type { RenderSceneInspection } from '../render-system';
 import type { RenderSceneBounds } from '../scene/render-scene-types';
+import type { SurfaceDynamicInputFrame } from '../surface/dynamic-input';
 import type {
   RenderTarget,
   RenderTargetDescriptor,
@@ -62,8 +62,8 @@ export type RendererHostEventListener = (event: RendererHostEvent) => void;
  * the public Renderer type.
  */
 export interface RendererHostImplementation {
-  /** Renderer-owned authoring and update path for large instance collections. */
-  readonly instances: InstanceCollectionStore;
+  /** Publish one renderer-owned read-only Surface dynamic page for the next frame. */
+  setSurfaceDynamicInput(frame: SurfaceDynamicInputFrame | undefined): void;
   attach(world: World): RenderResult<RenderWorldLease, RenderError>;
   prepareDynamicGeometry(
     input: DynamicGeometryPrepareInput,

package/src/assembly/lod-observation.ts

@@ -0,0 +1,12 @@
+import type { FrameReceipt } from '../render-contract';
+import type { RenderSystem } from '../render-system';
+
+export function observeLodOcclusionForReceipt(
+  renderSystem: Pick<RenderSystem, 'observeLodOcclusion'>,
+  receipt: Pick<FrameReceipt, 'frameId' | 'deviceGeneration'>,
+): Promise<void> {
+  return renderSystem.observeLodOcclusion({
+    frameId: receipt.frameId,
+    deviceGeneration: receipt.deviceGeneration,
+  });
+}

package/src/assembly/material/assembly.ts

@@ -245,7 +245,17 @@ function selectPublishedVariant(
     withColor = withColor.filter((variant) => variant.defines.COVERAGE_ONLY !== true);
   }
   if (options.variantSet !== undefined) {
-    return withColor.find((variant) => variant.definesKey === options.variantSet);
+    const requestedAxes = new Map(
+      options.variantSet.length === 0
+        ? []
+        : options.variantSet.split('+').map((entry) => {
+            const [name, value] = entry.split('=');
+            return [name ?? '', value === 'true'] as const;
+          }),
+    );
+    withColor = withColor.filter((variant) =>
+      [...requestedAxes].every(([name, value]) => variant.defines[name] === value),
+    );
   }
   // GPU-driven Standard owns the storage-backed scene-index variant. Prefer that exact family, then fall back to the closest variant
   // carrying the requested COLOR_0 fact. This keeps the selection deterministic
@@ -296,12 +306,13 @@ export function resolveStandardPbrArtifact(
   for (const lookupId of lookupIds) {
     const lookup = shader.findMaterialArtifact(lookupId);
     if (!lookup.ok) continue;
-    const manifestEntry =
-      shader.materialShaderManifestEntries === undefined
-        ? undefined
-        : Array.from(shader.materialShaderManifestEntries()).find(
-            (entry) => entry.identifier === lookupId,
-          );
+    let manifestEntry: MaterialShaderManifestEntry | undefined;
+    for (const entry of shader.materialShaderManifestEntries?.() ?? []) {
+      if (entry.identifier === lookupId) {
+        manifestEntry = entry;
+        break;
+      }
+    }
     const selected =
       manifestEntry === undefined || manifestEntry.variants.length === 0
         ? undefined
@@ -356,12 +367,13 @@ export function resolveMaterialShaderArtifact(
   for (const lookupId of lookupIds) {
     const lookup = shader.findMaterialArtifact(lookupId);
     if (!lookup.ok) continue;
-    const manifestEntry =
-      shader.materialShaderManifestEntries === undefined
-        ? undefined
-        : Array.from(shader.materialShaderManifestEntries()).find(
-            (entry) => entry.identifier === lookupId,
-          );
+    let manifestEntry: MaterialShaderManifestEntry | undefined;
+    for (const entry of shader.materialShaderManifestEntries?.() ?? []) {
+      if (entry.identifier === lookupId) {
+        manifestEntry = entry;
+        break;
+      }
+    }
     let cache = publishedArtifacts.get(lookup.value);
     if (cache === undefined || cache.manifest !== manifestEntry) {
       cache = { manifest: manifestEntry, requests: new Map() };