@forgeax/engine-shader 0.1.21 → 0.1.24

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,43 @@
 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[];
+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. */
+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;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/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.24",
   "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.24",
+    "@forgeax/engine-types": "0.1.24",
     "@webgpu/types": "^0.1.71"
   },
   "devDependencies": {
-    "@forgeax/engine-vite-plugin-shader": "0.1.21"
+    "@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

@@ -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,
+  it('publishes every supported capability combination including transmission', {
+    timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
     const standard = manifest.materialShaders.find(
@@ -34,86 +38,37 @@ 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,
-    );
-    // 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);
-    }
+    // 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 &&
             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);
-    for (const clusterForwardAvailable of [false, true]) {
-      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,
-                    }),
-                  }),
-                );
-              }
-            }
-          }
-        }
-      }
-    }
+    expect(standard.variants.every((variant) => 'TRANSMISSION_AVAILABLE' in variant.defines)).toBe(
+      true,
+    );
   });
 
-  it('omits transmission-only texture bindings from the fallback variant', {
-    timeout: 20_000,
+  it('omits transmission and physical resources from the non-transmission fallback variant', {
+    timeout: 60_000,
   }, async () => {
     const manifest = await engineManifest();
     const standard = manifest.materialShaders.find(
@@ -126,23 +81,38 @@ 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,
     );
-    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).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,
+    );
+  });
+
+  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,
     );
-    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('registers one Standard row and resolves a declared capability variant by exact key', {
     timeout: 20_000,
   }, async () => {
     const manifest = await engineManifest();
@@ -166,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 () => {
@@ -208,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__/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,17 +27,29 @@ 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);
   });
+
+  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\)/,
+    );
+  });
 });