@forgeax/engine-runtime 0.1.6 → 0.1.19

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

@@ -2232,10 +2232,11 @@ function spawnValidatedLight(
     //
     // visibility flags mirror the WebGPU GPUShaderStage bitmask:
     //   VERTEX = 0x1, FRAGMENT = 0x2.
+    const VISIBILITY_VERTEX = 0x1;
     const VISIBILITY_FRAGMENT = 0x2;
     const VISIBILITY_VERTEX_FRAGMENT = 0x1 | 0x2;
 
-    describe('binding 8 = spotShadowMap (D-5 always-on, last view-BG entry)', () => {
+    describe('binding 8 = spotShadowMap (D-5 always-on shadow entry)', () => {
       it('declares binding 8 as a depth 2D texture, FRAGMENT-only', () => {
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         const b8 = entries.find((e) => e.binding === 8);
@@ -2253,10 +2254,12 @@ function spawnValidatedLight(
         expect(noStorage.some((e) => e.binding === 8)).toBe(true);
       });
 
-      it('binding 8 is the last entry (no binding 9)', () => {
+      it('reserves binding 9 and keeps Points/Lines at binding 10', () => {
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         expect(entries.some((e) => e.binding === 9)).toBe(false);
-        expect(entries.some((e) => e.binding === 10)).toBe(false);
+        const pointsLines = entries.find((e) => e.binding === 10);
+        expect(pointsLines?.buffer?.type).toBe('uniform');
+        expect(pointsLines?.visibility).toBe(VISIBILITY_VERTEX);
       });
     });
 
@@ -2272,18 +2275,19 @@ function spawnValidatedLight(
     // UBO (binding 0). This block locks that the spot matrices add ZERO new view
     // BGL buffer bindings (the WebGL2 budget invariant).
     describe('spotLightViewProj folded into View UBO (binding 0), not a new binding', () => {
-      it('view BGL declares no uniform buffer beyond binding 7 (only binding 0 = view, 6/7 = point/cascade)', () => {
+      it('view BGL includes only the vertex Points/Lines UBO beyond binding 7', () => {
         // Enumerate uniform-buffer entries on the view BGL. After the w25 fold,
-        // the only uniform buffers are binding 0 (View UBO, carries the spot
-        // matrices in its tail), binding 6 (point shadowParams) and binding 7
-        // (shadowCasterCascade). No standalone spot-matrix uniform buffer.
+        // uniform buffers are binding 0 (View UBO, carries the spot matrices
+        // in its tail), binding 6 (point shadowParams), binding 7
+        // (shadowCasterCascade), and binding 10 (Points/Lines view). No
+        // standalone spot-matrix uniform buffer exists.
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         const uniformBufferBindings = entries
           .filter((e) => e.buffer?.type === 'uniform')
           .map((e) => e.binding)
           .sort((a, b) => a - b);
         // storageBuffer=true: bindings 1+2 are read-only-storage (not uniform).
-        expect(uniformBufferBindings).toEqual([0, 6, 7]);
+        expect(uniformBufferBindings).toEqual([0, 6, 7, 10]);
       });
 
       it('storageBuffer=false: WebGL2 fallback uniform-buffer bindings stay within budget', () => {
@@ -2348,12 +2352,12 @@ function spawnValidatedLight(
       });
     });
 
-    describe('full binding roster is contiguous 0..8', () => {
-      it('exposes exactly bindings 0..8 with no gaps (binding 9 folded into View UBO, w25)', () => {
+    describe('full binding roster reserves 9 for Points/Lines at 10', () => {
+      it('exposes bindings 0..8 plus binding 10, with binding 9 reserved', () => {
         const bindings = buildPbrViewBglEntries({ storageBuffer: true })
           .map((e) => e.binding)
           .sort((a, b) => a - b);
-        expect(bindings).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8]);
+        expect(bindings).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]);
       });
     });
   });

package/src/__tests__/material-texture-uv-scale.unit.test.ts

@@ -3,7 +3,6 @@ import { vec3 } from '@forgeax/engine-math';
 import { describe, expect, it } from 'vitest';
 import {
   applyMaterialTextureUvScales,
-  BUILTIN_USER_REGION_TEXTURE_FIELDS,
   buildPbrMaterialUboPayload,
   materialTextureUvScale,
   userRegionTextureFieldOrder,
@@ -22,11 +21,9 @@ describe('material texture UV scale [w37]', () => {
     expect(materialTextureUvScale({ width: 17, height: 9, format: 'rgba8unorm' })).toEqual([1, 1]);
   });
 
-  it('keeps builtin texture slots when compatibility param schemas are empty or numeric-only', () => {
-    expect(userRegionTextureFieldOrder([])).toEqual(BUILTIN_USER_REGION_TEXTURE_FIELDS);
-    expect(userRegionTextureFieldOrder([{ name: 'baseColor', type: 'color' }])).toEqual(
-      BUILTIN_USER_REGION_TEXTURE_FIELDS,
-    );
+  it('keeps compatibility param schemas compact when they have no textures', () => {
+    expect(userRegionTextureFieldOrder([])).toEqual([]);
+    expect(userRegionTextureFieldOrder([{ name: 'baseColor', type: 'color' }])).toEqual([]);
   });
 
   it('writes each slot set and transform into the builtin PBR payload', () => {
@@ -61,8 +58,8 @@ describe('material texture UV scale [w37]', () => {
       new World(),
     );
     const f32 = new Float32Array(payload.buffer, payload.byteOffset, payload.byteLength / 4);
-    expect(Array.from(f32.slice(24, 32))).toEqual([0.125, 0.25, 2, 3, 1, 0.5, 1, 1]);
-    expect(Array.from(f32.slice(40, 48))).toEqual([0.75, 0.25, 4, 5, 0, 0, 1, 1]);
+    expect(Array.from(f32.slice(32, 40))).toEqual([0.125, 0.25, 2, 3, 1, 0.5, 1, 1]);
+    expect(Array.from(f32.slice(48, 56))).toEqual([0.75, 0.25, 4, 5, 0, 0, 1, 1]);
   });
 
   it('keeps identity UV records for metadata-free standard and builtin schema materials', () => {
@@ -85,14 +82,11 @@ describe('material texture UV scale [w37]', () => {
     expect(
       Array.from(
         new Float32Array(standard.buffer, standard.byteOffset, standard.byteLength / 4).slice(
-          24,
-          72,
+          32,
+          96,
         ),
       ),
-    ).toEqual([
-      0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
-      1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
-    ]);
+    ).toEqual(Array.from({ length: 8 }, () => [0, 0, 1, 1, 0, 0, 1, 1]).flat());
 
     const unlit = buildPbrMaterialUboPayload({
       baseColor: vec3.create(1, 1, 1),

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

@@ -197,6 +197,8 @@ describe('Materials.standard multi-pass (w14)', () => {
         { name: 'specularTintTexture', type: 'texture', optional: true },
         { name: 'emissiveTexture', type: 'texture', optional: true },
         { name: 'occlusionTexture', type: 'texture', optional: true },
+        { name: 'transmissionTexture', type: 'texture', optional: true },
+        { name: 'thicknessTexture', type: 'texture', optional: true },
       ]);
     });
 

package/src/__tests__/pbr-pipeline.unit.test.ts

@@ -44,7 +44,7 @@ function makeSpec(): PipelineSpec {
 
 describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', () => {
   describe('pbr-view', () => {
-    it('storageBuffer=true: 9 entries with read-only-storage on bindings 1+2', () => {
+    it('storageBuffer=true: 10 entries with read-only-storage on bindings 1+2', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-view',
@@ -56,12 +56,15 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
       };
       expect(out).toEqual(expected);
       // feat-20260625-spot-light-shadow-mapping: binding 8 (spot shadow atlas,
-      // w14) raised the view BGL to 9 entries (always-on, D-5). w25 (scope-amend
+      // w14) raised the view BGL to 9 entries (always-on, D-5). The
+      // Points/Lines viewport UBO occupies binding 10, while w25 (scope-amend
       // webkit-fallback) folded the former binding 9 spotLightViewProj matrices
       // UBO into the View UBO (`view.spotLightViewProj`), so the BGL stays at 9
-      // entries (bindings 0..8) — keeping the WebGL2 fallback fragment uniform-
+      // entries (bindings 0..8 plus binding 10) — keeping the WebGL2 fallback fragment uniform-
       // buffer count <= 11 (GLES 3.0).
-      expect(out.entries.length).toBe(9);
+      expect(out.entries.length).toBe(10);
+      expect(out.entries.find((entry) => entry.binding === 9)).toBeUndefined();
+      expect(out.entries.find((entry) => entry.binding === 10)?.buffer?.type).toBe('uniform');
     });
 
     it('storageBuffer=false: bindings 1+2 fall back to uniform', () => {
@@ -79,22 +82,22 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('pbr-material-merged', () => {
-    it('24 entries: user-region 13 (derived) + ibl 7 + lightmap 4', () => {
+    it('26 entries: user-region 17 (derived) + ibl 7 + transmission 2', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-material-merged',
       });
       // Post-M2 (D-1): user-region comes from derive(paramSchema).bglEntries
-      // (built-in standard-PBR 4-texture fallback), then IBL + lightmap are
-      // appended at start = userRegion.length.
+      // (built-in standard-PBR 8-texture contract), then IBL + transmission
+      // are appended at start = userRegion.length.
       const userRegion = buildPbrMaterialUserRegionEntries();
       const afterIbl = [...userRegion, ...appendInjection(userRegion, 'ibl')];
       const expected = {
         label: 'pbr-material-skylight-bgl',
-        entries: [...afterIbl, ...appendInjection(afterIbl, 'lightmap')],
+        entries: [...afterIbl, ...appendInjection(afterIbl, 'transmission')],
       };
       expect(out).toEqual(expected);
-      expect(out.entries.length).toBe(24);
+      expect(out.entries.length).toBe(26);
     });
   });
 
@@ -139,7 +142,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
         entries: [
           {
             binding: 0,
-            visibility: 0x1,
+            visibility: 0x3,
             buffer: { type: 'read-only-storage', hasDynamicOffset: false },
           },
         ],
@@ -182,7 +185,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('unlit-material', () => {
-    it('13 entries: base PBR material only (no skylight injection)', () => {
+    it('17 entries: base PBR material only (no skylight injection)', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'unlit-material',
@@ -191,7 +194,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
         label: 'unlit-material-bgl',
         entries: buildPbrMaterialUserRegionEntries(),
       });
-      expect(out.entries.length).toBe(13);
+      expect(out.entries.length).toBe(17);
     });
   });
 });

package/src/__tests__/pipeline-cache-keying.unit.test.ts

@@ -127,14 +127,16 @@ describe('cacheKeyOf passKind dimension', () => {
 describe('PassKind open string + KNOWN_PASS_KINDS (feat-20260615 D-10)', () => {
   // M2-T4 expanded KNOWN_PASS_KINDS from 4 to 6 entries by adding 'post-process'
   // and 'skybox'; point-shadow-caster is the engine's depth-only point-light
-  // pass and is part of the discoverable catalogue as well.
-  it('KNOWN_PASS_KINDS has exactly 7 entries', () => {
-    expect(KNOWN_PASS_KINDS).toHaveLength(7);
+  // pass and is part of the discoverable catalogue as well. M3-T4 adds the
+  // Standard temporal producer to the shipped pass catalogue.
+  it('KNOWN_PASS_KINDS has exactly 8 entries', () => {
+    expect(KNOWN_PASS_KINDS).toHaveLength(8);
   });
 
-  it('KNOWN_PASS_KINDS contains the 7 engine-shipped pass kinds', () => {
+  it('KNOWN_PASS_KINDS contains the 8 engine-shipped pass kinds', () => {
     expect(KNOWN_PASS_KINDS).toContain('forward');
     expect(KNOWN_PASS_KINDS).toContain('deferred');
+    expect(KNOWN_PASS_KINDS).toContain('temporal');
     expect(KNOWN_PASS_KINDS).toContain('lighting');
     expect(KNOWN_PASS_KINDS).toContain('shadow-caster');
     expect(KNOWN_PASS_KINDS).toContain('point-shadow-caster');

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

@@ -138,6 +138,7 @@ import {
 import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 import { matchPass } from '../../../render/src/systems/pass-selector';
 import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
 
 function makeExplicitNullRhi(spies: {
   setIndexBuffer: ReturnType<typeof vi.fn>;
@@ -2407,7 +2408,8 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       sourcePath: `${identifier}.wgsl`,
       composedWgsl: '/* stub */',
       paramSchema: '[]',
-      variants: [],
+      variants:
+        identifier === 'forgeax::default-standard-pbr' ? standardMaterialShaderVariants() : [],
     });
     const manifest = {
       schemaVersion: '1.0.0',
@@ -2697,7 +2699,8 @@ vi.mock('@forgeax/engine-rhi-wgpu', () => {
       sourcePath: `${identifier}.wgsl`,
       composedWgsl: '/* stub */',
       paramSchema: '[]',
-      variants: [],
+      variants:
+        identifier === 'forgeax::default-standard-pbr' ? standardMaterialShaderVariants() : [],
     });
     const manifest = {
       schemaVersion: '1.0.0',

package/src/__tests__/render-environment-consumer.integration.test.ts

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const environmentSource = readFileSync(
+  fileURLToPath(new URL('../../../render/src/extract/environment.ts', import.meta.url)),
+  'utf8',
+);
+const vfxSource = readFileSync(
+  fileURLToPath(
+    new URL('../../../vfx-render/src/feature/gpu-particle-feature.ts', import.meta.url),
+  ),
+  'utf8',
+);
+
+describe('runtime Environment consumer ownership', () => {
+  it('consumes extracted Environment facts without a second Fog resource topology', () => {
+    expect(environmentSource).toContain('createEnvironmentExtractionContext');
+    expect(environmentSource).not.toContain('createFullscreenRenderFeature');
+    expect(vfxSource).not.toMatch(/fog.*(history|counter|upload)/i);
+  });
+
+  it('indexes the public recovery sequence without exposing graph or device state', () => {
+    const runtimeReadme = readFileSync(
+      fileURLToPath(new URL('../../README.md', import.meta.url)),
+      'utf8',
+    );
+    expect(runtimeReadme).toContain('inspect()');
+    expect(runtimeReadme).toContain('typed `detail`');
+    expect(runtimeReadme).toMatch(/retry the same\s+request/);
+    expect(runtimeReadme).toContain('graph, device, or');
+  });
+});

package/src/__tests__/render-error-exhaustive.test-d.ts

@@ -38,14 +38,30 @@ function exhaustiveSwitchOnRenderCode(code: RenderErrorCode): string {
       return code;
     case 'cleanup-failed':
       return code;
+    case 'taa-unavailable':
+      return code;
     case 'frame-receipt-stale':
       return code;
     case 'renderer-contract-failed':
       return code;
     case 'observation-unavailable':
       return code;
+    case 'scene-data-unavailable':
+      return code;
     case 'shadow-invalid-config':
       return code;
+    case 'environment-source-conflict':
+      return code;
+    case 'fog-cardinality':
+      return code;
+    case 'taa-caps-insufficient':
+      return code;
+    case 'environment-generation-failed':
+      return code;
+    case 'atmosphere-invalid-parameter':
+      return code;
+    case 'owner-stage-failed':
+      return code;
     case 'equirect-projection-failed':
       return code;
     case 'hdrp-light-budget-exceeded':
@@ -84,6 +100,20 @@ function exhaustiveSwitchOnRenderCode(code: RenderErrorCode): string {
       return code;
     case 'render-feature-draw-recording-failed':
       return code;
+    case 'transmission-capability-missing':
+      return code;
+    case 'points-lines-invalid-style':
+      return code;
+    case 'points-lines-topology-mismatch':
+      return code;
+    case 'points-lines-style-unsupported':
+      return code;
+    case 'points-lines-material-unsupported':
+      return code;
+    case 'points-lines-budget-exceeded':
+      return code;
+    case 'points-lines-prepare-failed':
+      return code;
     default: {
       const exhaustive: never = code;
       return exhaustive;
@@ -159,10 +189,41 @@ function narrowRenderError(err: RenderError): void {
       void err.detail.reason;
       void err.detail.recovery;
       break;
+    case 'scene-data-unavailable':
+      void err.detail.featureIdentity;
+      void err.detail.schema;
+      void err.detail.lane;
+      void err.detail.reason;
+      void err.detail.missingContributorIds;
+      void err.detail.omittedMissingContributorCount;
+      void err.detail.recovery;
+      break;
     case 'shadow-invalid-config':
       void err.detail.field; // string
       void err.detail.value; // number
       break;
+    case 'environment-source-conflict':
+      void err.detail.owners;
+      break;
+    case 'fog-cardinality':
+      void err.detail.count;
+      break;
+    case 'taa-caps-insufficient':
+      void err.detail.required;
+      void err.detail.available;
+      break;
+    case 'environment-generation-failed':
+      void err.detail.sourceKey;
+      void err.detail.stage;
+      break;
+    case 'atmosphere-invalid-parameter':
+      void err.detail.field;
+      void err.detail.value;
+      break;
+    case 'owner-stage-failed':
+      void err.detail.owner;
+      void err.detail.stage;
+      break;
     case 'equirect-projection-failed':
       void err.detail.handle; // number
       break;
@@ -235,11 +296,43 @@ function narrowRenderError(err: RenderError): void {
       void err.detail.backendReason;
       void err.detail.operation;
       break;
+    case 'taa-unavailable':
+      void err.detail.reason;
+      break;
     case 'vertex-color-variant-conflict':
       void err.detail.authored;
       void err.detail.authoredValue;
       void err.detail.projected;
       break;
+    case 'points-lines-invalid-style':
+      void err.detail.component;
+      void err.detail.field;
+      break;
+    case 'points-lines-topology-mismatch':
+      void err.detail.submesh;
+      void err.detail.actual;
+      break;
+    case 'points-lines-style-unsupported':
+      void err.detail.member;
+      void err.detail.supported;
+      break;
+    case 'points-lines-material-unsupported':
+      void err.detail.material;
+      void err.detail.pass;
+      break;
+    case 'points-lines-budget-exceeded':
+      void err.detail.requested;
+      void err.detail.limit;
+      break;
+    case 'points-lines-prepare-failed':
+      void err.detail.owner;
+      void err.detail.generation;
+      break;
+    case 'transmission-capability-missing':
+      void err.detail.material;
+      void err.detail.capability;
+      void err.detail.stage;
+      break;
     default: {
       const exhaustive: never = err;
       void exhaustive;

package/src/__tests__/render-feature-prepared-graphics.browser.test.ts

@@ -45,6 +45,10 @@ describe('prepared graphics browser contract', () => {
     canvas.remove();
   });
 
+  // This negative path intentionally exercises a real WebGPU pipeline before
+  // the renderer reports the structured stage error. Its cold lavapipe start
+  // has exceeded Vitest's 15s default in CI; keep the assertion bounded at the
+  // owner rather than weakening the global browser timeout.
   it('reports forged prepared state through subscribe without renderer diagnostics getters', async () => {
     if (typeof navigator?.gpu?.requestAdapter !== 'function') {
       throw new Error('WebGPU is unavailable');
@@ -80,5 +84,5 @@ describe('prepared graphics browser contract', () => {
     });
     expect(renderer).not.toHaveProperty('renderFeatureDiagnostics');
     canvas.remove();
-  });
+  }, 30_000);
 });

package/src/__tests__/render-feature-prepared-graphics.fixture.ts

@@ -8,6 +8,7 @@ import type {
 import { Camera } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { ok } from '@forgeax/engine-types';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
 
 export type PreparedFeatureMode = 'accepted' | 'empty' | 'mismatch' | 'recovery';
 
@@ -19,6 +20,15 @@ export const preparedManifest = `data:application/json,${encodeURIComponent(
       { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
       { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
     ],
+    materialShaders: [
+      {
+        identifier: 'forgeax::default-standard-pbr',
+        sourcePath: 'forgeax::default-standard-pbr.wgsl',
+        composedWgsl: '/* stub */',
+        paramSchema: '[]',
+        variants: standardMaterialShaderVariants(),
+      },
+    ],
   }),
 )}`;
 

package/src/__tests__/render-system-mega.test.ts

@@ -20,6 +20,7 @@ import { Transform } from '@forgeax/engine-scene';
 import type { Handle } from '@forgeax/engine-types';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
 import { drawWithOwners } from './renderer-test-utils';
 
 type RendererErrorObservation = {
@@ -278,7 +279,8 @@ function drawPublished(renderer: RendererType, world: WorldType) {
       sourcePath: `${identifier}.wgsl`,
       composedWgsl: '/* stub */',
       paramSchema: '[]',
-      variants: [],
+      variants:
+        identifier === 'forgeax::default-standard-pbr' ? standardMaterialShaderVariants() : [],
     });
     const manifest = {
       schemaVersion: '1.0.0',

package/src/__tests__/render-system-record-multi-material-textureview.test.ts

@@ -33,6 +33,7 @@ import type { World as WorldType } from '@forgeax/engine-ecs';
 import type { Renderer as RendererType } from '@forgeax/engine-render';
 import type { Handle, MaterialAsset, MeshAsset, TextureAsset } from '@forgeax/engine-types';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
 
 function canonicalTestMeshAttributes(vertexCount: number) {
   return {
@@ -195,7 +196,8 @@ function buildManifestDataUrl(): string {
     sourcePath: `${identifier}.wgsl`,
     composedWgsl: '/* stub */',
     paramSchema,
-    variants: [],
+    variants:
+      identifier === 'forgeax::default-standard-pbr' ? standardMaterialShaderVariants() : [],
   });
   // The standard-PBR shader declares baseColorTexture / metallicRoughnessTexture
   // / normalTexture as texture2d params. Texture resolution is now schema-driven

package/src/__tests__/render-system-record-per-submesh-transparency.test.ts

@@ -26,6 +26,7 @@ import type { World as WorldType } from '@forgeax/engine-ecs';
 import type { Renderer as RendererType } from '@forgeax/engine-render';
 import type { Handle, MaterialAsset, MeshAsset, TextureAsset } from '@forgeax/engine-types';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { standardMaterialShaderVariants } from './helpers/standard-material-manifest';
 
 function canonicalTestMeshAttributes(vertexCount: number) {
   return {
@@ -161,7 +162,8 @@ function buildManifestDataUrl(): string {
     sourcePath: `${identifier}.wgsl`,
     composedWgsl: '/* stub */',
     paramSchema,
-    variants: [],
+    variants:
+      identifier === 'forgeax::default-standard-pbr' ? standardMaterialShaderVariants() : [],
   });
   const pbrParamSchema = JSON.stringify([
     { name: 'baseColor', type: 'color', default: [1, 1, 1, 1] },

package/src/__tests__/render-system-record.test.ts

@@ -55,7 +55,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
   // asserts the PBR baseline against literal byte values.
   //
   // Coverage:
-  //   - 304 B payload (STANDARD_PBR_UBO_SIZE)
+  //   - 384 B payload (STANDARD_PBR_UBO_SIZE)
   //   - slot 0 = baseColor.rgb + 1 (alpha hardcoded)
   //   - slot 1 first 8 B = metallic, roughness (f32x2)
   //   - slot 1 last 4 u32 (channelMap) = [2, 1, 0, 0]
@@ -108,7 +108,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       expect(typeof mod.buildPbrMaterialUboPayload).toBe('function');
     });
 
-    it('304 B payload size + standard PBR slot layout (baseline)', () => {
+    it('384 B payload size + standard PBR slot layout (baseline)', () => {
       if (typeof mod.buildPbrMaterialUboPayload !== 'function') {
         throw new Error('helper not exported yet');
       }
@@ -124,7 +124,7 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
         specularTint: [0.11, 0.22, 0.33],
       });
       const buf = mod.buildPbrMaterialUboPayload(snap);
-      expect(buf.byteLength).toBe(304);
+      expect(buf.byteLength).toBe(384);
       const f32 = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
       // feat-20260613 fix-issue-1 (D-8 channelMap split): the 4 channelMap
       // u32 slots collapse into 4 independent f32 channel selectors at
@@ -161,7 +161,9 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       expect(f32[20]).toBeCloseTo(0.11);
       expect(f32[21]).toBeCloseTo(0.22);
       expect(f32[22]).toBeCloseTo(0.33);
-      expect(f32[72]).toBe(1);
+      // normalScale remains at the scalar end of the authored region after
+      // transmission fields moved the engine-owned coordinate records.
+      expect(f32[23]).toBe(1);
     });
 
     it('writes schema-carried alphaCutoff into the baseline PBR payload', () => {
@@ -180,15 +182,15 @@ import { extractFrame, prepareExtractContext } from '../../../render/src/render-
       const apply = mod.applyMaterialTextureUvScales;
       if (typeof apply !== 'function') throw new Error('helper not exported yet');
       const world = new World();
-      const pbrPayload = new ArrayBuffer(304);
+      const pbrPayload = new ArrayBuffer(384);
       apply(pbrPayload, makePbrSnapshot({}), world);
       const pbrF32 = new Float32Array(pbrPayload);
-      expect(pbrF32[26]).toBe(1);
       expect(pbrF32[34]).toBe(1);
       expect(pbrF32[42]).toBe(1);
       expect(pbrF32[50]).toBe(1);
       expect(pbrF32[58]).toBe(1);
       expect(pbrF32[66]).toBe(1);
+      expect(pbrF32[74]).toBe(1);
 
       const spritePayload = new ArrayBuffer(128);
       apply(