@forgeax/engine-shader 0.1.20 → 0.1.23

package/src/__tests__/ibl-irradiance.unit.test.ts

@@ -27,15 +27,18 @@ beforeAll(async () => {
 });
 
 describe('IBL irradiance payload contract', () => {
-  it('records that convolution produces E times pi before the Lambert divide', () => {
-    expect(irradianceSource).toContain('IRRADIANCE_PAYLOAD_E_TIMES_PI');
+  it('records that convolution stores Lambert-normalized E over pi', () => {
+    expect(irradianceSource).toContain('IRRADIANCE_PAYLOAD_E_OVER_PI');
     expect(irradianceSource).toMatch(/irradiance\s*=\s*PI\s*\*\s*irradiance/);
   });
 
   it('keeps the constant-environment analytic oracle finite and explicit', () => {
     const environment = 0.72;
-    const convolvedPayload = environment * Math.PI;
-    const diffuseRadiance = convolvedPayload / Math.PI;
+    // The hemisphere integral is E=pi*L for a constant environment. The
+    // convolution shader's PI*sampleAverage stores E/pi=L directly, which is
+    // the Lambert diffuse radiance consumed by the material shader.
+    const convolvedPayload = environment;
+    const diffuseRadiance = convolvedPayload;
 
     expect(diffuseRadiance).toBeCloseTo(environment, 12);
     expect(Number.isFinite(diffuseRadiance)).toBe(true);

package/src/__tests__/ibl-sampling.unit.test.ts

@@ -29,12 +29,11 @@ beforeAll(async () => {
 describe('IBL diffuse sampling payload contract', () => {
   it('names the sampled payload as E over pi at the canonical sampling owner', () => {
     expect(samplingSource).toContain('irradianceEOverPi');
-    expect(samplingSource).toMatch(/irradianceEOverPi\s*\/\s*PI/);
+    expect(samplingSource).toMatch(/return\s+irradianceEOverPi\s*;/);
   });
 
-  it('does not divide the same diffuse payload twice', () => {
+  it('does not divide the already Lambert-normalized diffuse payload again', () => {
     const diffuseBody = samplingSource.match(/fn sampleIblDiffuse\([\s\S]*?\n\}/)?.[0] ?? '';
-    expect(diffuseBody.match(/\/\s*PI/g) ?? []).toHaveLength(1);
-    expect(diffuseBody).not.toMatch(/irradianceEOverPi\s*\/\s*PI[\s\S]*\/\s*PI/);
+    expect(diffuseBody).not.toMatch(/\/\s*PI/);
   });
 });

package/src/__tests__/lighting-point-spot-volume.unit.test.ts

@@ -24,8 +24,22 @@ describe('shared punctual optics for volumetric fog', () => {
     expect(inject).toContain('evalVolumeSpot');
     expect(integrate).toContain('evalVolumePoint');
     expect(integrate).toContain('evalVolumeSpot');
-    expect(inject).toContain('pointLightsBuffer');
-    expect(inject).toContain('spotLightsBuffer');
+    expect(inject).toContain('light_data');
+    expect(inject).toContain('cluster_uniform');
+    expect(inject).not.toContain('pointLightsBuffer');
+    expect(inject).not.toContain('spotLightsBuffer');
+    expect(integrate).toContain('light_data');
+    expect(integrate).toContain('cluster_uniform');
+    expect(integrate).not.toContain('pointLightsBuffer');
+    expect(integrate).not.toContain('spotLightsBuffer');
+  });
+
+  it('keeps volume View aligned with the directional filter carrier', () => {
+    expect(inject).toContain('directionalShadowFilter : vec4<f32>');
+    expect(inject).toContain('normalBias : f32,\n  directionalShadowFilter');
+    expect(inject).not.toContain('view.pcfKernelSize');
+    expect(inject).toContain('filter_profile >= 4u');
+    expect(inject).toContain('stable PCF3 receiver');
   });
 
   it('keeps the punctual volume path finite and monotonic at range boundaries', () => {

package/src/__tests__/lighting-punctual.unit.test.ts

@@ -4,11 +4,16 @@ import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
 const shaderPath = join(dirname(fileURLToPath(import.meta.url)), '../lighting-punctual.wgsl');
-const hdrpShaderPath = join(
+const standardClusterShaderPath = join(
   dirname(fileURLToPath(import.meta.url)),
-  '../hdrp-cluster-forward.wgsl',
+  '../standard-cluster.wgsl',
 );
 const pbrShaderPath = join(dirname(fileURLToPath(import.meta.url)), '../default-standard-pbr.wgsl');
+const brdfShaderPath = join(dirname(fileURLToPath(import.meta.url)), '../brdf.wgsl');
+const directionalShaderPath = join(
+  dirname(fileURLToPath(import.meta.url)),
+  '../lighting-directional.wgsl',
+);
 
 describe('direct punctual lighting shader contract', () => {
   it('exposes independent point and spot paths with explicit range and cone inputs', async () => {
@@ -16,6 +21,8 @@ describe('direct punctual lighting shader contract', () => {
 
     expect(source).toContain('fn evalPoint(');
     expect(source).toContain('fn evalSpot(');
+    expect(source).toContain('fn evalPointFlat(');
+    expect(source).toContain('fn evalSpotFlat(');
     expect(source).toContain('invRangeSquared');
     expect(source).toContain('cosInner');
     expect(source).toContain('cosOuter');
@@ -36,10 +43,30 @@ describe('direct punctual lighting shader contract', () => {
     expect(source).not.toContain('normalize(lightDir)');
   });
 
+  it('shares Three r184 direct-PBR Fresnel and multiscatter ownership', async () => {
+    const [source, brdf, directional] = await Promise.all([
+      readFile(shaderPath, 'utf8'),
+      readFile(brdfShaderPath, 'utf8'),
+      readFile(directionalShaderPath, 'utf8'),
+    ]);
+
+    expect(brdf).toContain('exp2((-5.55473 * vDotH - 6.98316) * vDotH)');
+    expect(brdf).toContain('fn threeR184DirectMultiScatter(');
+    expect(brdf).toContain('energyLoss * favg * favg + vec3<f32>(1e-6)');
+    expect(brdf).not.toContain('energyLoss * favg + vec3<f32>(1e-6)');
+    expect(source).toContain('threeR184DirectMultiScatter(roughness, nDotV, nDotL, F0)');
+    expect(source).toContain('let diffuse = (1.0 - metallic) * baseColor / 3.14159265;');
+    expect(source).toContain('return factor * factor / dSquared;');
+    expect(source).not.toContain('let kd = (vec3<f32>(1.0) - f) * (1.0 - metallic);');
+    expect(directional).toContain('threeR184DirectMultiScatter');
+    expect(directional).not.toContain('THREE_R184_DFG_LUT');
+  });
+
   it('keeps cluster punctual evaluation in the shared lighting owner', async () => {
-    const source = await readFile(hdrpShaderPath, 'utf8');
+    const source = await readFile(standardClusterShaderPath, 'utf8');
 
-    expect(source).toContain('kind_and_shadow');
+    expect(source).toContain('DirectLightSlot');
+    expect(source).toContain('light.metadata.x');
     expect(source).toContain('evalPoint');
     expect(source).toContain('evalSpot');
     expect(source).toContain('evalSpotShadowed');
@@ -49,18 +76,44 @@ describe('direct punctual lighting shader contract', () => {
   });
 
   it('decodes HDRP spot cone lanes in the shared evaluator order', async () => {
-    const source = await readFile(hdrpShaderPath, 'utf8');
+    const source = await readFile(standardClusterShaderPath, 'utf8');
 
-    expect(source).toContain('light.color.w, light.direction.w, light.position.w');
+    expect(source).toContain('light.colorTimesIntensity.w, light.direction.w, light.position.w');
     expect(source).not.toContain('light.direction.w, light.color.w, light.position.w');
   });
 
+  it('keeps the unshadowed spot sentinel out of the projector flag branch', async () => {
+    const source = await readFile(standardClusterShaderPath, 'utf8');
+
+    expect(source).toContain('if (encoded_tile >= 0 && (encoded_tile & PROJECTOR_FLAG) != 0)');
+    expect(source).toContain(
+      'sampleStandardSpotProjector(view.spotLightViewProj[tile], world_pos, light.metadata)',
+    );
+    expect(source).toContain(
+      'textureSampleLevel(cookieTexture, spotModifierSampler, uv, metadata.w, 0.0).rgb',
+    );
+  });
+
   it('passes precomputed base and clearcoat roughness/F0 facts to cluster lights', async () => {
     const source = await readFile(pbrShaderPath, 'utf8');
 
-    expect(source).toContain(
-      'evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, diffuseAlbedo, metallic, a, f0)',
+    expect(source).toMatch(
+      /evaluateStandardClusterLights\(\s*in\.ndc\.xyz,\s*in\.viewZ,\s*in\.worldPos,\s*n,\s*v,\s*diffuseAlbedo,\s*metallic,\s*a,\s*f0,\s*false,?\s*\)/u,
     );
     expect(source).toContain('coatAlpha, vec3<f32>(0.04)');
   });
+
+  it('requires one shared Directional PCSS orchestration owner', async () => {
+    const source = await readFile(directionalShaderPath, 'utf8');
+
+    expect(source).toContain('PCSS_MEDIUM_RAW_TAPS');
+    expect(source).toContain('PCSS_MEDIUM_COMPARE_TAPS');
+    expect(source).toContain('PCSS_HIGH_RAW_TAPS');
+    expect(source).toContain('PCSS_HIGH_COMPARE_TAPS');
+    expect(source).toContain('fn _samplePcssForCascade');
+    expect(source).toContain('if (blockerCount == 0u)');
+    expect(source).toContain('shadow_load_raw_depth');
+    expect(source).toContain('shadow_sample_compare');
+    expect(source).not.toMatch(/frameIndex|frame_index|taaJitter|taa_jitter|jitter/);
+  });
 });

package/src/__tests__/lighting-spot-volume-attenuation.unit.test.ts

@@ -14,7 +14,7 @@ describe('volume Spot attenuation precision', () => {
     expect(volumeInject).toContain('spot_shadow_visibility_at');
     expect(volumeIntegrate).toContain('evalSpotAttenuation');
     expect(volumeIntegrate).toContain('spot_attenuation_at');
-    expect(volumeIntegrate).toContain('light.invRangeSquared');
+    expect(volumeIntegrate).toContain('light.position.w');
     // The paired Point+Spot owner applies visibility only to the Spot term;
     // the Point radiance remains independent of the spot shadow. Keep the
     // assertion at the semantic call boundary so WGSL formatting changes do

package/src/__tests__/ltc-provenance.unit.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import {
+  generateLtcTables,
+  hashLtcTable,
+  LTC_SOURCE_PROVENANCE,
+  LTC_TABLE_HASHES,
+  LTC_TABLE_HEIGHT,
+  LTC_TABLE_WIDTH,
+  LTC_TABLES,
+} from '../ltc/tables';
+
+describe('LTC provenance and tracked data contract', () => {
+  it('pins the fixed Three.js reference and two 64 by 64 rgba16float tables', () => {
+    expect(LTC_SOURCE_PROVENANCE.source).toBe('Three.js');
+    expect(LTC_SOURCE_PROVENANCE.revision).toBe('r184');
+    expect(LTC_SOURCE_PROVENANCE.generator).toContain('deterministic');
+    expect({ width: LTC_TABLE_WIDTH, height: LTC_TABLE_HEIGHT }).toEqual({ width: 64, height: 64 });
+    expect(LTC_TABLES.lambert.byteLength).toBe(64 * 64 * 4 * 2);
+    expect(LTC_TABLES.ggx.byteLength).toBe(64 * 64 * 4 * 2);
+  });
+
+  it('keeps generation deterministic and hashes the tracked outputs', () => {
+    const first = generateLtcTables();
+    const second = generateLtcTables();
+
+    expect(first).toEqual(second);
+    expect(first).toEqual(LTC_TABLES);
+    expect(hashLtcTable(first.lambert)).toBe(LTC_TABLE_HASHES.lambert);
+    expect(hashLtcTable(first.ggx)).toBe(LTC_TABLE_HASHES.ggx);
+    expect(LTC_TABLE_HASHES.lambert).toMatch(/^[a-f0-9]{64}$/);
+    expect(LTC_TABLE_HASHES.ggx).toMatch(/^[a-f0-9]{64}$/);
+  });
+});

package/src/__tests__/manifest.fixture.json

@@ -18,5 +18,38 @@
       "glsl": null,
       "bindings": "[]"
     }
+  ],
+  "materialShaders": [
+    {
+      "identifier": "forgeax::default-standard-pbr",
+      "sourcePath": "default-standard-pbr.wgsl",
+      "composedWgsl": "@vertex fn vs_main() -> @builtin(position) vec4<f32> { return vec4<f32>(0.0); }",
+      "paramSchema": "[]",
+      "variants": [],
+      "directEntry": "vs_main",
+      "sceneIndexEntry": "vs_scene_index",
+      "materialRow": { "byteLength": 384, "fields": ["baseColor", "alphaCutoff"] },
+      "resourceSlots": [],
+      "uvSets": [],
+      "vertexInputs": [
+        { "semantic": "position", "location": 0, "format": "float32x3" },
+        { "semantic": "normal", "location": 1, "format": "float32x3" },
+        { "semantic": "uv", "location": 2, "format": "float32x2" },
+        { "semantic": "tangent", "location": 3, "format": "float32x4" }
+      ],
+      "alphaMask": { "cutoff": "alphaCutoff", "source": "baseColor.a" },
+      "reflection": {
+        "layoutIdentity": "standard-pbr/material-row-v1",
+        "resourceSlots": [],
+        "vertexInputs": [
+          { "semantic": "position", "location": 0, "format": "float32x3" },
+          { "semantic": "normal", "location": 1, "format": "float32x3" },
+          { "semantic": "uv", "location": 2, "format": "float32x2" },
+          { "semantic": "tangent", "location": 3, "format": "float32x4" }
+        ]
+      },
+      "receiptIdentity": "standard-pbr/material-row-v1",
+      "generation": 1
+    }
   ]
 }

package/src/__tests__/material-contract.unit.test.ts

@@ -102,7 +102,11 @@ describe('standard PBR transmission material contract', () => {
   });
 
   it('keeps the seven transmission inputs in the reflected UBO and coordinate contract', {
-    timeout: 20_000,
+    // This test intentionally invokes the full engine shader manifest
+    // producer. Keep its budget local to the producer-backed contract so a
+    // concurrent coverage child cannot turn host CPU contention into a false
+    // product failure.
+    timeout: 60_000,
   }, async () => {
     const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
     const transmissionNames = [
@@ -178,4 +182,60 @@ describe('standard PBR transmission material contract', () => {
       /@group\(1\)\s*@binding\(16\)\s*var thicknessTexture/,
     );
   });
+
+  it('publishes one receipt for direct and scene-index consumers', {
+    timeout: 20_000,
+  }, async () => {
+    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+    const manifest = await buildEngineShaderManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    const skin = manifest.materialShaders.find((entry) => entry.identifier === 'forgeax::pbr-skin');
+    expect(standard).toBeDefined();
+    expect(skin).toBeDefined();
+    expect(standard).toMatchObject({
+      directEntry: expect.any(String),
+      sceneIndexEntry: expect.any(String),
+      materialRow: expect.any(Object),
+      resourceSlots: expect.any(Array),
+      uvSets: expect.any(Array),
+      vertexInputs: expect.any(Array),
+      alphaMask: expect.any(Object),
+      reflection: expect.any(Object),
+    });
+    expect(skin?.receiptIdentity).toBe(standard?.receiptIdentity);
+  });
+
+  it('composes the scene-index entry into the same validated PBR artifact as the direct entry', {
+    timeout: 30_000,
+  }, async () => {
+    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+    const manifest = await buildEngineShaderManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+    expect(standard.composedWgsl).toMatch(/@vertex\s+fn\s+vs_main\s*\(/);
+    expect(standard.composedWgsl).toMatch(/@vertex\s+fn\s+vs_scene_index\s*\(/);
+    expect(standard.composedWgsl).toMatch(/@fragment\s+fn\s+fs_main\s*\(/);
+    expect(standard.sceneIndexEntry).toBe('vs_scene_index');
+    expect(standard.reflection?.layoutIdentity).toBe(standard.receiptIdentity);
+  });
+
+  it('rejects a receipt that loses a required prepared ABI field', {
+    timeout: 30_000,
+  }, async () => {
+    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+    const manifest = await buildEngineShaderManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+    const malformed = { ...standard } as Record<string, unknown>;
+    delete malformed.reflection;
+    expect(malformed).not.toHaveProperty('reflection');
+  });
 });

package/src/__tests__/material-derived-builtins.integration.test.ts

@@ -1,8 +1,35 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { derive } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '../material-schemas.js';
 
 describe('material derived built-in integration contract', () => {
+  it('routes every Standard lit consumer through the single Cluster accessor', () => {
+    const sources = [
+      readFileSync(resolve(import.meta.dirname, '../default-standard-pbr.wgsl'), 'utf8'),
+      readFileSync(resolve(import.meta.dirname, '../default-standard-pbr-skin.wgsl'), 'utf8'),
+    ];
+
+    for (const source of sources) {
+      expect(source).toContain('evaluateStandardClusterLights');
+      expect(source).not.toContain('evaluate_cluster_lights');
+      expect(source).not.toContain('forgeax_hdrp');
+      expect(source).not.toContain('forgeax_urp');
+    }
+
+    const sprite = readFileSync(resolve(import.meta.dirname, '../sprite-lit.wgsl'), 'utf8');
+    expect(sprite).toContain('evaluateStandardClusterLights');
+    expect(sprite).toContain('CLUSTER_FORWARD_AVAILABLE');
+    expect(sprite).toContain('ndc, viewZ, worldPos');
+    expect(sprite).not.toContain('forgeax_hdrp');
+    expect(sprite).not.toContain('forgeax_urp');
+
+    for (const source of [...sources, sprite]) {
+      expect(source).not.toMatch(/in\.clip\.xy\s*\/\s*in\.clip\.w/);
+    }
+  });
+
   it('uses the same derived identity for standard and skinned standard schemas', () => {
     const standard = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
     const skinned = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);

package/src/__tests__/probe-lighting-composition.unit.test.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const shaderRoot = resolve(import.meta.dirname, '..');
+const probe = readFileSync(resolve(shaderRoot, 'lighting-probe.wgsl'), 'utf8');
+const standard = readFileSync(resolve(shaderRoot, 'default-standard-pbr.wgsl'), 'utf8');
+const skin = readFileSync(resolve(shaderRoot, 'default-standard-pbr-skin.wgsl'), 'utf8');
+
+describe('Probe diffuse shader composition', () => {
+  it('evaluates one SH9 record and derives Sky as the residual', () => {
+    expect(probe).toContain('array<vec4<f32>, 9>');
+    expect(probe).toContain('sh9');
+    expect(probe).toContain('1.0 - localBlendFraction');
+    expect(probe).toContain('max(');
+    expect(standard).toContain('#ifdef PROBE_BLEND_AVAILABLE');
+    expect(standard).toContain('@group(3) @binding(1) var<storage, read> probeBlendRecords');
+    expect(standard).not.toContain('@group(2) @binding(1) var<storage, read> probeBlendRecords');
+    expect(standard).toContain('evaluateProbeDiffuse(probeShPreblend');
+    expect(skin).toContain('evaluateProbeDiffuse(probeShPreblend');
+    expect(skin).toContain('@group(3) @binding(1) var<storage, read> probeBlendRecords');
+  });
+
+  it('keeps Sky out of probe admission and preserves the existing specular owner', () => {
+    expect(probe).not.toContain('q_sky');
+    expect(probe).not.toContain('for (var probe');
+    expect(standard).toContain('sampleIblSpecular');
+    expect(skin).toContain('sampleIblSpecular');
+    expect(standard).not.toContain('sampleProbeSpecular');
+    expect(skin).not.toContain('sampleProbeSpecular');
+  });
+
+  it('suppresses probe diffuse for metal while retaining Skylight IBL inputs', () => {
+    expect(probe).toContain('(1.0 - metallic)');
+    expect(standard).toContain('sampleIblDiffuse');
+    expect(skin).toContain('sampleIblDiffuse');
+  });
+});

package/src/__tests__/rect-area-brdf.unit.test.ts

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+
+describe('RectAreaLight LTC BRDF shader contract', () => {
+  it('provides one-sided Lambert and GGX LTC polygon evaluators', async () => {
+    const source = await readFile(new URL('../lighting-rect-area.wgsl', import.meta.url), 'utf8');
+
+    expect(source).toContain('fn evalRectAreaLtcLambert(');
+    expect(source).toContain('fn evalRectAreaLtcGgx(');
+    expect(source).toContain('fn ltcUv(');
+    expect(source).toContain('fn ltcEdgeVectorFormFactor(');
+    expect(source).toContain('fn ltcClippedSphereFormFactor(');
+    expect(source).toContain('fn ltcEvaluate(');
+    expect(source).toContain('ltcLambertTexture');
+    expect(source).toContain('ltcGgxTexture');
+    expect(source).not.toContain('LTC_LAMBERT');
+    expect(source).not.toContain('LTC_GGX');
+    expect(source).toContain('let rect0 = lightPos - halfX - halfY;');
+    expect(source).toContain(
+      'let transform = mInv * transpose(mat3x3<f32>(tangent, bitangent, n));',
+    );
+    expect(source).toContain('sqrt(1.0 - nDotV)');
+    expect(source).toContain('let diffuse = baseColor * (1.0 - metallic);');
+    expect(source).not.toContain('viewWeight');
+    expect(source).not.toContain('rectAreaSolidAngle');
+  });
+
+  it('does not route Rect through punctual inverse-square or shadow sampling', async () => {
+    const source = await readFile(new URL('../lighting-rect-area.wgsl', import.meta.url), 'utf8');
+
+    expect(source).not.toContain('/ distanceSquared');
+    expect(source).not.toContain('shadowAtlas');
+    expect(source).not.toContain('evalPoint(');
+    expect(source).not.toContain('evalSpot(');
+  });
+});

package/src/__tests__/reflection-probe-sampling.unit.test.ts

@@ -0,0 +1,45 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const samplingSource = readFileSync(new URL('../ibl-sampling.wgsl', import.meta.url), 'utf8');
+const standardSource = readFileSync(
+  new URL('../default-standard-pbr.wgsl', import.meta.url),
+  'utf8',
+);
+
+describe('Standard reflection probe sampling contract', () => {
+  it('keeps global IBL helpers and adds a bounded local probe sampling helper', () => {
+    expect(samplingSource).toMatch(/fn\s+sampleIblDiffuse\s*\(/);
+    expect(samplingSource).toMatch(/fn\s+sampleIblSpecular\s*\(/);
+    expect(samplingSource).toMatch(/fn\s+sampleReflectionProbeSpecular\s*\(/);
+  });
+
+  it('uses box projection and explicit Skylight fallback in the Standard shader', () => {
+    expect(samplingSource).toMatch(/box_project/);
+    expect(standardSource).toMatch(/sampleReflectionProbeSpecular/);
+    expect(standardSource).toContain('skylight.intensity < 0.0');
+    expect(standardSource).toMatch(/sampleIblSpecular/);
+    expect(standardSource).toMatch(/skylight/);
+  });
+
+  it('projects only the environment specular lobe for c=1 without removing diffuse light', () => {
+    expect(standardSource).toContain(
+      'var reflectionFallback = specularIbl * (vec3<f32>(1.0) - coatF);',
+    );
+    expect(standardSource).toContain('kD * irradiance * diffuseAlbedo');
+    expect(standardSource).toContain(
+      'output.reflectionFallback = vec4<f32>(reflectionFallback, 1.0);',
+    );
+    expect(standardSource).not.toContain('output.reflectionFallback = vec4<f32>(ambient, 1.0);');
+  });
+
+  it('keeps probe clearcoat on the selected probe source', () => {
+    expect(standardSource).toMatch(
+      /if \(skylight\.intensity < 0\.0\) \{[\s\S]*?clearcoatIbl = sampleReflectionProbeSpecular\(/,
+    );
+  });
+
+  it('keeps zero-intensity probes distinguishable from an absent Skylight', () => {
+    expect(standardSource).toContain('max(-skylight.intensity - 1.0, 0.0) * ao');
+  });
+});

package/src/__tests__/scene-temporal.unit.test.ts

@@ -20,6 +20,25 @@ describe('scene temporal varyings', () => {
     expect(source).toContain('packed.z < 0.0');
     expect(source).toContain('SCENE_DATA_TEMPORAL_V1_CLEAR');
     expect(source).toContain('rgba16float');
+    expect(source).toContain('fn sceneViewZ');
+    expect(source).toContain('orthographicViewZ = -(temporalProjection.x');
+  });
+
+  it('uses projection depth rather than Euclidean distance for cluster view Z', () => {
+    const sceneViewZ = (
+      clip: { readonly z: number; readonly w: number },
+      temporalProjection: { readonly x: number; readonly y: number; readonly z: number },
+    ) => {
+      const ndcDepth = clip.z / Math.max(Math.abs(clip.w), 1e-6);
+      const orthographicViewZ = -(
+        temporalProjection.x +
+        ndcDepth * (temporalProjection.y - temporalProjection.x)
+      );
+      return temporalProjection.z >= 0.5 ? orthographicViewZ : -clip.w;
+    };
+
+    expect(sceneViewZ({ z: 0.5, w: 1 }, { x: 1, y: 11, z: 1 })).toBe(-6);
+    expect(sceneViewZ({ z: 3, w: 7 }, { x: 1, y: 11, z: 0 })).toBe(-7);
   });
 
   it.each(localTemporalShaders)('%s perspective-interpolates both clip authorities', (file) => {
@@ -39,6 +58,7 @@ describe('scene temporal varyings', () => {
 
   it.each(pbrTemporalConsumers)('%s imports the shared PBR temporal authority', (file) => {
     const source = readFileSync(resolve(import.meta.dirname, '..', file), 'utf8');
+    expect(source).toContain('#import forgeax_scene_temporal::{sceneViewZ}');
     expect(source).toContain('#import forgeax_pbr::temporal::{projectPbrSceneTemporal}');
     expect(source).toMatch(/@interpolate\(perspective\) currentClip : vec4<f32>/);
     expect(source).toMatch(/@interpolate\(perspective\) previousClip : vec4<f32>/);