@forgeax/engine-shader 0.1.23 → 0.1.24

package/dist/material-schemas.d.ts

@@ -3,6 +3,37 @@ import { type MaterialShaderArtifactReceipt } from './material/artifact-types.js
 export declare const STANDARD_PBR_ALPHA_CUTOFF_DEFAULT = 0;
 /** Shared material contract for the standard PBR and skinned PBR shaders. */
 export declare const DEFAULT_STANDARD_PBR_PARAM_SCHEMA: readonly ParamSchemaEntry[];
+export type { StandardPhysicalTextureField } from '@forgeax/engine-types';
+/**
+ * Backward-compatible export name for callers that need the physical
+ * projection.  Every entry is selected from the Standard root schema above;
+ * no independent defaults or binding inventory can drift from it.
+ */
+/**
+ * Stable physical texture injection order.  The order is part of the
+ * Standard template's resource ABI and is derived from the root schema by
+ * `standardPhysicalTextureFields`; render/cook must not maintain another
+ * field inventory.
+ */
+export { STANDARD_PHYSICAL_TEXTURE_FIELDS, standardPhysicalTextureFields, } from '@forgeax/engine-types';
+export declare const STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA: readonly ParamSchemaEntry[];
+/**
+ * Canonical static Standard entry.  It deliberately contains only the base
+ * contract (including the specular extension) so a base-only material keeps
+ * its Deferred path and carries no second-stage physical resources.
+ */
+export declare const STANDARD_BASE_PARAM_SCHEMA: readonly ParamSchemaEntry[];
+/**
+ * Canonical boot-time user region for the shared Standard material BGL.
+ *
+ * It is still a projection of the root schema, but unlike the author-facing
+ * base-only projection it retains the pre-existing transmission texture pair.
+ * The template reserves those two pairs before the IBL/backdrop injection so
+ * a base-only shader and a transmissive shader can share one boot layout;
+ * physical texture pairs are never included here and are appended only for a
+ * root contract that declares them.
+ */
+export declare const STANDARD_PIPELINE_PARAM_SCHEMA: readonly ParamSchemaEntry[];
 /** The single producer receipt shared by direct and scene-index Standard PBR. */
 export declare const STANDARD_PBR_ARTIFACT_RECEIPT: MaterialShaderArtifactReceipt;
 /** Skinned Standard PBR keeps the material receipt identity and adds palette ABI. */

package/dist/material-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material-schemas.d.ts","sourceRoot":"","sources":["../src/material-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,8BAA8B,CAAC;AAEtC,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAEnD,6EAA6E;AAC7E,eAAO,MAAM,iCAAiC,EAAE,SAAS,gBAAgB,EA6BxE,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,EAAE,6BACR,CAAC;AAErC,qFAAqF;AACrF,eAAO,MAAM,kCAAkC,EAAE,6BACT,CAAC;AAEzC,eAAO,MAAM,0BAA0B,EAAE,SAAS,gBAAgB,EAIjE,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,SAAS,gBAAgB,EAMlE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,SAAS,gBAAgB,EAIrE,CAAC"}
+{"version":3,"file":"material-schemas.d.ts","sourceRoot":"","sources":["../src/material-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,OAAO,EAEL,KAAK,6BAA6B,EACnC,MAAM,8BAA8B,CAAC;AAEtC,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAEnD,6EAA6E;AAC7E,eAAO,MAAM,iCAAiC,6BAAiC,CAAC;AAEhF,YAAY,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAC1E;;;;GAIG;AACH;;;;;GAKG;AACH,OAAO,EACL,gCAAgC,EAChC,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,oCAAoC,EAAE,SAAS,gBAAgB,EAGzE,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,gBAAgB,EAY/D,CAAC;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B,EAAE,SAAS,gBAAgB,EAOnE,CAAC;AAEJ,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,EAAE,6BACR,CAAC;AAErC,qFAAqF;AACrF,eAAO,MAAM,kCAAkC,EAAE,6BACT,CAAC;AAEzC,eAAO,MAAM,0BAA0B,EAAE,SAAS,gBAAgB,EAIjE,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,SAAS,gBAAgB,EAMlE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,SAAS,gBAAgB,EAIrE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-shader",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -22,12 +22,12 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-rhi": "0.1.23",
-    "@forgeax/engine-types": "0.1.23",
+    "@forgeax/engine-rhi": "0.1.24",
+    "@forgeax/engine-types": "0.1.24",
     "@webgpu/types": "^0.1.71"
   },
   "devDependencies": {
-    "@forgeax/engine-vite-plugin-shader": "0.1.23"
+    "@forgeax/engine-vite-plugin-shader": "0.1.24"
   },
   "forgeax": {
     "metrics": {

package/src/ShaderRegistry.ts

@@ -356,23 +356,6 @@ export class ShaderRegistry {
           }
           variantKeys.add(variant.definesKey);
         }
-        if (ms.identifier === 'forgeax::default-standard-pbr') {
-          const transmissionStates = new Set(
-            ms.variants
-              .filter((variant) => 'TRANSMISSION_AVAILABLE' in variant.defines)
-              .map((variant) => variant.defines.TRANSMISSION_AVAILABLE),
-          );
-          if (!transmissionStates.has(false) || !transmissionStates.has(true)) {
-            return err(
-              manifestMalformed({
-                message:
-                  'ShaderRegistry: Standard material shader is missing a transmission variant state',
-                hint: 'forgeax::default-standard-pbr must declare TRANSMISSION_AVAILABLE=false and true',
-                reason: `declared transmission states: ${JSON.stringify([...transmissionStates])}`,
-              }),
-            );
-          }
-        }
         validatedMaterialShaderEntries.push(ms);
       }
     }

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

