@forgeax/engine-shader 0.1.7 → 0.1.20

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

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const volumeInject = readFileSync(new URL('../volume/volume-inject.wgsl', import.meta.url), 'utf8');
+const volumeIntegrate = readFileSync(
+  new URL('../volume/volume-integrate.wgsl', import.meta.url),
+  'utf8',
+);
+
+describe('volume Spot attenuation precision', () => {
+  it('keeps the shared finite-range attenuation monotonic', () => {
+    expect(volumeInject).not.toContain('evalSpotAttenuation');
+    expect(volumeInject).not.toContain('attenuation * cone_distance');
+    expect(volumeInject).toContain('spot_shadow_visibility_at');
+    expect(volumeIntegrate).toContain('evalSpotAttenuation');
+    expect(volumeIntegrate).toContain('spot_attenuation_at');
+    expect(volumeIntegrate).toContain('light.invRangeSquared');
+    // 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
+    // not turn this contract test into a stale substring check.
+    expect(volumeIntegrate).toContain('volume_light_radiance_pair(world_position, visibility)');
+    expect(volumeIntegrate).toContain('volume_spot_radiance(world_position) *');
+    expect(volumeIntegrate).toContain('mix(1.0, spot_visibility, volume_spot_shadow_intensity())');
+  });
+});

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

@@ -0,0 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const attenuation = readFileSync(new URL('../lighting-attenuation.wgsl', import.meta.url), 'utf8');
+const punctual = readFileSync(new URL('../lighting-punctual.wgsl', import.meta.url), 'utf8');
+
+describe('shared Spot volume optics', () => {
+  it('uses finite squared distance attenuation and a smooth cosine cone', () => {
+    expect(attenuation).toContain('evalSpotAttenuation');
+    expect(attenuation).toContain('invRangeSquared');
+    expect(attenuation).toContain('smoothstep(cosOuter, cosInner');
+  });
+
+  it('is consumed by the surface punctual owner', () => {
+    expect(punctual).toContain('forgeax_pbr::lighting_attenuation');
+    expect(punctual).toContain('evalSpotAttenuation');
+  });
+
+  it('keeps invalid range and cone inputs finite at the shared boundary', () => {
+    expect(attenuation).toContain('max(dSquared, 1e-4)');
+    expect(attenuation).toContain('clamp');
+    expect(attenuation).toContain('cosInner');
+    expect(attenuation).toContain('cosOuter');
+  });
+});

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

@@ -70,6 +70,41 @@ describe('built-in MaterialAsset sources', () => {
       { ...material, values: { ...material.values, baseColor: [0.2, 0.3, 0.4, 1] } }.values,
     ).toMatchObject({ baseColor: [0.2, 0.3, 0.4, 1] });
   });
+
+  it.each([
+    'default-standard-pbr.wgsl',
+    'default-standard-pbr-skin.wgsl',
+  ] as const)('keeps the Standard user-region ABI before Skylight in %s', (file) => {
+    const text = source(file);
+    const bindings = [
+      'baseColorSampler',
+      'baseColorTexture',
+      'metallicRoughnessSampler',
+      'metallicRoughnessTexture',
+      'normalSampler',
+      'normalTexture',
+      'specularTintSampler',
+      'specularTintTexture',
+      'emissiveSampler',
+      'emissiveTexture',
+      'occlusionSampler',
+      'occlusionTexture',
+      'transmissionSampler',
+      'transmissionTexture',
+      'thicknessSampler',
+      'thicknessTexture',
+      'irradianceMap',
+    ];
+    let previous = -1;
+    for (const name of bindings) {
+      const index = text.indexOf(`var ${name}`);
+      expect(index, `${file} must declare ${name}`).toBeGreaterThan(previous);
+      previous = index;
+    }
+    expect(text).toContain('@binding(13) var transmissionSampler');
+    expect(text).toContain('@binding(16) var thicknessTexture');
+    expect(text).toContain('@binding(17) var irradianceMap');
+  });
 });
 
 describe('built-in and custom material derived layout matrix', () => {
@@ -77,9 +112,11 @@ describe('built-in and custom material derived layout matrix', () => {
     const names = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.map((entry) => entry.name);
     expect(names).toContain('emissiveTexture');
     expect(names).toContain('occlusionTexture');
+    expect(names).toContain('transmissionTexture');
+    expect(names).toContain('thicknessTexture');
     expect(
       DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) => entry.type === 'texture2d'),
-    ).toHaveLength(6);
+    ).toHaveLength(8);
   });
 
   it('derives a coordinate record for every texture parameter in an interleaved custom schema', () => {

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

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { derive } from '@forgeax/engine-types';
 import Ajv2020 from 'ajv/dist/2020.js';
 import { describe, expect, it } from 'vitest';
 import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '../material-schemas.js';
@@ -56,3 +57,125 @@ describe('standard PBR material alpha contract', () => {
     expect(validateAlpha({ baseColor: [1, 1, 1, 0.5], alphaMode: 'MASK' })).toBe(true);
   });
 });
