@forgeax/engine-render 0.1.24 → 0.1.25

package/src/__tests__/surface-standard-pipeline.fixture.ts

@@ -0,0 +1,132 @@
+import { AssetGuid, type PackageId } from '@forgeax/engine-pack/guid';
+import type { MaterialAsset } from '@forgeax/engine-types';
+import { deriveStandardLayerPlan } from '@forgeax/engine-types';
+
+type SurfacePack = {
+  packageId: PackageId;
+  build: () =>
+    | { readonly ok: true; readonly value: Readonly<Record<string, MaterialAsset>> }
+    | Promise<{ readonly ok: true; readonly value: Readonly<Record<string, MaterialAsset>> }>;
+};
+
+type ViteImportMeta = ImportMeta & {
+  glob<T>(
+    patterns: readonly string[],
+    options: { readonly eager: true; readonly import: 'default' },
+  ): Readonly<Record<string, T>>;
+};
+
+const packModules = Object.values(
+  (import.meta as ViteImportMeta).glob<SurfacePack>(
+    [
+      '../../../../templates/game-3d/assets/materials.pack.ts',
+      '../../../../apps/preview/assets/surface-standard-evidence.pack.ts',
+    ],
+    {
+      eager: true,
+      import: 'default',
+    },
+  ),
+);
+if (packModules.length !== 2)
+  throw new Error('surface-evidence-fixture: required pack module missing');
+
+const builtPacks = packModules.map((pack) => {
+  const built = pack.build();
+  if (built instanceof Promise || !built.ok) {
+    throw new Error('surface-evidence-fixture: materials pack did not produce outputs');
+  }
+  return { packageId: pack.packageId, values: built.value };
+});
+const materials = Object.assign({}, ...builtPacks.map((pack) => pack.values)) as Record<
+  string,
+  MaterialAsset | undefined
+>;
+
+function guidForSourceKey(sourceKey: string): AssetGuid {
+  const owner = builtPacks.find((pack) => Object.hasOwn(pack.values, sourceKey));
+  if (owner === undefined) {
+    throw new Error(`surface-evidence-fixture: source key '${sourceKey}' is not published`);
+  }
+  return AssetGuid.derive(owner.packageId, sourceKey);
+}
+
+const rustedIron = materials['material/rusted-iron'];
+
+const defaultBase = materials['material/ground'];
+const defaultPhysical = materials['material/painted'];
+const customPhysical = materials['material/rusted-iron-custom-physical'];
+if (
+  rustedIron === undefined ||
+  defaultBase === undefined ||
+  defaultPhysical === undefined ||
+  customPhysical === undefined
+)
+  throw new Error('surface-evidence-fixture: required material row missing');
+
+export const SURFACE_CLOSURE = 'forgeax_material::surface_v1';
+export const SURFACE_SOURCE_CLOSURE = [
+  'templates/game-3d/assets/materials.pack.ts',
+  'templates/game-3d/assets/shaders/rusted-iron.wgsl',
+] as const;
+export const SURFACE_SOURCE_PATH = 'templates/game-3d/assets/shaders/rusted-iron.wgsl';
+export const SURFACE_MATERIAL_SOURCE_KEY = 'material/rusted-iron';
+export const EVIDENCE_SOURCE_SHA =
+  (import.meta as ImportMeta & { env?: Record<string, string | undefined> }).env
+    ?.VITE_FORGEAX_EVIDENCE_SOURCE_SHA ?? 'unavailable';
+
+export const SURFACE_CASES = [
+  {
+    id: 'default-base',
+    material: defaultBase,
+    materialGuid: AssetGuid.format(guidForSourceKey('material/ground')),
+    surfaceModule: defaultBase.passes?.[0]?.program.moduleSlots?.surface ?? '',
+    physical: false,
+  },
+  {
+    id: 'custom-base',
+    material: rustedIron,
+    materialGuid: AssetGuid.format(guidForSourceKey('material/rusted-iron')),
+    surfaceModule: rustedIron.passes?.[0]?.program.moduleSlots?.surface ?? '',
+    physical: false,
+  },
+  {
+    id: 'default-physical',
+    material: defaultPhysical,
+    materialGuid: '019fb7ce-3200-7000-8000-000000000002',
+    surfaceModule: defaultPhysical.passes?.[0]?.program.moduleSlots?.surface ?? '',
+    physical: true,
+  },
+  {
+    id: 'custom-physical',
+    material: customPhysical,
+    materialGuid: '019fb7ce-3f00-7000-8000-000000000001',
+    surfaceModule: customPhysical.passes?.[0]?.program.moduleSlots?.surface ?? '',
+    physical: true,
+  },
+] as const;
+
+export function layerPlanFor(surfaceCase: (typeof SURFACE_CASES)[number]) {
+  return deriveStandardLayerPlan(
+    surfaceCase.physical ? (surfaceCase.material.parameters ?? []) : [],
+  );
+}
+
+export function baseColorFor(
+  surfaceCase: (typeof SURFACE_CASES)[number],
+): readonly [number, number, number] {
+  const values = surfaceCase.material.values ?? {};
+  const value = values.baseColor ?? values.ironColor;
+  if (!Array.isArray(value) || value.length < 3) {
+    throw new Error(`surface-evidence-fixture: missing base color for ${surfaceCase.id}`);
+  }
+  return [Number(value[0]), Number(value[1]), Number(value[2])];
+}
+
+export function passFor(surfaceCase: (typeof SURFACE_CASES)[number]): 'forward' | 'deferred' {
+  return layerPlanFor(surfaceCase).mode === 'physical' ? 'forward' : 'deferred';
+}
+
+export function publicationGenerationFor(_surfaceCase: (typeof SURFACE_CASES)[number]): number {
+  return 1;
+}