@@ -6,15 +6,21 @@ const shader = readFileSync(
   fileURLToPath(new URL('../default-standard-pbr.wgsl', import.meta.url)),
   'utf8',
 );
+const surface = readFileSync(
+  fileURLToPath(new URL('../default_standard_surface.wgsl', import.meta.url)),
+  'utf8',
+);
 
 describe('standard PBR MASK alpha contract', () => {
   it('multiplies factor alpha by sampled texture alpha before discard', () => {
-    expect(shader).toContain('alphaTest(material.baseColor.a * baseSample.a * vertexColor.a)');
+    expect(surface).toContain(
+      'clamp(material.baseColor.a * baseSample.a * vertexColor.a, 0.0, 1.0)',
+    );
   });
 
   it('matches Three r184 alphaTest by discarding values equal to or below cutoff', () => {
-    expect(shader).toContain('alpha <= material.alphaCutoff');
-    expect(shader).not.toContain('alpha < material.alphaCutoff');
+    expect(shader).toContain('surface.opacity <= surface.alphaClipThreshold');
+    expect(shader).not.toContain('surface.opacity < surface.alphaClipThreshold');
   });
 
   it('keeps alpha PBR on the shared Directional factor path', () => {

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

@@ -28,7 +28,7 @@ async function engineManifest(): Promise<EngineShaderManifest> {
 let engineManifestPromise: Promise<EngineShaderManifest> | undefined;
 
 describe('default Standard PBR transmission manifest contract', () => {
-  it('publishes both TRANSMISSION_AVAILABLE variants from the cooked producer', {
+  it('publishes every supported capability combination including transmission', {
     timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
@@ -38,63 +38,14 @@ describe('default Standard PBR transmission manifest contract', () => {
 
     expect(standard).toBeDefined();
     if (standard === undefined) return;
-    const transmissionVariants = standard.variants.filter(
-      (variant) => 'TRANSMISSION_AVAILABLE' in variant.defines,
-    );
-    // The producer emits the complete supported Cartesian product. Storage is
-    // required for cluster/probe/extended-lighting variants, and extended
-    // lighting additionally requires the projector texture lane. Keep the
-    // expected keys derived here so adding a new axis cannot silently shrink
-    // the published set.
-    const expectedKeys = new Set<string>();
-    for (const clusterForwardAvailable of [false, true]) {
-      for (const storageBufferAvailable of [false, true]) {
-        for (const vertexColorAvailable of [false, true]) {
-          for (const probeBlendAvailable of [false, true]) {
-            for (const extendedLightingAvailable of [false, true]) {
-              for (const directionalPcssAvailable of [false, true]) {
-                for (const transmissionAvailable of [false, true]) {
-                  for (const projectorAvailable of [false, true]) {
-                    for (const reflectionFallbackAvailable of [false, true]) {
-                      if (
-                        (clusterForwardAvailable && !storageBufferAvailable) ||
-                        (probeBlendAvailable && !storageBufferAvailable) ||
-                        (extendedLightingAvailable &&
-                          (!storageBufferAvailable || !projectorAvailable))
-                      ) {
-                        continue;
-                      }
-                      const expectedKeyEntries = [
-                        `CLUSTER_FORWARD_AVAILABLE=${clusterForwardAvailable}`,
-                        `DIRECTIONAL_PCSS_AVAILABLE=${directionalPcssAvailable}`,
-                        `EXTENDED_LIGHTING_AVAILABLE=${extendedLightingAvailable}`,
-                        `PROBE_BLEND_AVAILABLE=${probeBlendAvailable}`,
-                        `PROJECTOR_AVAILABLE=${projectorAvailable}`,
-                        `REFLECTION_FALLBACK_AVAILABLE=${reflectionFallbackAvailable}`,
-                        `STORAGE_BUFFER_AVAILABLE=${storageBufferAvailable}`,
-                        `TRANSMISSION_AVAILABLE=${transmissionAvailable}`,
-                        `VERTEX_COLOR_AVAILABLE=${vertexColorAvailable}`,
-                      ];
-                      expectedKeys.add(
-                        expectedKeyEntries.every((entry) => entry.endsWith('=true'))
-                          ? ''
-                          : expectedKeyEntries.join('+'),
-                      );
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    expect(transmissionVariants).toHaveLength(expectedKeys.size);
-    expect(new Set(transmissionVariants.map((variant) => variant.definesKey))).toEqual(
-      expectedKeys,
-    );
+    // Nine declared axes produce 512 combinations. The compiler publishes
+    // the supported subset: storage is required by cluster/probe/extended
+    // lighting, and extended lighting also requires the projector lane.
+    expect(standard.variants).toHaveLength(224);
+    expect(new Set(standard.variants.map((variant) => variant.definesKey)).size).toBe(224);
+    expect(new Set(standard.variants.map((variant) => variant.composedWgsl)).size).toBe(224);
     expect(
-      transmissionVariants.every(
+      standard.variants.every(
         (variant) =>
           !(
             variant.defines.CLUSTER_FORWARD_AVAILABLE === true &&
@@ -111,67 +62,12 @@ describe('default Standard PBR transmission manifest contract', () => {
           ),
       ),
     ).toBe(true);
-    for (const clusterForwardAvailable of [false, true]) {
-      for (const storageBufferAvailable of [false, true]) {
-        if (clusterForwardAvailable && !storageBufferAvailable) continue;
-        for (const vertexColorAvailable of [false, true]) {
-          for (const probeBlendAvailable of [false, true]) {
-            for (const extendedLightingAvailable of [false, true]) {
-              for (const directionalPcssAvailable of [false, true]) {
-                for (const transmissionAvailable of [false, true]) {
-                  for (const projectorAvailable of [false, true]) {
-                    for (const reflectionFallbackAvailable of [false, true]) {
-                      if (
-                        (probeBlendAvailable && !storageBufferAvailable) ||
-                        (extendedLightingAvailable &&
-                          (!storageBufferAvailable || !projectorAvailable))
-                      ) {
-                        continue;
-                      }
-                      const expectedKeyEntries = [
-                        `CLUSTER_FORWARD_AVAILABLE=${clusterForwardAvailable}`,
-                        `DIRECTIONAL_PCSS_AVAILABLE=${directionalPcssAvailable}`,
-                        `EXTENDED_LIGHTING_AVAILABLE=${extendedLightingAvailable}`,
-                        `PROBE_BLEND_AVAILABLE=${probeBlendAvailable}`,
-                        `PROJECTOR_AVAILABLE=${projectorAvailable}`,
-                        `REFLECTION_FALLBACK_AVAILABLE=${reflectionFallbackAvailable}`,
-                        `STORAGE_BUFFER_AVAILABLE=${storageBufferAvailable}`,
-                        `TRANSMISSION_AVAILABLE=${transmissionAvailable}`,
-                        `VERTEX_COLOR_AVAILABLE=${vertexColorAvailable}`,
-                      ];
-                      const expectedKey = expectedKeyEntries.every((entry) =>
-                        entry.endsWith('=true'),
-                      )
-                        ? ''
-                        : expectedKeyEntries.join('+');
-                      expect(transmissionVariants).toContainEqual(
-                        expect.objectContaining({
-                          definesKey: expectedKey,
-                          defines: expect.objectContaining({
-                            CLUSTER_FORWARD_AVAILABLE: clusterForwardAvailable,
-                            DIRECTIONAL_PCSS_AVAILABLE: directionalPcssAvailable,
-                            EXTENDED_LIGHTING_AVAILABLE: extendedLightingAvailable,
-                            PROBE_BLEND_AVAILABLE: probeBlendAvailable,
-                            PROJECTOR_AVAILABLE: projectorAvailable,
-                            REFLECTION_FALLBACK_AVAILABLE: reflectionFallbackAvailable,
-                            STORAGE_BUFFER_AVAILABLE: storageBufferAvailable,
-                            TRANSMISSION_AVAILABLE: transmissionAvailable,
-                            VERTEX_COLOR_AVAILABLE: vertexColorAvailable,
-                          }),
-                        }),
-                      );
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
+    expect(standard.variants.every((variant) => 'TRANSMISSION_AVAILABLE' in variant.defines)).toBe(
+      true,
+    );
   });
 
-  it('omits transmission-only texture bindings from the fallback variant', {
+  it('omits transmission and physical resources from the non-transmission fallback variant', {
     timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
@@ -190,23 +86,34 @@ describe('default Standard PBR transmission manifest contract', () => {
         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.EXTENDED_LIGHTING_AVAILABLE === false &&
-        variant.defines.PROBE_BLEND_AVAILABLE === false &&
-        variant.defines.TRANSMISSION_AVAILABLE === true &&
-        variant.defines.VERTEX_COLOR_AVAILABLE === false,
+    expect(fallback).toBeDefined();
+    if (fallback === undefined) return;
+    expect(fallback.composedWgsl).not.toMatch(
+      /var(?:<[^>]+>)?\s+(?:transmissionSampler|transmissionTexture|thicknessSampler|thicknessTexture|clearcoatTexture|clearcoatRoughnessTexture|clearcoatNormalTexture|anisotropyTexture|sheenColorTexture|sheenRoughnessTexture|iridescenceTexture|iridescenceThicknessTexture|specularTexture)\b/u,
     );
-    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', {
+  it('publishes the same explicit transmission axis for the skin Standard template', {
     timeout: 60_000,
+  }, async () => {
+    const manifest = await engineManifest();
+    const skin = manifest.materialShaders.find((entry) => entry.identifier === 'forgeax::pbr-skin');
+    expect(skin).toBeDefined();
+    if (skin === undefined) return;
+    expect(skin.variants.length).toBeGreaterThan(0);
+    expect(skin.variants.every((variant) => 'TRANSMISSION_AVAILABLE' in variant.defines)).toBe(
+      true,
+    );
+    expect(skin.variants.some((variant) => variant.defines.TRANSMISSION_AVAILABLE === false)).toBe(
+      true,
+    );
+    expect(skin.variants.some((variant) => variant.defines.TRANSMISSION_AVAILABLE === true)).toBe(
+      true,
+    );
+  });
+
+  it('registers one Standard row and resolves a declared capability variant by exact key', {
+    timeout: 20_000,
   }, async () => {
     const manifest = await engineManifest();
     const standard = manifest.materialShaders.find(
@@ -229,38 +136,13 @@ describe('default Standard PBR transmission manifest contract', () => {
     expect(registered).toBeDefined();
     if (registered === undefined) return;
 
-    const transmission = registered.variants.find(
-      (variant) => variant.defines.TRANSMISSION_AVAILABLE === true,
+    const variant = registered.variants.find(
+      (candidate) => candidate.defines.CLUSTER_FORWARD_AVAILABLE === false,
     );
-    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);
+    expect(variant).toBeDefined();
+    if (variant === undefined) return;
+    expect(findVariantByKey(registered, variant.definesKey)).toBe(variant);
+    expect(findVariantByKey(registered, `${variant.definesKey}+UNDECLARED=true`)).toBeUndefined();
   });
 
   it('rejects duplicate variant keys instead of allowing ambiguous prewarm', async () => {
@@ -271,14 +153,14 @@ describe('default Standard PBR transmission manifest contract', () => {
       paramSchema: '[]',
       variants: [
         {
-          definesKey: 'TRANSMISSION_AVAILABLE=true',
-          defines: { TRANSMISSION_AVAILABLE: true },
-          composedWgsl: 'standard-transmission-a',
+          definesKey: 'CLUSTER_FORWARD_AVAILABLE=false',
+          defines: { CLUSTER_FORWARD_AVAILABLE: false },
+          composedWgsl: 'standard-a',
         },
         {
-          definesKey: 'TRANSMISSION_AVAILABLE=true',
-          defines: { TRANSMISSION_AVAILABLE: true },
-          composedWgsl: 'standard-transmission-b',
+          definesKey: 'CLUSTER_FORWARD_AVAILABLE=false',
+          defines: { CLUSTER_FORWARD_AVAILABLE: false },
+          composedWgsl: 'standard-b',
         },
       ],
     };

package/src/__tests__/deferred-lighting-ssao.test.ts

@@ -51,12 +51,12 @@ function stripComments(src: string): string {
 
 describe('deferred lighting ambient SSAO synthesis (M2 / w11)', () => {
   it('(a) ambient calculation uses occlusionStrength * bakedAO texture sample', () => {
-    // The ambient expression starts from kD * irradiance before clearcoat and
-    // skylight terms are applied; ao comes from material.occlusionStrength.
+    // The ambient expression starts from kD * irradiance before skylight terms
+    // are applied; ao comes from material.occlusionStrength.
     // M7/w32 changed `let` -> `var` so the SSAO blend line `ambient *= mix(...)` can mutate it.
     const codeOnly = stripComments(pbrSource);
     expect(codeOnly).toMatch(/var\s+ambient\s*=\s*\(*\s*kD\s*\*\s*irradiance/);
-    expect(codeOnly).toMatch(/material\.occlusionStrength/);
+    expect(codeOnly).toMatch(/surface\.occlusion/);
     expect(codeOnly).toMatch(/skylight\.intensity/);
   });
 

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

@@ -43,4 +43,13 @@ describe('IBL irradiance payload contract', () => {
     expect(diffuseRadiance).toBeCloseTo(environment, 12);
     expect(Number.isFinite(diffuseRadiance)).toBe(true);
   });
+
+  it('rejects NaN and infinity before a sample reaches the accumulation sum', () => {
+    expect(irradianceSource).toMatch(/const IRRADIANCE_SAMPLE_DELTA:\s*f32\s*=\s*0\.05/);
+    expect(irradianceSource).toContain('fn irradianceFiniteScalar');
+    expect(irradianceSource).toContain('abs(value) <= 65504.0');
+    expect(irradianceSource).toMatch(
+      /irradianceFiniteVec3\(sampleVec\)[\s\S]*irradianceFiniteVec3\(sampleColor\)[\s\S]*irradianceFiniteScalar\(sampleWeight\)/,
+    );
+  });
 });

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

@@ -0,0 +1,36 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+
+const source = readFileSync(new URL('../lighting-directional.wgsl', import.meta.url), 'utf8');
+
+type Vec3 = readonly [number, number, number];
+
+function unsafeNormalize(value: Vec3): Vec3 {
+  const length = Math.hypot(value[0], value[1], value[2]);
+  return [value[0] / length, value[1] / length, value[2] / length];
+}
+
+function directionalHalfVector(viewDir: Vec3, lightDir: Vec3): Vec3 {
+  const sum: Vec3 = [viewDir[0] + lightDir[0], viewDir[1] + lightDir[1], viewDir[2] + lightDir[2]];
+  const lengthSquared = Math.max(sum[0] ** 2 + sum[1] ** 2 + sum[2] ** 2, 1e-8);
+  const inverseLength = 1 / Math.sqrt(lengthSquared);
+  return [sum[0] * inverseLength, sum[1] * inverseLength, sum[2] * inverseLength];
+}
+
+describe('directional GGX half-vector boundary', () => {
+  it('reproduces the old normalize zero-vector failure', () => {
+    const halfVector: Vec3 = [0, 0, 0];
+    expect(unsafeNormalize(halfVector).some((value) => !Number.isFinite(value))).toBe(true);
+  });
+
+  it.each([
+    ['anti-parallel', [0, 0, 1] as const, [0, 0, -1] as const],
+    ['near anti-parallel', [0, 0, 1] as const, [1e-5, 0, -1] as const],
+  ])('%s inputs remain finite in evalDirectionalNoShadow', (_name, viewDir, lightDir) => {
+    expect(directionalHalfVector(viewDir, lightDir).every(Number.isFinite)).toBe(true);
+  });
+
+  it('uses a finite lower bound for the half-vector length', () => {
+    expect(source).toContain('max(dot(halfVector, halfVector), 1e-8)');
+  });
+});

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

@@ -8,6 +8,10 @@ const standardClusterShaderPath = join(
   dirname(fileURLToPath(import.meta.url)),
   '../standard-cluster.wgsl',
 );
+const spotProjectorShaderPath = join(
+  dirname(fileURLToPath(import.meta.url)),
+  '../lighting-spot-projector.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(
@@ -83,13 +87,16 @@ describe('direct punctual lighting shader contract', () => {
   });
 
   it('keeps the unshadowed spot sentinel out of the projector flag branch', async () => {
-    const source = await readFile(standardClusterShaderPath, 'utf8');
+    const [source, projector] = await Promise.all([
+      readFile(standardClusterShaderPath, 'utf8'),
+      readFile(spotProjectorShaderPath, '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(
+    expect(projector).toContain(
       'textureSampleLevel(cookieTexture, spotModifierSampler, uv, metadata.w, 0.0).rgb',
     );
   });
@@ -98,9 +105,10 @@ describe('direct punctual lighting shader contract', () => {
     const source = await readFile(pbrShaderPath, 'utf8');
 
     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,
+      /evaluateStandardClusterLights\(\s*in\.ndc\.xyz,\s*standardViewZ\(in\),\s*in\.worldPos,\s*physicalNormal,\s*v,\s*diffuseAlbedo,\s*metallic,\s*a,\s*f0,\s*false,?\s*\)/u,
     );
-    expect(source).toContain('coatAlpha, vec3<f32>(0.04)');
+    expect(source).toContain('clearcoatAlpha,');
+    expect(source).toContain('vec3<f32>(0.04),');
   });
 
   it('requires one shared Directional PCSS orchestration owner', async () => {

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

@@ -83,8 +83,6 @@ describe('built-in MaterialAsset sources', () => {
       'metallicRoughnessTexture',
       'normalSampler',
       'normalTexture',
-      'specularTintSampler',
-      'specularTintTexture',
       'emissiveSampler',
       'emissiveTexture',
       'occlusionSampler',
@@ -104,6 +102,13 @@ describe('built-in MaterialAsset sources', () => {
     expect(text).toContain('@binding(13) var transmissionSampler');
     expect(text).toContain('@binding(16) var thicknessTexture');
     expect(text).toContain('@binding(17) var irradianceMap');
+    expect(text).toMatch(
+      /#ifdef SPECULAR_COLOR_TEXTURE_AVAILABLE\s+@group\(1\) @binding\(44\) var specularColorTextureSampler/u,
+    );
+    expect(text).toMatch(
+      /#ifdef SPECULAR_COLOR_TEXTURE_AVAILABLE[\s\S]*?@group\(1\) @binding\(45\) var specularColorTexture/u,
+    );
+    expect(text).not.toMatch(/@binding\((?:7|8)\) var specularColorTexture/u);
   });
 });
 
@@ -116,7 +121,20 @@ describe('built-in and custom material derived layout matrix', () => {
     expect(names).toContain('thicknessTexture');
     expect(
       DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) => entry.type === 'texture2d'),
-    ).toHaveLength(8);
+    ).toHaveLength(17);
+    expect(names).toEqual(
+      expect.arrayContaining([
+        'clearcoatTexture',
+        'clearcoatRoughnessTexture',
+        'clearcoatNormalTexture',
+        'anisotropyTexture',
+        'sheenColorTexture',
+        'sheenRoughnessTexture',
+        'iridescenceTexture',
+        'iridescenceThicknessTexture',
+        'specularTexture',
+      ]),
+    );
   });
 
   it('derives a coordinate record for every texture parameter in an interleaved custom schema', () => {