+
+describe('standard PBR transmission material contract', () => {
+  it('declares the seven transmission and volume parameters once, separate from CPU and GPU evidence', () => {
+    const entries = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) =>
+      [
+        'transmission',
+        'ior',
+        'thickness',
+        'attenuationColor',
+        'attenuationDistance',
+        'transmissionTexture',
+        'thicknessTexture',
+      ].includes(entry.name),
+    );
+    expect(entries).toEqual([
+      { name: 'transmission', type: 'f32', default: 0 },
+      { name: 'ior', type: 'f32', default: 1.5 },
+      { name: 'thickness', type: 'f32', default: 0 },
+      { name: 'attenuationColor', type: 'vec3', colorSpace: 'linear', default: [1, 1, 1] },
+      { name: 'attenuationDistance', type: 'f32' },
+      { name: 'transmissionTexture', type: 'texture2d' },
+      { name: 'thicknessTexture', type: 'texture2d' },
+    ]);
+  });
+
+  it('derives numeric layout and paired texture bindings from the same schema', () => {
+    const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+    expect(derived.numericMembers.map((member) => member.name)).toEqual(
+      expect.arrayContaining([
+        'transmission',
+        'ior',
+        'thickness',
+        'attenuationColor',
+        'attenuationDistance',
+      ]),
+    );
+    expect(derived.textureFieldNames.has('transmissionTexture')).toBe(true);
+    expect(derived.textureFieldNames.has('thicknessTexture')).toBe(true);
+    expect(derived.samplerForTexture.get('transmissionTexture')).toBe(
+      'transmissionTexture_sampler',
+    );
+    expect(derived.samplerForTexture.get('thicknessTexture')).toBe('thicknessTexture_sampler');
+  });
+
+  it('keeps the seven transmission inputs in the reflected UBO and coordinate contract', {
+    timeout: 20_000,
+  }, async () => {
+    const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+    const transmissionNames = [
+      'transmission',
+      'ior',
+      'thickness',
+      'attenuationColor',
+      'attenuationDistance',
+      'transmissionTexture',
+      'thicknessTexture',
+    ];
+
+    expect(derived.numericMembers.map((member) => member.name)).toEqual(
+      expect.arrayContaining(transmissionNames.slice(0, 5)),
+    );
+    expect(derived.coordinateRecords.map((record) => record.parameter)).toEqual(
+      expect.arrayContaining(transmissionNames.slice(5)),
+    );
+    expect(derived.resourceBindings.filter((binding) => binding.binding >= 13)).toEqual([
+      {
+        name: 'transmissionTexture_sampler',
+        parameter: 'transmissionTexture',
+        kind: 'sampler',
+        binding: 13,
+      },
+      {
+        name: 'transmissionTexture',
+        parameter: 'transmissionTexture',
+        kind: 'texture',
+        binding: 14,
+      },
+      {
+        name: 'thicknessTexture_sampler',
+        parameter: 'thicknessTexture',
+        kind: 'sampler',
+        binding: 15,
+      },
+      {
+        name: 'thicknessTexture',
+        parameter: 'thicknessTexture',
+        kind: 'texture',
+        binding: 16,
+      },
+    ]);
+
+    const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+    const manifest = await buildEngineShaderManifest();
+    const material = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(material).toBeDefined();
+    if (material === undefined) return;
+    const transmissionVariant = material.variants.find(
+      (variant) =>
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.STORAGE_BUFFER_AVAILABLE === true &&
+        variant.defines.TRANSMISSION_AVAILABLE === true &&
+        variant.defines.VERTEX_COLOR_AVAILABLE === false,
+    );
+    expect(transmissionVariant).toBeDefined();
+    if (transmissionVariant === undefined) return;
+    expect(derived.totalBytes).toBe(384);
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(13\)\s*var transmissionSampler/,
+    );
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(14\)\s*var transmissionTexture/,
+    );
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(15\)\s*var thicknessSampler/,
+    );
+    expect(transmissionVariant.composedWgsl).toMatch(
+      /@group\(1\)\s*@binding\(16\)\s*var thicknessTexture/,
+    );
+  });
+});

