@forgeax/engine-shader 0.1.21 → 0.1.23

package/dist/ltc/provenance.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The table source is the Three.js r184 RectAreaLight implementation. The
+ * source arrays are converted to IEEE-754 binary16 offline and checked into
+ * `tables.ts`; the runtime never fetches or parses a source file.
+ */
+export declare const LTC_SOURCE_PROVENANCE: {
+    readonly source: "Three.js";
+    readonly revision: "r184";
+    readonly sourceUrl: "https://github.com/mrdoob/three.js/blob/r184/examples/jsm/lights/RectAreaLightTexturesLib.js";
+    readonly upstreamData: "selfshadow/ltc_code fit/results/ltc.js";
+    readonly generator: "deterministic Three.js source-array to rgba16float conversion";
+    readonly inputSha256: {
+        readonly lambert: "cf5cf21e5c112d2095c7e2418cb0a1ac54636e275d73e42f3453646c67f26814";
+        readonly ggx: "3b1b09080b26104498db277c14fc1733786465c6958e7a8403d688b1e24c2ff5";
+    };
+};
+//# sourceMappingURL=provenance.d.ts.map

package/dist/ltc/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../src/ltc/provenance.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;CAWxB,CAAC"}

package/dist/ltc/tables.d.ts

@@ -0,0 +1,22 @@
+import { LTC_SOURCE_PROVENANCE } from './provenance';
+export { LTC_SOURCE_PROVENANCE };
+export declare const LTC_TABLE_WIDTH = 64;
+export declare const LTC_TABLE_HEIGHT = 64;
+export declare const LTC_TABLES: {
+    readonly lambert: Uint16Array<ArrayBuffer>;
+    readonly ggx: Uint16Array<ArrayBuffer>;
+};
+export declare const LTC_TABLE_HASHES: {
+    readonly lambert: "a391de32f868fd4aa8774917b793174b7be804c08e2fb8924c30f31d7aa8dcd7";
+    readonly ggx: "fa1ecbc6deb3c85ddf603cdf1e98e30279444f905eb1cebb849d761b570dd696";
+};
+export declare const LTC_TABLE_INPUT_HASHES: {
+    readonly lambert: "cf5cf21e5c112d2095c7e2418cb0a1ac54636e275d73e42f3453646c67f26814";
+    readonly ggx: "3b1b09080b26104498db277c14fc1733786465c6958e7a8403d688b1e24c2ff5";
+};
+export declare function generateLtcTables(): {
+    lambert: Uint16Array;
+    ggx: Uint16Array;
+};
+export declare function hashLtcTable(table: Uint16Array): string;
+//# sourceMappingURL=tables.d.ts.map

package/dist/ltc/tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../src/ltc/tables.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAorFnC,eAAO,MAAM,UAAU;;;CAAkD,CAAC;AAC1E,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AACX,eAAO,MAAM,sBAAsB;;;CAAoC,CAAC;AAExE,wBAAgB,iBAAiB,IAAI;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,CAE9E;AAwED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAEvD"}

package/dist/material/artifact-types.d.ts

@@ -1,13 +1,65 @@
 import type { BindGroupLayoutDescriptor } from '@forgeax/engine-types';
+export interface MaterialShaderResourceSlot {
+    readonly name: string;
+    readonly parameter: string;
+    readonly kind: 'sampler' | 'texture';
+    readonly group: number;
+    readonly binding: number;
+}
+export interface MaterialShaderVertexInput {
+    readonly semantic: string;
+    readonly location: number;
+    readonly format: string;
+}
+export interface MaterialShaderArtifactReceipt {
+    readonly directEntry: string;
+    readonly sceneIndexEntry: string;
+    readonly materialRow: {
+        readonly byteLength: number;
+        readonly fields: readonly string[];
+    };
+    readonly resourceSlots: readonly MaterialShaderResourceSlot[];
+    readonly uvSets: readonly {
+        readonly parameter: string;
+        readonly set: number;
+    }[];
+    readonly vertexInputs: readonly MaterialShaderVertexInput[];
+    readonly alphaMask: {
+        readonly cutoff: string;
+        readonly source: string;
+    };
+    readonly skinPaletteAddress?: {
+        readonly group: number;
+        readonly binding: number;
+        readonly stride: number;
+    };
+    readonly reflection: {
+        readonly layoutIdentity: string;
+        readonly resourceSlots: readonly MaterialShaderResourceSlot[];
+        readonly vertexInputs: readonly MaterialShaderVertexInput[];
+    };
+    readonly receiptIdentity: string;
+    readonly generation: number;
+}
 export interface MaterialShaderArtifact {
     readonly material: string;
     readonly pass: string;
     readonly wgsl: string;
     readonly layoutIdentity: string;
+    /** Naga-reflected UV set count used to derive clamp-to-last vertex aliases. */
+    readonly uvSetCount?: number;
     readonly bindings: readonly BindGroupLayoutDescriptor[];
     readonly deps: readonly string[];
     readonly vertexInputs: readonly Readonly<Record<string, unknown>>[];
     readonly specializationKey?: string;
+    /** Producer-owned ABI facts shared by direct and scene-index consumers. */
+    readonly receipt?: MaterialShaderArtifactReceipt;
 }