package/src/__tests__/surface-variant-provenance.integration.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import {
+  projectStandardSurfacePasses,
+  type StandardSurfaceProjectionOptions,
+} from '../assembly/material/surface-projection';
+
+type FullCustomFixture = StandardSurfaceProjectionOptions & {
+  readonly surfaceKind: 'full-custom';
+  readonly declaredPasses: readonly ('forward' | 'deferred' | 'shadow-caster')[];
+};
+
+describe('full-custom Surface provenance', () => {
+  it('does not synthesize an undeclared Deferred pass or fallback identity', () => {
+    const options: FullCustomFixture = {
+      surfaceModule: 'game_3d::full_custom_surface',
+      values: { tint: [1, 0.1, 0.05, 1] },
+      surfaceKind: 'full-custom',
+      declaredPasses: ['forward', 'shadow-caster'],
+    };
+
+    const passes = projectStandardSurfacePasses(options);
+
+    expect(passes.map((pass) => pass.name)).toEqual(['forward', 'shadow-caster']);
+    expect(passes.map((pass) => pass.program.module)).toEqual([
+      'forgeax_material::standard',
+      'forgeax_material::standard',
+    ]);
+    for (const pass of passes) {
+      expect(pass.program.moduleSlots?.surface).toBe(options.surfaceModule);
+      expect((pass.renderState?.tags as Record<string, string>).SurfaceKind).toBe('full-custom');
+    }
+  });
+});

package/src/__tests__/volumetric-fog-budget-recovery.integration.test.ts

@@ -651,5 +651,5 @@ describe('volumetric fog budget and recovery contract', () => {
       activeLedger: steadyLedger,
     });
     await renderer.dispose();
-  });
+  }, 30_000);
 });

package/src/assembly/factory.ts