package/src/__tests__/motion-blur.unit.test.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const source = readFileSync(resolve(import.meta.dirname, '../motion-blur.wgsl'), 'utf8');
+
+describe('motion-blur.wgsl', () => {
+  it('declares the portable raster gather contract', () => {
+    expect(source).toContain('@fragment');
+    expect(source).toContain('symmetric');
+    expect(source).toContain('maxRadiusPixels');
+    expect(source).toContain('shutterAngle');
+    expect(source).toContain('sampleCount');
+    expect(source).toContain('textureSample');
+  });
+
+  it('samples scene temporal depth through the portable color path', () => {
+    expect(source).toContain('@group(1) @binding(3) var sceneTemporal : texture_2d<f32>');
+    expect(source).toContain('textureLoad(sceneTemporal, samplePixel, 0)');
+    expect(source).not.toContain('texture_depth_2d');
+    expect(source).not.toContain('sceneDepth');
+    expect(source).not.toContain('depthSampler');
+  });
+
+  it('keeps depth, reactive, reset, and alpha guards in the shader owner', () => {
+    expect(source).toContain('reactive');
+    expect(source).toContain('invalidDepth');
+    expect(source).toContain('depthReject');
+    expect(source).toContain('reset');
+    expect(source).toContain('output.a');
+    expect(source).toContain('#import forgeax_scene_temporal::{unpackSceneTemporalV1}');
+    expect(source).toContain('let blurWeight = (1.0 - reactive)');
+    expect(source).toContain('for (var index = 0u; index < 16u; index += 1u)');
+    expect(source).not.toContain('positiveUv');
+    expect(source).not.toContain('negativeUv');
+  });
+
+  it('does not introduce compute, storage, or temporal history writes', () => {
+    expect(source).not.toContain('@compute');
+    expect(source).not.toContain('var<storage');
+    expect(source).not.toContain('history');
+    expect(source).not.toContain('atomic');
+  });
+});

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

@@ -10,10 +10,25 @@ const pbrTemporalConsumers = [
 ] as const;
 
 describe('scene temporal varyings', () => {
-  it.each(localTemporalShaders)('%s linearly interpolates both clip authorities', (file) => {
+  it('defines the temporal-v1 accessor ABI in one owner module', () => {
+    const source = readFileSync(resolve(import.meta.dirname, '..', 'scene-temporal.wgsl'), 'utf8');
+    expect(source).toContain('struct SceneTemporalV1');
+    expect(source).toContain('fn unpackSceneTemporalV1');
+    expect(source).toContain('motionUv = packed.xy');
+    expect(source).toContain('exp2(packed.z) - 1.0');
+    expect(source).toContain('reactive = clamp(packed.w');
+    expect(source).toContain('packed.z < 0.0');
+    expect(source).toContain('SCENE_DATA_TEMPORAL_V1_CLEAR');
+    expect(source).toContain('rgba16float');
+  });
+
+  it.each(localTemporalShaders)('%s perspective-interpolates both clip authorities', (file) => {
     const source = readFileSync(resolve(import.meta.dirname, '..', file), 'utf8');
-    expect(source).toMatch(/@interpolate\(linear\) currentClip : vec4<f32>/);
-    expect(source).toMatch(/@interpolate\(linear\) previousClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) currentClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) previousClip : vec4<f32>/);
+    expect(source).not.toMatch(
+      /@interpolate\((?:linear|noperspective)\) (?:currentClip|previousClip)/,
+    );
   });
 
   it('keeps PBR UV selection and fragment projection in one module', () => {
@@ -25,8 +40,11 @@ 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_pbr::temporal::{projectPbrSceneTemporal}');
-    expect(source).toMatch(/@interpolate\(linear\) currentClip : vec4<f32>/);
-    expect(source).toMatch(/@interpolate\(linear\) previousClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) currentClip : vec4<f32>/);
+    expect(source).toMatch(/@interpolate\(perspective\) previousClip : vec4<f32>/);
+    expect(source).not.toMatch(
+      /@interpolate\((?:linear|noperspective)\) (?:currentClip|previousClip)/,
+    );
     expect(source).not.toContain('fn transformedTemporalUv');
   });
 });

