@forgeax/engine-shader 0.1.7 → 0.1.19

package/src/__tests__/default-standard-pbr-transmission.unit.test.ts

@@ -0,0 +1,181 @@
+import { ok, type ShaderModule } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import { findVariantByKey, ShaderRegistry, type ShaderRegistryDevice } from '../index.js';
+
+type EngineShaderManifest = Awaited<
+  ReturnType<typeof import('@forgeax/engine-vite-plugin-shader').buildEngineShaderManifest>
+>;
+
+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);
+    },
+  };
+}
+
+async function engineManifest(): Promise<EngineShaderManifest> {
+  const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
+  return buildEngineShaderManifest();
+}
+
+describe('default Standard PBR transmission manifest contract', () => {
+  it('publishes both TRANSMISSION_AVAILABLE variants from the cooked producer', {
+    timeout: 20_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+    const transmissionVariants = standard.variants.filter(
+      (variant) => 'TRANSMISSION_AVAILABLE' in variant.defines,
+    );
+    expect(transmissionVariants).toHaveLength(16);
+    expect(new Set(transmissionVariants.map((variant) => variant.definesKey)).size).toBe(16);
+    expect(new Set(transmissionVariants.map((variant) => variant.composedWgsl)).size).toBe(16);
+    for (const storageBufferAvailable of [false, true]) {
+      for (const transmissionAvailable of [false, true]) {
+        const expectedKey = [
+          'CLUSTER_FORWARD_AVAILABLE=false',
+          `STORAGE_BUFFER_AVAILABLE=${storageBufferAvailable}`,
+          `TRANSMISSION_AVAILABLE=${transmissionAvailable}`,
+          'VERTEX_COLOR_AVAILABLE=false',
+        ].join('+');
+        expect(transmissionVariants).toContainEqual(
+          expect.objectContaining({
+            definesKey: expectedKey,
+            defines: expect.objectContaining({
+              CLUSTER_FORWARD_AVAILABLE: false,
+              STORAGE_BUFFER_AVAILABLE: storageBufferAvailable,
+              TRANSMISSION_AVAILABLE: transmissionAvailable,
+              VERTEX_COLOR_AVAILABLE: false,
+            }),
+          }),
+        );
+      }
+    }
+  });
+
+  it('omits transmission-only texture bindings from the fallback variant', {
+    timeout: 20_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+
+    const fallback = standard.variants.find(
+      (variant) =>
+        variant.defines.CLUSTER_FORWARD_AVAILABLE === false &&
+        variant.defines.STORAGE_BUFFER_AVAILABLE === true &&
+        variant.defines.TRANSMISSION_AVAILABLE === false &&
+        variant.defines.VERTEX_COLOR_AVAILABLE === false,
+    );
+    const transmission = standard.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(fallback?.composedWgsl).not.toContain('@binding(13)');
+    expect(fallback?.composedWgsl).not.toContain('@binding(24)');
+    expect(transmission?.composedWgsl).toContain('@binding(13)');
+    expect(transmission?.composedWgsl).toContain('@binding(24)');
+  });
+
+  it('registers one Standard row and resolves a declared variant by exact key', {
+    timeout: 20_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const standard = manifest.materialShaders.find(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(standard).toBeDefined();
+    if (standard === undefined) return;
+
+    const registry = new ShaderRegistry({
+      device: device(),
+      manifestUrl: dataUrl({ entries: [], materialShaders: [standard] }),
+    });
+    const loaded = await registry.loadManifest();
+    expect(loaded.ok).toBe(true);
+    const rows = Array.from(registry.materialShaderManifestEntries()).filter(
+      (entry) => entry.identifier === 'forgeax::default-standard-pbr',
+    );
+    expect(rows).toHaveLength(1);
+    const registered = rows[0];
+    expect(registered).toBeDefined();
+    if (registered === undefined) return;
+
+    const transmission = registered.variants.find(
+      (variant) => variant.defines.TRANSMISSION_AVAILABLE === true,
+    );
+    expect(transmission).toBeDefined();
+    if (transmission === undefined) return;
+    expect(findVariantByKey(registered, transmission.definesKey)).toBe(transmission);
+    expect(
+      findVariantByKey(registered, `${transmission.definesKey}+UNDECLARED=true`),
+    ).toBeUndefined();
+  });
+
+  it('rejects a manifest with a missing transmission variant before prewarm', async () => {
+    const missingVariant = {
+      identifier: 'forgeax::default-standard-pbr',
+      sourcePath: 'default-standard-pbr.wgsl',
+      composedWgsl: 'standard-default',
+      paramSchema: '[]',
+      variants: [
+        {
+          definesKey: 'TRANSMISSION_AVAILABLE=false',
+          defines: { TRANSMISSION_AVAILABLE: false },
+          composedWgsl: 'standard-no-transmission',
+        },
+      ],
+    };
+    const registry = new ShaderRegistry({
+      device: device(),
+      manifestUrl: dataUrl({ entries: [], materialShaders: [missingVariant] }),
+    });
+
+    const loaded = await registry.loadManifest();
+    expect(loaded.ok).toBe(false);
+  });
+
+  it('rejects duplicate variant keys instead of allowing ambiguous prewarm', async () => {
+    const duplicateVariant = {
+      identifier: 'forgeax::default-standard-pbr',
+      sourcePath: 'default-standard-pbr.wgsl',
+      composedWgsl: 'standard-default',
+      paramSchema: '[]',
+      variants: [
+        {
+          definesKey: 'TRANSMISSION_AVAILABLE=true',
+          defines: { TRANSMISSION_AVAILABLE: true },
+          composedWgsl: 'standard-transmission-a',
+        },
+        {
+          definesKey: 'TRANSMISSION_AVAILABLE=true',
+          defines: { TRANSMISSION_AVAILABLE: true },
+          composedWgsl: 'standard-transmission-b',
+        },
+      ],
+    };
+    const registry = new ShaderRegistry({
+      device: device(),
+      manifestUrl: dataUrl({ entries: [], materialShaders: [duplicateVariant] }),
+    });
+
+    const loaded = await registry.loadManifest();
+    expect(loaded.ok).toBe(false);
+  });
+});

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

@@ -59,7 +59,7 @@ describe('direct punctual lighting shader contract', () => {
     const source = await readFile(pbrShaderPath, 'utf8');
 
     expect(source).toContain(
-      'evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, albedo, metallic, a, f0)',
+      'evaluate_cluster_lights(in.ndc, in.viewZ, in.worldPos, n, v, diffuseAlbedo, metallic, a, f0)',
     );
     expect(source).toContain('coatAlpha, vec3<f32>(0.04)');
   });

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,7 @@ import {
         '#pragma variant_axis STORAGE_BUFFER_AVAILABLE',
         '#pragma variant_axis CLUSTER_FORWARD_AVAILABLE',
         '#pragma variant_axis VERTEX_COLOR_AVAILABLE',
+        '#pragma variant_axis TRANSMISSION_AVAILABLE',
       ]);
     });
 
@@ -923,12 +949,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 +1020,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 +1053,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 +1067,8 @@ import {
         'texture2d',
         'texture2d',
         'texture2d',
+        'texture2d',
+        'texture2d',
       ]);
     });
   });

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

@@ -117,6 +117,7 @@ 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',
     ]);
   });
 
@@ -207,3 +208,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>');
+    });
+  }
+});