@@ -65,7 +65,9 @@ export {
   isSharedMaterialUserRegionCompatible,
   normalizeMaterialShaderVariantSet,
   projectMaterialPipeline,
+  resolveMaterialShaderBackendArtifactKey,
   resolveMaterialShaderBindingContract,
+  resolveMaterialShaderUvSetCount,
   resolveMaterialShaderVariantSet,
   resolveMaterialShaderVertexInputContract,
   routeMaterialPipeline,

package/src/assembly/material/__tests__/standard-layer-plan-projection.integration.test.ts

@@ -0,0 +1,18 @@
+import { deriveStandardLayerPlan } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { projectStandardSurfacePasses } from '../surface-projection.js';
+
+describe('StandardLayerPlan pass projection', () => {
+  it('keeps a physical Standard material on Forward and shadow passes', () => {
+    const plan = deriveStandardLayerPlan([
+      { name: 'clearcoat', type: 'f32' },
+      { name: 'clearcoatRoughness', type: 'f32' },
+    ]);
+    const passes = projectStandardSurfacePasses({
+      surfaceModule: 'game::surface',
+      values: {},
+      layerPlan: plan,
+    });
+    expect(passes.map((pass) => pass.name)).toEqual(['forward', 'shadow-caster']);
+  });
+});

package/src/assembly/material/__tests__/surface-pass-projection.integration.test.ts

@@ -0,0 +1,62 @@
+import { deriveStandardLayerPlan } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import {
+  projectStandardSurfacePasses,
+  type StandardSurfaceProjectionOptions,
+} from '../surface-projection';
+
+type SurfaceFixture = StandardSurfaceProjectionOptions & {
+  readonly geometryVariant: 'rigid' | 'skinned' | 'instanced';
+  readonly lightingLane: 'direct' | 'clustered';
+  readonly alphaClip: boolean;
+};
+
+const fixture = (geometryVariant: SurfaceFixture['geometryVariant']): SurfaceFixture => ({
+  surfaceModule: 'game_3d::rusted_iron_surface',
+  values: { ironColor: [0.42, 0.47, 0.5, 1] },
+  geometryVariant,
+  lightingLane: geometryVariant === 'instanced' ? 'clustered' : 'direct',
+  alphaClip: geometryVariant === 'skinned',
+});
+
+function tagsFor(pass: ReturnType<typeof projectStandardSurfacePasses>[number]) {
+  return pass.renderState?.tags as Record<string, string>;
+}
+
+describe('Standard Surface pass projection', () => {
+  it.each([
+    'rigid',
+    'skinned',
+    'instanced',
+  ] as const)('projects one %s Surface closure into every Standard pass', (geometryVariant) => {
+    const options = fixture(geometryVariant);
+    const passes = projectStandardSurfacePasses(options);
+
+    expect(passes.map((pass) => pass.name)).toEqual(['forward', 'deferred', 'shadow-caster']);
+    for (const pass of passes) {
+      expect(pass.program.moduleSlots?.surface).toBe(options.surfaceModule);
+      expect(tagsFor(pass)).toMatchObject({
+        SurfaceModule: options.surfaceModule,
+        GeometryVariant: geometryVariant,
+        LightingLane: options.lightingLane,
+        AlphaClip: options.alphaClip ? 'enabled' : 'disabled',
+      });
+    }
+  });
+
+  it('keeps base Standard on Deferred while physical Standard stays Forward-only', () => {
+    const base = projectStandardSurfacePasses({
+      ...fixture('rigid'),
+      layerPlan: deriveStandardLayerPlan([]),
+    });
+    const physical = projectStandardSurfacePasses({
+      ...fixture('rigid'),
+      layerPlan: deriveStandardLayerPlan([
+        { name: 'clearcoat', type: 'f32' },
+        { name: 'clearcoatRoughness', type: 'f32' },
+      ]),
+    });
+    expect(base.map((pass) => pass.name)).toEqual(['forward', 'deferred', 'shadow-caster']);
+    expect(physical.map((pass) => pass.name)).toEqual(['forward', 'shadow-caster']);
+  });
+});

package/src/assembly/material/surface-projection.ts

@@ -0,0 +1,90 @@
+import { DEFAULT_STANDARD_SURFACE_MODULE } from '@forgeax/engine-shader';
+import type {
+  MaterialPass,
+  MaterialRenderState,
+  MaterialValue,
+  StandardLayerPlan,
+} from '@forgeax/engine-types';
+
+export const STANDARD_MATERIAL_MODULE = 'forgeax_material::standard';
+export { DEFAULT_STANDARD_SURFACE_MODULE };
+
+export type StandardSurfacePassName = 'forward' | 'deferred' | 'shadow-caster';
+export type StandardSurfaceGeometryVariant = 'rigid' | 'skinned' | 'instanced';
+export type StandardSurfaceLightingLane = 'direct' | 'clustered';
+export type StandardSurfaceKind = 'standard' | 'full-custom';
+
+export interface StandardSurfaceProjectionOptions {
+  readonly surfaceModule: string;
+  readonly values: Readonly<Record<string, MaterialValue | null>>;
+  readonly renderState?: MaterialRenderState;
+  readonly castShadow?: boolean;
+  readonly queue?: number;
+  readonly geometryVariant?: StandardSurfaceGeometryVariant;
+  readonly lightingLane?: StandardSurfaceLightingLane;
+  readonly alphaClip?: boolean;
+  readonly surfaceKind?: StandardSurfaceKind;
+  readonly declaredPasses?: readonly StandardSurfacePassName[];
+  readonly layerPlan?: StandardLayerPlan;
+}
+
+function pass(
+  name: StandardSurfacePassName,
+  options: StandardSurfaceProjectionOptions,
+  fragmentEntry: string,
+): MaterialPass {
+  const authoredState = options.renderState ?? {};
+  const authoredRecord = authoredState as Readonly<Record<string, unknown>>;
+  const tags = (authoredRecord.tags ?? {}) as Readonly<Record<string, string>>;
+  const lightMode =
+    name === 'shadow-caster' ? 'ShadowCaster' : name === 'forward' ? 'Forward' : 'Deferred';
+  return {
+    name,
+    program: {
+      module: STANDARD_MATERIAL_MODULE,
+      fragmentEntry,
+      moduleSlots: { surface: options.surfaceModule },
+    },
+    renderState: {
+      ...authoredState,
+      tags:
+        options.surfaceModule === DEFAULT_STANDARD_SURFACE_MODULE
+          ? { LightMode: lightMode, ...tags }
+          : {
+              ...tags,
+              LightMode: lightMode,
+              SurfaceModule: options.surfaceModule,
+              SurfaceKind: options.surfaceKind ?? 'standard',
+              GeometryVariant: options.geometryVariant ?? 'rigid',
+              LightingLane: options.lightingLane ?? 'direct',
+              AlphaClip: options.alphaClip === true ? 'enabled' : 'disabled',
+            },
+      ...(options.queue === undefined ? {} : { queue: options.queue }),
+    },
+  };
+}
+
+/** Project one custom or default Surface into the existing Standard pass family. */
+export function projectStandardSurfacePasses(
+  options: StandardSurfaceProjectionOptions,
+): [MaterialPass, ...MaterialPass[]] {
+  const authoredPasses = options.declaredPasses;
+  const passNames: StandardSurfacePassName[] =
+    options.surfaceKind === 'full-custom' && authoredPasses !== undefined
+      ? [...authoredPasses]
+      : (['forward'] as StandardSurfacePassName[]);
+  if (authoredPasses === undefined || options.surfaceKind !== 'full-custom') {
+    const blended = options.renderState?.blend !== undefined;
+    if (!blended && options.layerPlan?.mode !== 'physical') passNames.push('deferred');
+    if (options.castShadow !== false) passNames.push('shadow-caster');
+  }
+  const entries = passNames.map((name) =>
+    pass(
+      name,
+      options,
+      name === 'forward' ? 'fs_main' : name === 'deferred' ? 'fs_gbuffer' : 'fs_shadow',
+    ),
+  );
+  const passes = entries as [MaterialPass, ...MaterialPass[]];
+  return passes;
+}

package/src/assembly/material-shader-policy.ts

@@ -12,6 +12,7 @@ import {
   type MaterialShaderManifestEntry,
   type ShaderCatalog,
   type ShaderCatalogDevice,
+  STANDARD_PIPELINE_PARAM_SCHEMA,
   standardPhysicalTextureFields,
 } from '@forgeax/engine-shader';
 import type { AssetGuid as AssetGuidType, ParamSchemaEntry } from '@forgeax/engine-types';
@@ -282,11 +283,10 @@ export async function prepareMaterialShaders(
   const capValue = (rhiDevice.limits as Readonly<Record<string, number>>)
     .maxStorageBuffersPerShaderStage;
   const webgl2Downlevel = rhiDevice.caps.backendKind === 'wgpu-webgl2';
-  let storageBufferCapable = !webgl2Downlevel;
-  if (typeof capValue === 'number') {
+  const storageBufferCapable = rhiDevice.caps.storageBuffer;
+  if (storageBufferCapable && typeof capValue === 'number') {
     const capCheck = assertStorageBufferCap(capValue);
     if (!capCheck.ok) throw capCheck.error;
-    storageBufferCapable = !webgl2Downlevel && capCheck.value;
   }
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
   const projectorAvailable =
@@ -314,9 +314,10 @@ export async function prepareMaterialShaders(
     // engine-entry compile path, NOT by installMaterialArtifact.
     if (msEntry.identifier.startsWith('forgeax::engine-')) continue;
     // buildVariantKey logic: sorted key=value pairs joined with +; all-true = ''.
-    const variantDefines: Record<string, boolean> = {
-      STORAGE_BUFFER_AVAILABLE: storageBufferCapable,
-    };
+    const variantDefines: Record<string, boolean> = {};
+    if (msEntry.variants.some((variant) => 'STORAGE_BUFFER_AVAILABLE' in variant.defines)) {
+      variantDefines.STORAGE_BUFFER_AVAILABLE = storageBufferCapable;
+    }
     // User material manifests may declare WEBGL2_COMPAT alongside the shared
     // mesh-storage axis. The fallback backend must select that authored
     // branch at boot; otherwise it asks for the impossible bare
@@ -450,11 +451,12 @@ export async function prepareMaterialShaders(
       (candidate) => candidate.identifier === shadowCasterIdentifier,
     );
     if (manifestEntry !== undefined) {
-      // shadow_caster has no authored material parameters. M3 / w12-w13
-      // (D-2 / D-12): derive([]) is the graceful empty-schema path.
+      // shadow_caster evaluates the same default Surface as Standard. Keep
+      // its generated MaterialParameters contract aligned with the Standard
+      // pipeline even when a legacy manifest omitted the material entry.
       registry.installMaterialArtifact(shadowCasterIdentifier, {
         source: manifestEntry.composedWgsl,
-        paramSchema: [],
+        paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA,
       });
       const shaderGuid = ENGINE_SHADER_GUIDS.get(shadowCasterIdentifier);
       if (shaderGuid !== undefined) {
@@ -462,7 +464,7 @@ export async function prepareMaterialShaders(
           kind: 'shader' as const,
           name: shadowCasterIdentifier,
           source: manifestEntry.composedWgsl,
-          paramSchema: [] as readonly import('@forgeax/engine-types').ParamSchemaEntry[],
+          paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA,
         };
         // feat-20260614 M8 (D-17): catalogue by GUID; no handle minted.
         assets.catalog(shaderGuid, shaderAsset);
@@ -659,6 +661,82 @@ export function resolveMaterialShaderVertexInputContract(
     : 'none';
 }
 
+/**
+ * Resolve the number of UV sets declared by one material artifact.
+ *
+ * Runtime-published Surface programs do not necessarily have a manifest
+ * reflection row, so the authored vertex input is the fallback source of
+ * truth. The renderer then feeds this count into the geometry alias
+ * projection, which clamps missing mesh UV sets to the last available set.
+ */
+export function resolveMaterialShaderUvSetCount(
+  source: string | undefined,
+  reflectedCount?: number,
+): number | undefined {
+  if (reflectedCount !== undefined) return reflectedCount;
+  if (source === undefined) return undefined;
+
+  const withoutComments = source.replace(/\/\*[\s\S]*?\*\//gu, '').replace(/\/\/.*$/gmu, '');
+  const inputStructs = [
+    ...withoutComments.matchAll(/struct\s+([A-Za-z_]\w*)\s*\{([^}]*)\}/gu),
+  ].filter((match) => /@location\s*\(/u.test(match[2] ?? ''));
+  for (const inputStruct of inputStructs) {
+    const name = inputStruct[1];
+    const body = inputStruct[2];
+    if (name === undefined || body === undefined) continue;
+    const firstParameter = new RegExp(
+      `@vertex\\s*fn\\s+\\w+\\s*\\(\\s*\\w+\\s*:\\s*${name}\\b`,
+      'u',
+    );
+    if (!firstParameter.test(withoutComments)) continue;
+    let uvSetCount = 0;
+    for (const location of body.matchAll(/@location\s*\(\s*(\d+)\s*\)\s+([A-Za-z_]\w*)/gu)) {
+      const field = location[2];
+      if (field === 'uv') {
+        uvSetCount = Math.max(uvSetCount, 1);
+        continue;
+      }
+      const uvIndex = field?.match(/^uv(\d+)_?$/u)?.[1];
+      if (uvIndex !== undefined) uvSetCount = Math.max(uvSetCount, Number(uvIndex) + 1);
+    }
+    return uvSetCount > 0 ? uvSetCount : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Select a published material artifact that matches a downlevel backend.
+ *
+ * Cooked Surface publications carry immutable backend variants in their
+ * metadata. WebGL2 must select the uniform-fallback specialization before
+ * pipeline construction so its shader, bind-group layout, and cache key stay
+ * capability-consistent.
+ */
+export function resolveMaterialShaderBackendArtifactKey(
+  materialShaderId: string,
+  backendKind: 'webgpu' | 'wgpu-native' | 'wgpu-webgl2' | 'null',
+  artifact:
+    | {
+        readonly metadata?: Readonly<Record<string, unknown>>;
+      }
+    | undefined,
+): string {
+  if (backendKind !== 'wgpu-webgl2') return materialShaderId;
+  const variants = artifact?.metadata?.variants;
+  if (!Array.isArray(variants)) return materialShaderId;
+  const fallback = variants.find((variant): variant is { specializationKey: string } => {
+    if (typeof variant !== 'object' || variant === null) return false;
+    const candidate = variant as Record<string, unknown>;
+    return (
+      candidate.backend === 'webgl2' &&
+      candidate.capability === 'uniform-fallback' &&
+      typeof candidate.specializationKey === 'string' &&
+      candidate.specializationKey.length > 0
+    );
+  });
+  return fallback?.specializationKey ?? materialShaderId;
+}
+
 export function allowsUnlitPreparedFallback(
   depthFormatOverride: GPUTextureFormat | null | undefined,
   vertexLayout: string | undefined,

package/src/assembly/recovery/renderer-recover.ts

@@ -632,7 +632,7 @@ export function createRendererRecovery(deps: RendererRecoveryDependencies): Rend
       releaseCandidate();
       return err(new RecoverError('recover-device-unavailable'));
     }
-    const graphPreparation = renderSystem.prepareRecoveryGraphCandidate({
+    const graphPreparation = await renderSystem.prepareRecoveryGraphCandidate({
       internals: candidateInternals,
       pipelineState: candidatePipelineState,
     });

package/src/assembly/webgpu-ready.ts

@@ -54,7 +54,6 @@ import {
 } from '../ibl/skylight-bind-group';
 import type { BloomInspection } from '../inspection-types';
 import type { DeviceScope, RhiErrorListenerRegistry } from '../lifecycle';
-import { assertStorageBufferCap } from '../light-buffer-layout';
 import {
   buildPbrPipelineLayouts,
   buildPbrSkinLayouts,
@@ -218,22 +217,10 @@ export async function buildReadyWebGPU(
   setVolumetricFogShaderSources: (sources: VolumetricFogShaderSources) => void,
 ): Promise<PipelineState> {
   const extendedLightingShaderAvailable = deriveExtendedLightingCapability(rhiDevice).admitted;
-  // bug-20260610: WebGL2 fallback path — read storage-buffer capability up
-  // front so both Step 2 (shader-module compile, where we patch engine
-  // entries to the STORAGE_BUFFER_AVAILABLE=false variant) and Step 3
-  // (buildPbrPipelineLayouts, which switches between read-only-storage
-  // and uniform BGL entries) walk the same axis. Step 0 already ran in
-  // `prepareMaterialShaders`; this is an idempotent re-read driven by
-  // `device.limits.maxStorageBuffersPerShaderStage`, which is 0 on the
-  // wgpu-wasm WebGL2 backend (downlevel_webgl2_defaults).
-  const capValue = (rhiDevice.limits as Readonly<Record<string, number>>)
-    .maxStorageBuffersPerShaderStage;
+  // Shader layouts and record-stage buffer usage share the RHI capability.
+  // Backend names and numeric limits must not independently re-enable storage.
+  const storageBufferCapable = rhiDevice.caps.storageBuffer;
   const webgl2Downlevel = rhiDevice.caps.backendKind === 'wgpu-webgl2';
-  let storageBufferCapable = !webgl2Downlevel;
-  if (typeof capValue === 'number') {
-    const capCheck = assertStorageBufferCap(capValue);
-    storageBufferCapable = capCheck.ok ? !webgl2Downlevel && capCheck.value : !webgl2Downlevel;
-  }
   const directionalPcssAvailable =
     rhiDevice.caps.backendKind === 'webgpu' || rhiDevice.caps.backendKind === 'wgpu-native';
   const projectorAvailable =