package/src/__tests__/shader-manifest-transmission.unit.test.ts

@@ -0,0 +1,75 @@
+import { ok, type ShaderModule } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import { ShaderRegistry, type ShaderRegistryDevice } from '../index.js';
+
+function dataUrl(payload: unknown): string {
+  return `data:application/json,${encodeURIComponent(JSON.stringify(payload))}`;
+}
+
+function device(): ShaderRegistryDevice {
+  return {
+    createShaderModule(): ReturnType<ShaderRegistryDevice['createShaderModule']> {
+      return ok({} as ShaderModule);
+    },
+  };
+}
+
+function variant(definesKey: string, transmission: boolean) {
+  return {
+    definesKey,
+    defines: {
+      CLUSTER_FORWARD_AVAILABLE: false,
+      STORAGE_BUFFER_AVAILABLE: true,
+      TRANSMISSION_AVAILABLE: transmission,
+      VERTEX_COLOR_AVAILABLE: false,
+    },
+    composedWgsl: `standard-${transmission}`,
+  };
+}
+
+function standardRow(variants: readonly unknown[]) {
+  return {
+    identifier: 'forgeax::default-standard-pbr',
+    sourcePath: 'default-standard-pbr.wgsl',
+    composedWgsl: 'standard-default',
+    paramSchema: '[]',
+    variants,
+  };
+}
+
+async function load(materialShaders: readonly unknown[]) {
+  const registry = new ShaderRegistry({
+    device: device(),
+    manifestUrl: dataUrl({ entries: [], materialShaders }),
+  });
+  return registry.loadManifest();
+}
+
+describe('Standard transmission manifest validation', () => {
+  const falseKey =
+    'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=false+VERTEX_COLOR_AVAILABLE=false';
+  const trueKey =
+    'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false';
+
+  it('accepts one Standard row with both exact transmission states', async () => {
+    const result = await load([standardRow([variant(falseKey, false), variant(trueKey, true)])]);
+    expect(result.ok).toBe(true);
+  });
+
+  it('rejects a Standard row when either transmission state is missing', async () => {
+    const result = await load([standardRow([variant(falseKey, false)])]);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.code).toBe('manifest-malformed');
+  });
+
+  it('rejects duplicate material rows and duplicate variant keys', async () => {
+    const row = standardRow([variant(falseKey, false), variant(trueKey, true)]);
+    const duplicateRow = await load([row, row]);
+    expect(duplicateRow.ok).toBe(false);
+
+    const duplicateVariant = await load([
+      standardRow([variant(trueKey, true), variant(trueKey, true)]),
+    ]);
+    expect(duplicateVariant.ok).toBe(false);
+  });
+});

package/src/__tests__/shader.unit.test.ts

@@ -16,6 +16,7 @@
 // Paradigm: each block-scoped describe('<source-filename>.test.ts', ...) preserves
 // source as ancestorTitles[0]. Top-level imports merged + deduped.
 
+import { readFileSync } from 'node:fs';
 import type { Result, RhiError, ShaderModule } from '@forgeax/engine-rhi';
 import { beforeAll, describe, expect, it } from 'vitest';
 import type { ShaderError } from '../errors.js';
@@ -31,6 +32,19 @@ import {
   ShaderRegistry,
 } from '../ShaderRegistry.js';
 