+/**
+ * Builds the one Standard PBR ABI receipt consumed by both material lanes.
+ * The skinned module uses the same material producer and only adds its palette
+ * address; it must retain the same receipt identity for material compatibility.
+ */
+export declare function createStandardPbrArtifactReceipt(skinned?: boolean): MaterialShaderArtifactReceipt;
 export declare function isMaterialShaderArtifact(value: unknown): value is MaterialShaderArtifact;
 //# sourceMappingURL=artifact-types.d.ts.map

package/dist/material/artifact-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifact-types.d.ts","sourceRoot":"","sources":["../../src/material/artifact-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAEvE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,SAAS,yBAAyB,EAAE,CAAC;IACxD,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IACpE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAYxF"}
+{"version":3,"file":"artifact-types.d.ts","sourceRoot":"","sources":["../../src/material/artifact-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAEvE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE;QACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;KACpC,CAAC;IACF,QAAQ,CAAC,aAAa,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC9D,QAAQ,CAAC,MAAM,EAAE,SAAS;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACjF,QAAQ,CAAC,YAAY,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAC5D,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE,QAAQ,CAAC,kBAAkB,CAAC,EAAE;QAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,QAAQ,CAAC,UAAU,EAAE;QACnB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;QAChC,QAAQ,CAAC,aAAa,EAAE,SAAS,0BAA0B,EAAE,CAAC;QAC9D,QAAQ,CAAC,YAAY,EAAE,SAAS,yBAAyB,EAAE,CAAC;KAC7D,CAAC;IACF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,yBAAyB,EAAE,CAAC;IACxD,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IACpE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,6BAA6B,CAAC;CAClD;AA8DD;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,UAAQ,GAAG,6BAA6B,CA2B/F;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAYxF"}

package/dist/material-schemas.d.ts

@@ -1,7 +1,12 @@
 import type { ParamSchemaEntry } from '@forgeax/engine-types';
+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[];
+/** 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. */
+export declare const STANDARD_PBR_SKIN_ARTIFACT_RECEIPT: MaterialShaderArtifactReceipt;
 export declare const DEFAULT_UNLIT_PARAM_SCHEMA: readonly ParamSchemaEntry[];
 export declare const DEFAULT_SPRITE_PARAM_SCHEMA: readonly ParamSchemaEntry[];
 export declare const DEFAULT_MSDF_TEXT_PARAM_SCHEMA: readonly ParamSchemaEntry[];

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;AAE9D,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAEnD,6EAA6E;AAC7E,eAAO,MAAM,iCAAiC,EAAE,SAAS,gBAAgB,EA6BxE,CAAC;AAEF,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;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"}

package/dist/register-default-sprite-lit.d.ts

@@ -22,12 +22,9 @@ export interface SpriteLitCaps {
  * compiled by @forgeax/engine-vite-plugin-shader at build time and surfaced
  * in manifest.json. The caller reads it from the manifest entries.
  *
- * `caps.storageBuffer` switches the runtime BGL buffer types for
- * @group(0) bindings 1+2 (pointLightsBuffer / spotLightsBuffer):
- * `false` -> uniform fallback (AC-10 WebGL2 path); `true` -> read-only-storage.
- * The BGL itself is built downstream in runtime/pbr-pipeline.ts (sprite-lit
- * reuses pbr-view / pbr-mesh-array / pbr-instances unchanged; AC-07
- * BGL byte-identical).
+ * `caps.storageBuffer` is retained for the shared mesh/instance layout
+ * selection. Sprite-lit local lighting reads the same Standard Cluster group
+ * as PBR; the view group has no direct point/spot arrays.
  *
  * @param registry ShaderRegistry instance (engine boot path).
  * @param composedWgsl Post-naga_oil composed WGSL source string.

package/dist/register-default-sprite-lit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register-default-sprite-lit.d.ts","sourceRoot":"","sources":["../src/register-default-sprite-lit.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAiBjD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,aAAa,GAClB,IAAI,CAUN"}
+{"version":3,"file":"register-default-sprite-lit.d.ts","sourceRoot":"","sources":["../src/register-default-sprite-lit.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAiBjD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,cAAc,EACxB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,aAAa,GAClB,IAAI,CAUN"}

package/dist/types.d.ts

@@ -11,6 +11,7 @@
  * no longer carry a bindingLayout sidecar (§Change stance: no v1/v2
  * dual-path, no incremental drop window).
  */
+import type { MaterialShaderArtifactReceipt } from './material/artifact-types.js';
 export interface MaterialShaderManifestVariant {
     readonly definesKey: string;
     readonly defines: Record<string, boolean>;
@@ -26,7 +27,7 @@ export interface MaterialShaderManifestVariant {
  *
  * For Engine.create() internal use only; AI users never see this type.
  */
-export interface MaterialShaderManifestEntry {
+export interface MaterialShaderManifestEntry extends Partial<MaterialShaderArtifactReceipt> {
     readonly identifier: string;
     readonly sourcePath: string;
     readonly composedWgsl: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,6BAA6B,EAAE,CAAC;IAC5D;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,2BAA2B,EAClC,UAAU,EAAE,MAAM,GACjB,6BAA6B,GAAG,SAAS,CAE3C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC;AAClF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,2BAA4B,SAAQ,OAAO,CAAC,6BAA6B,CAAC;IACzF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,6BAA6B,EAAE,CAAC;IAC5D;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,2BAA2B,EAClC,UAAU,EAAE,MAAM,GACjB,6BAA6B,GAAG,SAAS,CAE3C"}

package/package.json

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

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

@@ -19,13 +19,17 @@ function device(): ShaderRegistryDevice {
 }
 
 async function engineManifest(): Promise<EngineShaderManifest> {
-  const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
-  return buildEngineShaderManifest();
+  engineManifestPromise ??= import('@forgeax/engine-vite-plugin-shader').then(
+    ({ buildEngineShaderManifest }) => buildEngineShaderManifest(),
+  );
+  return engineManifestPromise;
 }
 
+let engineManifestPromise: Promise<EngineShaderManifest> | undefined;
+
 describe('default Standard PBR transmission manifest contract', () => {
   it('publishes both TRANSMISSION_AVAILABLE variants from the cooked producer', {
-    timeout: 20_000,
+    timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
     const standard = manifest.materialShaders.find(
@@ -37,39 +41,73 @@ describe('default Standard PBR transmission manifest contract', () => {
     const transmissionVariants = standard.variants.filter(
       (variant) => 'TRANSMISSION_AVAILABLE' in variant.defines,
     );
-    // Cluster-forward + storage-fallback is not a valid ABI pair: the
-    // clustered Standard group(2) requires storage buffers. The producer
-    // emits the six-axis Cartesian product minus those sixteen impossible
-    // combinations, i.e. 48 exact variants.
-    expect(transmissionVariants).toHaveLength(48);
-    expect(new Set(transmissionVariants.map((variant) => variant.definesKey)).size).toBe(48);
-    // Projector sampling is owned by the shared Cluster module. The
-    // non-cluster capability rows intentionally have no projector consumer
-    // after the direct-light/fallback cut, so their true/false projector keys
-    // alias one source instead of carrying duplicate WGSL. The 16 non-cluster
-    // pairs therefore collapse 48 logical keys to 32 source identities.
-    expect(new Set(transmissionVariants.map((variant) => variant.composedWgsl)).size).toBe(32);
-    const nonClusterPairs = transmissionVariants.filter(
-      (variant) => variant.defines.CLUSTER_FORWARD_AVAILABLE === false,
-    );
-    for (const variant of nonClusterPairs) {
-      const projectorTwin = nonClusterPairs.find(
-        (candidate) =>
-          candidate.defines.STORAGE_BUFFER_AVAILABLE === variant.defines.STORAGE_BUFFER_AVAILABLE &&
-          candidate.defines.TRANSMISSION_AVAILABLE === variant.defines.TRANSMISSION_AVAILABLE &&
-          candidate.defines.VERTEX_COLOR_AVAILABLE === variant.defines.VERTEX_COLOR_AVAILABLE &&
-          candidate.defines.DIRECTIONAL_PCSS_AVAILABLE ===
-            variant.defines.DIRECTIONAL_PCSS_AVAILABLE &&
-          candidate.defines.PROJECTOR_AVAILABLE !== variant.defines.PROJECTOR_AVAILABLE,
-      );
-      expect(projectorTwin?.composedWgsl).toBe(variant.composedWgsl);
+    // 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,
+    );
     expect(
       transmissionVariants.every(
         (variant) =>
           !(
             variant.defines.CLUSTER_FORWARD_AVAILABLE === true &&
             variant.defines.STORAGE_BUFFER_AVAILABLE === false
+          ) &&
+          !(
+            variant.defines.PROBE_BLEND_AVAILABLE === true &&
+            variant.defines.STORAGE_BUFFER_AVAILABLE === false
+          ) &&
+          !(
+            variant.defines.EXTENDED_LIGHTING_AVAILABLE === true &&
+            (variant.defines.STORAGE_BUFFER_AVAILABLE === false ||
+              variant.defines.PROJECTOR_AVAILABLE === false)
           ),
       ),
     ).toBe(true);
@@ -77,33 +115,54 @@ describe('default Standard PBR transmission manifest contract', () => {
       for (const storageBufferAvailable of [false, true]) {
         if (clusterForwardAvailable && !storageBufferAvailable) continue;
         for (const vertexColorAvailable of [false, true]) {
-          for (const directionalPcssAvailable of [false, true]) {
-            for (const transmissionAvailable of [false, true]) {
-              for (const projectorAvailable of [false, true]) {
-                const expectedKeyEntries = [
-                  `CLUSTER_FORWARD_AVAILABLE=${clusterForwardAvailable}`,
-                  `DIRECTIONAL_PCSS_AVAILABLE=${directionalPcssAvailable}`,
-                  `PROJECTOR_AVAILABLE=${projectorAvailable}`,
-                  `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,
-                      PROJECTOR_AVAILABLE: projectorAvailable,
-                      STORAGE_BUFFER_AVAILABLE: storageBufferAvailable,
-                      TRANSMISSION_AVAILABLE: transmissionAvailable,
-                      VERTEX_COLOR_AVAILABLE: vertexColorAvailable,
-                    }),
-                  }),
-                );
+          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,
+                          }),
+                        }),
+                      );
+                    }
+                  }
+                }
               }
             }
           }
@@ -113,7 +172,7 @@ describe('default Standard PBR transmission manifest contract', () => {
   });
 
   it('omits transmission-only texture bindings from the fallback variant', {
-    timeout: 20_000,
+    timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
     const standard = manifest.materialShaders.find(
@@ -126,6 +185,8 @@ describe('default Standard PBR transmission manifest contract', () => {
       (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 === false &&
         variant.defines.VERTEX_COLOR_AVAILABLE === false,
     );
@@ -133,6 +194,8 @@ describe('default Standard PBR transmission manifest contract', () => {
       (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,
     );
@@ -143,7 +206,7 @@ describe('default Standard PBR transmission manifest contract', () => {
   });
 
   it('registers one Standard row and resolves a declared variant by exact key', {
-    timeout: 20_000,
+    timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
     const standard = manifest.materialShaders.find(

package/src/__tests__/direct-light-layout.unit.test.ts

@@ -0,0 +1,40 @@
+import { readFile } from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+
+async function readShader(name: string): Promise<string> {
+  return readFile(new URL(`../${name}`, import.meta.url), 'utf8');
+}
+
+describe('DirectLightSlot WGSL ABI', () => {
+  it('declares the canonical five-row 80-byte slot', async () => {
+    const common = await readShader('common.wgsl');
+    const match = common.match(/struct DirectLightSlot\s*\{([\s\S]*?)\};/);
+
+    expect(match).not.toBeNull();
+    const struct = match?.[1] ?? '';
+    expect(struct.match(/vec4<f32>/g)).toHaveLength(4);
+    expect(struct.match(/vec4<u32>/g)).toHaveLength(1);
+    expect(struct).toContain('row0');
+    expect(struct).toContain('row1');
+    expect(struct).toContain('row2');
+    expect(struct).toContain('row3');
+    expect(struct).toContain('metadata : vec4<u32>');
+    expect(common).not.toContain('struct DirectLightArray');
+    expect(common).not.toContain('array<DirectLightSlot, 4>');
+    expect(common).toContain('@group(0) @binding(0)');
+  });
+
+  it('keeps the slot type owned by the unified Cluster shader consumer', async () => {
+    const common = await readShader('common.wgsl');
+    const standard = await readShader('default-standard-pbr.wgsl');
+    const clustered = await readShader('standard-cluster.wgsl');
+
+    expect(common).toContain('struct DirectLightSlot');
+    expect(standard).not.toContain('DirectLightSlot');
+    expect(standard).not.toContain('pointLightsBuffer');
+    expect(standard).not.toContain('spotLightsBuffer');
+    expect(clustered).toContain('DirectLightSlot');
+    expect(clustered).toContain('array<DirectLightSlot, 256>');
+    expect(clustered).not.toContain('struct LightSlot');
+  });
+});

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,14 @@ 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', () => {

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

@@ -9,6 +9,7 @@ const standardClusterShaderPath = join(
   '../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',
@@ -42,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(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');
@@ -57,7 +78,7 @@ describe('direct punctual lighting shader contract', () => {
   it('decodes HDRP spot cone lanes in the shared evaluator order', async () => {
     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');
   });
 
@@ -65,6 +86,12 @@ describe('direct punctual lighting shader contract', () => {
     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 () => {

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