+{
+  const sceneTemporalSource = readFileSync(
+    new URL('../scene-temporal.wgsl', import.meta.url),
+    'utf8',
+  );
+  describe('scene-temporal accessor ABI', () => {
+    it('keeps the public shader module free of compiler and backend policy imports', () => {
+      expect(sceneTemporalSource).toContain('forgeax_scene_temporal');
+      expect(sceneTemporalSource).not.toMatch(/naga|shader-compiler|engine-rhi/i);
+    });
+  });
+}
+
 {
   // --- from fullscreen-triangle.test.ts ---
   // @forgeax/engine-shader/__tests__/fullscreen-triangle.test.ts -
@@ -179,7 +193,7 @@ import {
     });
   });
 
-  describe('fxaa.wgsl SSOT gate (AC-05)', () => {
+  describe('fxaa.wgsl display-encoded SSOT gate (AC-05)', () => {
     it('does NOT define fullscreen_triangle (SSOT is in common.wgsl)', () => {
       expect(fxaaSource).not.toMatch(/fn fullscreen_triangle/);
     });
@@ -191,6 +205,17 @@ import {
     it('imports forgeax_view::common::FullscreenOutput', () => {
       expect(fxaaSource).toContain('#import forgeax_view::common::FullscreenOutput');
     });
+
+    it('declares display-encoded input/output without an OETF owner', () => {
+      expect(fxaaSource).toContain('display-encoded');
+      expect(fxaaSource).not.toContain('linearLdrColorDomain');
+      expect(fxaaSource).not.toContain('linearToSrgbOetf');
+    });
+
+    it('returns encoded colors directly from early and final paths', () => {
+      expect(fxaaSource).toMatch(/return vec4<f32>\(centerColor, 1\.0\);/);
+      expect(fxaaSource).toMatch(/return vec4<f32>\(finalColor, 1\.0\);/);
+    });
   });
 
   describe('fxaa.wgsl bindings', () => {
@@ -779,6 +804,8 @@ import {
         '#pragma variant_axis STORAGE_BUFFER_AVAILABLE',
         '#pragma variant_axis CLUSTER_FORWARD_AVAILABLE',
         '#pragma variant_axis VERTEX_COLOR_AVAILABLE',
+        '#pragma variant_axis TRANSMISSION_AVAILABLE',
+        '#pragma variant_axis PROJECTOR_AVAILABLE',
       ]);
     });
 
@@ -923,12 +950,19 @@ import {
     'clearcoatRoughness',
     'specularTint',
     'normalScale',
+    'transmission',
+    'ior',
+    'thickness',
+    'attenuationColor',
+    'attenuationDistance',
     'baseColorTexture',
     'metallicRoughnessTexture',
     'normalTexture',
     'specularTintTexture',
     'emissiveTexture',
     'occlusionTexture',
+    'transmissionTexture',
+    'thicknessTexture',
   ] as const;
 
   const STUB_WGSL = '// stub composed pbr-skin wgsl\n';
@@ -987,7 +1021,7 @@ import {
       const registry = makeMockRegistry();
       registerDefaultStandardPbrSkin(registry, STUB_WGSL, STORAGE_CAPS);
       const entry = lookup(registry);
-      expect(entry.paramSchema).toHaveLength(21);
+      expect(entry.paramSchema).toHaveLength(28);
     });
 
     it('paramSchema names match default-standard-pbr schema field-for-field', () => {
@@ -1020,7 +1054,12 @@ import {
         'f32',
         'f32',
         'f32',
-        // specular tint and its texture map.
+        // specular tint, transmission, and attenuation controls.
+        'vec3',
+        'f32',
+        'f32',
+        'f32',
+        'f32',
         'vec3',
         'f32',
         'texture2d',
@@ -1029,6 +1068,8 @@ import {
         'texture2d',
         'texture2d',
         'texture2d',
+        'texture2d',
+        'texture2d',
       ]);
     });
   });

package/src/__tests__/sprite-variants.unit.test.ts

@@ -117,6 +117,8 @@ describe('w6 (b) -- pbr / unlit / sprite-adjacent shaders DO NOT pick up PER_INS
       '#pragma variant_axis STORAGE_BUFFER_AVAILABLE',
       '#pragma variant_axis CLUSTER_FORWARD_AVAILABLE',
       '#pragma variant_axis VERTEX_COLOR_AVAILABLE',
+      '#pragma variant_axis TRANSMISSION_AVAILABLE',
+      '#pragma variant_axis PROJECTOR_AVAILABLE',
     ]);
   });
 
@@ -207,3 +209,21 @@ describe('w6 (d) -- MAX_UNIFORM_INSTANCES=128 stays unchanged under the new axis
     expect(src).toMatch(/MAX_UNIFORM_INSTANCES\s*=\s*128/);
   });
 });
+
+describe('HDR/display fragment contract', () => {
+  for (const file of ['sprite.wgsl', 'sprite-lit.wgsl'] as const) {
+    it(`${file} keeps LDR OETF in fs_main and HDR output linear`, () => {
+      const src = stripComments(readWgsl(file));
+      const ldrStart = src.indexOf('fn fs_main(');
+      const hdrStart = src.indexOf('fn fs_main_hdr(');
+      expect(ldrStart).toBeGreaterThanOrEqual(0);
+      expect(hdrStart).toBeGreaterThan(ldrStart);
+
+      const ldrBody = src.slice(ldrStart, hdrStart);
+      const hdrBody = src.slice(hdrStart);
+      expect(ldrBody).toContain('linear_to_srgb(');
+      expect(hdrBody).not.toContain('linear_to_srgb(');
+      expect(hdrBody).toContain('return vec4<f32>');
+    });
+  }
+});

package/src/__tests__/taa-resolve.unit.test.ts

@@ -3,24 +3,29 @@ import { resolve } from 'node:path';
 import { describe, expect, it } from 'vitest';
 
 const source = readFileSync(resolve(import.meta.dirname, '../taa-resolve.wgsl'), 'utf8');
+const pbrTemporal = readFileSync(resolve(import.meta.dirname, '../pbr-temporal.wgsl'), 'utf8');
+const sceneTemporal = readFileSync(resolve(import.meta.dirname, '../scene-temporal.wgsl'), 'utf8');
 
 describe('taa-resolve.wgsl', () => {
   it('keeps the fixed packed temporal and two-attachment ABI', () => {
     expect(source).toContain('struct TaaResolveParams');
     expect(source).toContain('@location(0) color');
     expect(source).toContain('@location(1) temporal');
-    expect(source).toContain('output.temporal = temporal');
+    expect(source).toContain('return TaaResolveOutput(');
+    expect(source).toContain('temporal,');
     expect(source).toContain('current.a');
+    expect(source).toContain('1.0 - clamp(temporal.w');
+    expect(source).not.toContain('1.0 - clamp(current.a');
   });
 
   it('contains every v1 rejection and adaptive weighting term', () => {
-    expect(source).toContain('uv + params.currentJitterUv');
+    expect(source).toContain('in.uv + params.currentJitterUv');
     expect(source).toContain('in.uv - temporal.xy');
     expect(source).toContain('closestCurrentTemporal(pixel, dimensions)');
     expect(source).toContain('historyInBounds');
     expect(source).toContain('depthDelta > depthThreshold');
     expect(source).toContain('neighborhoodSquareMean');
-    expect(source).toContain('clamp(rgbToYCoCg(sampledHistory.rgb), clipMin, clipMax)');
+    expect(source).toContain('clamp(rgbToYCoCg(history.rgb), clipMin, clipMax)');
     expect(source).toContain('reactiveFactor');
     expect(source).toContain('velocityFactor');
     expect(source).toContain('depthFactor');
@@ -28,5 +33,72 @@ describe('taa-resolve.wgsl', () => {
     expect(source).toContain('mix(0.88, 0.97, lumaFactor)');
     expect(source).toContain('params.temporalFrameIndex < 8u');
     expect(source).toContain('progressiveWeight');
+    expect(source).toContain('let dimensions = vec2<i32>(textureDimensions(currentColor, 0));');
+    expect(source).toContain('closestCurrentTemporal(pixel, dimensions)');
+    expect(source).toContain('vec2<f32>(dimensions)');
+  });
+
+  it('compiles the PBR temporal seam with coverage-aware reactive output', async () => {
+    const compilerPath = resolve(import.meta.dirname, '../../../shader-compiler/dist/index.mjs');
+    const { compileShader } = await import(/* @vite-ignore */ compilerPath);
+    const common = `
+fn sampleMaterialTexture(
+  texture : texture_2d<f32>,
+  textureSampler : sampler,
+  uv : vec2<f32>,
+  uvScale : vec2<f32>,
+) -> vec4<f32> {
+  return textureSample(texture, textureSampler, uv * uvScale);
+}
+
+`;
+    const sceneTemporalBody = sceneTemporal
+      .replace(/^#define_import_path.*$/gm, '')
+      .replace(/^#import.*$/gm, '');
+    const entry = `${common}
+${sceneTemporalBody}
+${pbrTemporal.replace(/^#define_import_path.*$/gm, '').replace(/^#import.*$/gm, '')}
+@group(0) @binding(0) var colorTexture : texture_2d<f32>;
+@group(0) @binding(1) var colorSampler : sampler;
+@fragment
+fn fs_temporal_probe() -> @location(0) vec4<f32> {
+  return projectPbrSceneTemporal(
+    0.75, 0.5, colorTexture, colorSampler,
+    vec4<f32>(0.0, 0.0, 1.0, 1.0), vec4<f32>(0.0),
+    vec4<f32>(0.0, 0.0, 1.0, 1.0), vec4<f32>(0.0),
+    vec4<f32>(0.0, 0.0, 0.0, 0.0), 0.0,
+    vec2<f32>(0.5), vec2<f32>(0.5), vec2<f32>(0.5), vec2<f32>(0.5),
+    vec2<f32>(0.5), vec2<f32>(0.5), vec2<f32>(0.5), vec2<f32>(0.5),
+  );
+}
+`;
+    const compiled = await compileShader(entry, {
+      id: 'test::pbr-temporal-reactive',
+      defines: { PER_INSTANCE_REGION: false, STORAGE_BUFFER_AVAILABLE: true },
+    });
+    expect(compiled.ok, compiled.ok ? undefined : String(compiled.error)).toBe(true);
+    if (!compiled.ok) return;
+    expect(compiled.value.wgsl).toContain('resolvePbrTemporalReactive');
+    expect(compiled.value.wgsl).toContain('max(clamp(reactive');
+    const discardIndex = pbrTemporal.indexOf('discard;');
+    const reactiveIndex = pbrTemporal.indexOf('let reactiveCoverage');
+    expect(discardIndex).toBeGreaterThanOrEqual(0);
+    expect(discardIndex).toBeLessThan(reactiveIndex);
+  });
+
+  it('rejects a dev-only forced-reactive-zero falsifier', () => {
+    const reactiveCoverageLine =
+      'let reactiveCoverage = resolvePbrTemporalReactive(reactive, baseColorAlpha, baseSample.a);';
+    const falsified = pbrTemporal.replace(reactiveCoverageLine, 'let reactiveCoverage = 0.0;');
+    expect(() => {
+      expect(falsified).toContain(reactiveCoverageLine);
+      expect(falsified).toContain('let reactiveCoverage = 0.0;');
+    }).toThrow();
+  });
+
+  it('keeps the reactive coverage contract explicit', () => {
+    expect(pbrTemporal).toContain('resolvePbrTemporalReactive');
+    expect(pbrTemporal).toContain('coverageReactive');
+    expect(pbrTemporal).not.toContain('return packSceneTemporal(currentClip, previousClip, 0.0)');
   });
 });

package/src/__tests__/transmission-thickness-scale.unit.test.ts

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const shader = readFileSync(resolve(import.meta.dirname, '../default-standard-pbr.wgsl'), 'utf8');
+
+describe('standard transmission thickness scale contract', () => {
+  it('converts local authored thickness through the combined local-to-world basis', () => {
+    expect(shader).toContain('let localToWorld = entityWorld * instanceLocal;');
+    expect(shader).toContain(
+      'let localToWorld = meshes[0].worldFromLocal * instances[in.instanceIdx].localFromInstance;',
+    );
+    expect(shader).toContain('let worldToLocal0 = vec3<f32>(');
+    expect(shader).toContain('let worldRefractedDirection =');
+    expect(shader).toMatch(
+      /finiteScalar\(material\.thickness, 0\.0\) \* length\(worldRefractedDirection\) \*\s+finiteScalar\(thicknessSample, 1\.0\)/,
+    );
+  });
+});