@forgeax/engine-render 0.1.6 → 0.1.19

package/src/__tests__/frame-plan-contract.unit.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type AtmosphereParameters,
+  type EnvironmentCandidate,
+  type EnvironmentFrame,
+  type FogCandidate,
+  selectEnvironmentFrame,
+} from '../extract/environment';
+
+const atmosphereParameters: AtmosphereParameters = {
+  turbidity: 2,
+  rayleigh: 1,
+  mieCoefficient: 0.005,
+  mieDirectionalG: 0.8,
+  sunAngularRadius: 0.004675,
+};
+
+function unwrapFrame(result: ReturnType<typeof selectEnvironmentFrame>): EnvironmentFrame {
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+
+const image = (entityKey: number, sourceKey: string): EnvironmentCandidate => ({
+  kind: 'image',
+  entityKey,
+  sourceKey,
+});
+const atmosphere = (entityKey: number, sourceKey: string): EnvironmentCandidate => ({
+  kind: 'atmosphere',
+  entityKey,
+  sourceKey,
+  atmosphere: atmosphereParameters,
+});
+const fog = (entityKey: number): FogCandidate => ({
+  entityKey,
+  color: [0.4, 0.5, 0.6],
+  density: 0.01,
+  heightFalloff: 0.2,
+  maxOpacity: 0.9,
+});
+
+describe('immutable frame plan contract', () => {
+  it('selects none, one image, or one atmosphere deterministically', () => {
+    expect(unwrapFrame(selectEnvironmentFrame([], [])).source.kind).toBe('none');
+    expect(unwrapFrame(selectEnvironmentFrame([image(2, 'image-a')], [])).source).toEqual({
+      kind: 'image',
+      sourceKey: 'image-a',
+      entityKey: 2,
+    });
+    expect(unwrapFrame(selectEnvironmentFrame([atmosphere(7, 'sky-a')], [])).source).toEqual({
+      kind: 'atmosphere',
+      sourceKey: 'sky-a',
+      entityKey: 7,
+      atmosphere: atmosphereParameters,
+    });
+  });
+
+  it('rejects mixed source kinds and conflicting source keys', () => {
+    expect(selectEnvironmentFrame([image(1, 'a'), atmosphere(2, 'b')], [])).toMatchObject({
+      ok: false,
+      error: { code: 'environment-source-conflict' },
+    });
+    expect(selectEnvironmentFrame([image(1, 'a'), image(2, 'b')], [])).toMatchObject({
+      ok: false,
+      error: { code: 'environment-source-conflict' },
+    });
+  });
+
+  it('keeps Fog independent from environment source and bounds cardinality', () => {
+    const withoutFog = unwrapFrame(selectEnvironmentFrame([], []));
+    expect(withoutFog.fog).toBeUndefined();
+    const withFog = unwrapFrame(selectEnvironmentFrame([], [fog(4)]));
+    expect(withFog.fog?.entityKey).toBe(4);
+    expect(selectEnvironmentFrame([], [fog(4), fog(8)])).toMatchObject({
+      ok: false,
+      error: { code: 'fog-cardinality' },
+    });
+  });
+
+  it('returns detached facts without GPU handles and freezes nested values', () => {
+    const result = selectEnvironmentFrame([image(1, 'stable')], [fog(3)]);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(Object.isFrozen(result.value)).toBe(true);
+    expect(Object.isFrozen(result.value.source)).toBe(true);
+    expect('device' in result.value).toBe(false);
+    expect('texture' in result.value).toBe(false);
+    expect('buffer' in result.value).toBe(false);
+  });
+});

package/src/__tests__/fullscreen-feature-plan.unit.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { createFullscreenRenderFeature } from '../features/fullscreen';
 import { freezeRenderFeaturePlan } from '../features/plan';
+import { createSceneDataCatalog } from '../temporal/scene-data-catalog';
 
 describe('fullscreen RenderFeature plan', () => {
   it('keeps the cooked effect on the Standard post-stage owner', () => {
@@ -14,6 +15,12 @@ describe('fullscreen RenderFeature plan', () => {
       frame: { frameNumber: 1 },
       generation: 1,
       targets: [{ name: 'scene-color', kind: 'color', format: 'rgba16float', sampleCount: 1 }],
+      sceneData: createSceneDataCatalog({
+        featureIdentity: 'test::fullscreen',
+        generation: 1,
+        planIdentity: 'test::fullscreen:1',
+        rgba16floatRenderable: true,
+      }),
     });
 
     expect(planned.ok).toBe(true);

package/src/__tests__/gpu-driven-indirect-raster-evidence.ts

@@ -102,7 +102,14 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
   const viewLayout = device
     .createBindGroupLayout({
       label: 'gpu-driven-production-view-bgl',
-      entries: [{ binding: 0, visibility: 0x1, buffer: { type: 'uniform' } }],
+      entries: [
+        { binding: 0, visibility: 0x1, buffer: { type: 'uniform' } },
+        {
+          binding: 10,
+          visibility: 0x1,
+          buffer: { type: 'uniform', hasDynamicOffset: true },
+        },
+      ],
     })
     .unwrap();
   const viewUniform = device
@@ -121,7 +128,10 @@ export async function runGpuDrivenIndirectRasterEvidence(): Promise<GpuDrivenInd
     .createBindGroup({
       label: 'gpu-driven-production-view-bg',
       layout: viewLayout,
-      entries: [{ binding: 0, resource: { kind: 'buffer', value: { buffer: viewUniform } } }],
+      entries: [
+        { binding: 0, resource: { kind: 'buffer', value: { buffer: viewUniform } } },
+        { binding: 10, resource: { kind: 'buffer', value: { buffer: viewUniform } } },
+      ],
     })
     .unwrap();
 

package/src/__tests__/gpu-driven-production.integration.test.ts

@@ -4,6 +4,10 @@ import { deriveVertexLayoutProjection } from '@forgeax/engine-geometry';
 import { RenderGraphBuilder } from '@forgeax/engine-render-graph';
 import { type RhiNullDevice, rhi } from '@forgeax/engine-rhi-null';
 import { Transform } from '@forgeax/engine-scene';
+import {
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+  DEFAULT_UNLIT_PARAM_SCHEMA,
+} from '@forgeax/engine-shader';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createRenderer as constructRenderer } from '../assembly/factory';
@@ -26,6 +30,61 @@ import { RenderScene } from '../scene/render-scene';
 
 const EMPTY_RESOURCE_CLASS = JSON.stringify({ textures: [], samplers: [], video: [] });
 
+const STANDARD_PBR_URP_VARIANT_KEY =
+  'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=false+VERTEX_COLOR_AVAILABLE=false';
+const STANDARD_PBR_TRANSMISSION_VARIANT_KEY =
+  'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+TRANSMISSION_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false';
+
+function manifestDataUrl(): string {
+  const pbrWgsl = '/* pbr stub - calls f_schlick( */';
+  const unlitWgsl = '/* unlit stub */';
+  const tonemapWgsl = '/* tonemap stub - struct TonemapParams { exposure: f32 }; */';
+  const standardPbrVariant = (transmissionAvailable: boolean, definesKey: string) => ({
+    definesKey,
+    defines: {
+      CLUSTER_FORWARD_AVAILABLE: false,
+      STORAGE_BUFFER_AVAILABLE: true,
+      TRANSMISSION_AVAILABLE: transmissionAvailable,
+      VERTEX_COLOR_AVAILABLE: false,
+    },
+    composedWgsl: pbrWgsl,
+  });
+  const materialShader = (
+    identifier: string,
+    paramSchema: readonly unknown[],
+    composedWgsl: string,
+    variants: readonly unknown[] = [],
+  ) => ({
+    identifier,
+    sourcePath: `${identifier}.wgsl`,
+    composedWgsl,
+    paramSchema: JSON.stringify(paramSchema),
+    variants,
+  });
+  return `data:application/json,${encodeURIComponent(
+    JSON.stringify({
+      schemaVersion: '1.0.0',
+      entries: [
+        { hash: 'pbr00000', wgsl: pbrWgsl, glsl: '', bindings: '' },
+        { hash: 'unlit000', wgsl: unlitWgsl, glsl: '', bindings: '' },
+        { hash: 'tonemap0', wgsl: tonemapWgsl, glsl: '', bindings: '' },
+      ],
+      materialShaders: [
+        materialShader(
+          'forgeax::default-standard-pbr',
+          DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+          pbrWgsl,
+          [
+            standardPbrVariant(false, STANDARD_PBR_URP_VARIANT_KEY),
+            standardPbrVariant(true, STANDARD_PBR_TRANSMISSION_VARIANT_KEY),
+          ],
+        ),
+        materialShader('forgeax::default-unlit', DEFAULT_UNLIT_PARAM_SCHEMA, unlitWgsl),
+      ],
+    }),
+  )}`;
+}
+
 function snapshot(entityKey: number, assetHandle: number): RenderableSnapshot {
   const material = {
     baseColor: new Float32Array([0.25 * entityKey, 0.5, 0.75]),
@@ -293,16 +352,6 @@ describe('GPU-driven production projection', () => {
   });
 
   it('activates inside the renderer-owned URP graph and removes the CPU forward draw', async () => {
-    const manifest = `data:application/json,${encodeURIComponent(
-      JSON.stringify({
-        schemaVersion: '1.0.0',
-        entries: [
-          { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
-          { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-          { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
-        ],
-      }),
-    )}`;
     const canvas = {
       width: 1,
       height: 1,
@@ -310,7 +359,11 @@ describe('GPU-driven production projection', () => {
       addEventListener: () => undefined,
       removeEventListener: () => undefined,
     } as unknown as HTMLCanvasElement;
-    const renderer = await constructRenderer(canvas, { rhi }, { shaderManifestUrl: manifest });
+    const renderer = await constructRenderer(
+      canvas,
+      { rhi },
+      { shaderManifestUrl: manifestDataUrl() },
+    );
     expect((await renderer.initialization).ok).toBe(true);
     const world = new World();
     expect(renderer.attach(world).ok).toBe(true);
@@ -345,9 +398,14 @@ describe('GPU-driven production projection', () => {
         'main',
       ]),
     );
+    expect(renderer.perFramePassNames).toContain('output-transform');
+    // Storage-buffer LDR frames keep the scene linear until the one output
+    // transform writes the encoded surface; the GPU-driven indirect raster
+    // draw and that fullscreen pass are the only draws in this topology.
     expect(device.totalDrawCount).toBe(2);
     expect(renderer.renderScene).toMatchObject({
       worldEntitiesScanned: 0,
+      fullRebuilds: 1,
       projectionRecords: 1,
       topology: { batchCount: 1, candidateCount: 1 },
       gpu: { status: 'resident' },
@@ -366,16 +424,6 @@ describe('GPU-driven production projection', () => {
   });
 
   it('keeps a stable multi-World composition resident and patches one World transform', async () => {
-    const manifest = `data:application/json,${encodeURIComponent(
-      JSON.stringify({
-        schemaVersion: '1.0.0',
-        entries: [
-          { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
-          { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-          { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
-        ],
-      }),
-    )}`;
     const canvas = {
       width: 1,
       height: 1,
@@ -383,7 +431,11 @@ describe('GPU-driven production projection', () => {
       addEventListener: () => undefined,
       removeEventListener: () => undefined,
     } as unknown as HTMLCanvasElement;
-    const renderer = await constructRenderer(canvas, { rhi }, { shaderManifestUrl: manifest });
+    const renderer = await constructRenderer(
+      canvas,
+      { rhi },
+      { shaderManifestUrl: manifestDataUrl() },
+    );
     expect((await renderer.initialization).ok).toBe(true);
     const cameraWorld = new World();
     const sceneWorld = new World();

package/src/__tests__/gpu-driven-view-graph.integration.test.ts

@@ -221,10 +221,47 @@ describe('GpuDrivenView graph projection', () => {
         undefined,
         prepared,
       );
+
+    Object.defineProperty(device, 'surfaceViewFormats', {
+      configurable: true,
+      value: false,
+    });
+    Object.defineProperty(device, 'caps', {
+      configurable: true,
+      value: { ...device.caps, rgba16floatRenderable: false },
+    });
+    expect(compile(preparedFrame(view))).toBeNull();
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'webgpu-runtime-error',
+      detail: { error: { code: 'surface-raw-endpoint-failed' } },
+    });
+    errors.length = 0;
+    delete (device as unknown as { caps?: unknown }).caps;
+    delete (device as unknown as { surfaceViewFormats?: unknown }).surfaceViewFormats;
+
     const compiledPrevious = compile(preparedFrame(view));
     expect(compiledPrevious).not.toBeNull();
     if (compiledPrevious === null) return;
 
+    Object.defineProperty(device, 'surfaceViewFormats', {
+      configurable: true,
+      value: false,
+    });
+    Object.defineProperty(device, 'caps', {
+      configurable: true,
+      value: { ...device.caps, rgba16floatRenderable: false },
+    });
+    expect(compile(preparedFrame(view))).toBe(compiledPrevious);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatchObject({
+      code: 'webgpu-runtime-error',
+      detail: { error: { code: 'surface-raw-endpoint-failed' } },
+    });
+    errors.length = 0;
+    delete (device as unknown as { caps?: unknown }).caps;
+    delete (device as unknown as { surfaceViewFormats?: unknown }).surfaceViewFormats;
+
     const secondDelta = projection.apply([{ kind: 'create', snapshot: snapshot(2) }]);
     sceneAvailability.scene.sync(secondDelta).unwrap();
     topology.rebuild(projection.slotsSnapshot());

package/src/__tests__/gpu-scene.unit.test.ts

@@ -5,6 +5,7 @@ import { GpuScene } from '../gpu-scene';
 import { GPU_SCENE_LAYOUTS, gpuSceneFieldOffset } from '../gpu-scene-schema';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
 import { RenderScene } from '../scene/render-scene';
+import { classifySceneDataCoverage } from '../temporal/coverage';
 
 interface WriteRecord {
   readonly offset: number;
@@ -66,6 +67,15 @@ function createDevice(queue: RecordingQueue): RhiNullDevice {
 }
 
 describe('GpuScene', () => {
+  it('exposes GPU scene facts as exact temporal coverage', () => {
+    const coverage = classifySceneDataCoverage({
+      contributors: [{ id: 'gpu-scene', kind: 'exact' }],
+      requiredContributorIds: ['gpu-scene'],
+    });
+    expect(coverage.complete).toBe(true);
+    expect(coverage.exactContributorIds).toEqual(['gpu-scene']);
+  });
+
   it('uploads only coalesced dirty ranges and performs no upload on no-change', () => {
     const queue = new RecordingQueue();
     const created = GpuScene.create(createDevice(queue), 4).unwrap();

package/src/__tests__/injection-kind-owner.test-d.ts

@@ -4,11 +4,12 @@ import { appendInjection, INJECTION_KIND_LENGTHS, type InjectionKind } from '../
 
 it('derives InjectionKind from the public length-map keys', () => {
   expectTypeOf<InjectionKind>().toEqualTypeOf<keyof typeof INJECTION_KIND_LENGTHS>();
-  expectTypeOf<InjectionKind>().toEqualTypeOf<'shadow' | 'ibl' | 'lightmap'>();
+  expectTypeOf<InjectionKind>().toEqualTypeOf<'shadow' | 'ibl' | 'lightmap' | 'transmission'>();
   expectTypeOf<'unknown'>().not.toExtend<InjectionKind>();
 });
 
 it('keeps the public map assignability and appendInjection narrowing', () => {
   expectTypeOf(INJECTION_KIND_LENGTHS).toMatchTypeOf<Readonly<Record<InjectionKind, number>>>();
   expectTypeOf(appendInjection).parameter(1).toEqualTypeOf<InjectionKind>();
+  expectTypeOf(appendInjection([], 'transmission')).toEqualTypeOf<GPUBindGroupLayoutEntry[]>();
 });

package/src/__tests__/material-contract-inventory.unit.test.ts

@@ -3,7 +3,9 @@ import {
   DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
   DEFAULT_UNLIT_PARAM_SCHEMA,
 } from '@forgeax/engine-shader';
+import { resolveMaterialAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { Materials } from '../materials.js';
 
 describe('vertex color does not change the material contract', () => {
   it('keeps colored and plain materials on the same schema and resource identity', () => {
@@ -21,4 +23,64 @@ describe('vertex color does not change the material contract', () => {
     expect(JSON.stringify(material)).not.toMatch(/hasColor|VERTEX_COLOR_AVAILABLE|colorBinding/i);
     expect(material.passes?.[0]?.program).not.toHaveProperty('color');
   });
+
+  it.each([
+    ['unlit', Materials.unlit([0.5, 0.5, 0.5, 1])],
+    ['standard', Materials.standard({ baseColor: [0.5, 0.5, 0.5, 1] })],
+  ] as const)('keeps the %s factory fallback aligned with its color schema', (_name, material) => {
+    const resolved = resolveMaterialAsset('factory-fallback', {
+      'factory-fallback': material,
+    });
+    expect(resolved).toMatchObject({ ok: true });
+  });
+
+  it('keeps the standard authoring parameters derived from the shared schema', () => {
+    const material = Materials.standard({ baseColor: [1, 1, 1, 1] });
+    expect(material.parameters?.map((parameter) => parameter.name)).toEqual(
+      DEFAULT_STANDARD_PBR_PARAM_SCHEMA.map((entry) => entry.name),
+    );
+    expect(material.values).toMatchObject({
+      transmission: 0,
+      ior: 1.5,
+      thickness: 0,
+      attenuationColor: [1, 1, 1],
+    });
+  });
+
+  it('routes active transmission to Forward and ShadowCaster only', () => {
+    const material = Materials.standard({ baseColor: [1, 1, 1, 1], transmission: 0.5 });
+    expect(material.passes?.map((pass) => pass.name)).toEqual(['forward', 'shadow-caster']);
+    expect(material.passes?.[0]?.renderState).toMatchObject({ depthWriteEnabled: false });
+  });
+
+  it.each([
+    ['transmission', { transmission: -0.1 }],
+    ['ior', { ior: 0 }],
+    ['thickness', { thickness: -0.1 }],
+    ['attenuationDistance', { attenuationDistance: 0 }],
+  ])('rejects invalid %s before material publication', (_name, options) => {
+    expect(() => Materials.standard({ baseColor: [1, 1, 1, 1], ...options })).toThrow();
+  });
+
+  it('rejects BLEND and depth writes for an active transmission material', () => {
+    expect(() =>
+      Materials.standard({
+        baseColor: [1, 1, 1, 1],
+        transmission: 0.5,
+        renderState: {
+          blend: {
+            color: { srcFactor: 'one', dstFactor: 'zero', operation: 'add' },
+            alpha: { srcFactor: 'one', dstFactor: 'zero', operation: 'add' },
+          },
+        },
+      }),
+    ).toThrow();
+    expect(() =>
+      Materials.standard({
+        baseColor: [1, 1, 1, 1],
+        transmission: 0.5,
+        renderState: { depthWriteEnabled: true },
+      }),
+    ).toThrow();
+  });
 });

package/src/__tests__/material-cooked-projection.unit.test.ts

@@ -1,128 +1,22 @@
-import type { CookedMaterialRecord } from '@forgeax/engine-pack';
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
+import { derive } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { assembleMaterialProjection } from '../assembly/material/assembly.js';
-import { projectMaterialPipeline } from '../assembly/material/pipeline-projection.js';
 
-function cookedRecord(): CookedMaterialRecord {
-  return {
-    schemaVersion: 'material-cook/2',
-    guid: 'material-leaf' as never,
-    authored: {
-      kind: 'material',
-      parent: 'material-parent' as never,
-      values: { baseColor: [1, 0, 0, 1] },
-    },
-    resolved: {
-      passes: [
-        {
-          name: 'forward',
-          program: {
-            module: 'project::standard',
-            vertexEntry: 'vs_main',
-            fragmentEntry: 'fs_main',
-          },
-          renderState: { blend: 'opaque' },
-        },
-      ],
-      parameters: [{ name: 'baseColor', type: 'color' }],
-      values: { baseColor: [0.2, 0.3, 0.4, 1] },
-    },
-    refs: {
-      parent: ['material-parent'],
-      textures: [],
-      samplers: [],
-      modules: ['project::standard'],
-    },
-    artifact: {
-      mediaType: 'text/wgsl',
-      path: 'material-leaf.wgsl',
-      digest: 'sha256:artifact',
-      bytes: new Uint8Array([1, 2, 3]),
-    },
-    receipt: {
-      schemaVersion: 'material-cook/2',
-      sourceClosure: ['project::standard'],
-      profile: 'forgeax-material-wgsl-v1',
-      compilerVersion: 'compiler/1',
-      inputDigest: 'specialization-key',
-      outputDigest: 'sha256:artifact',
-      layoutIdentity: 'sha256:layout',
-      derivedInterface: { layoutIdentity: 'sha256:layout' },
-    },
-  };
-}
-
-describe('cooked material render projection', () => {
-  it('projects cooked passes and artifact identity without exposing authored inheritance', () => {
-    const projection = assembleMaterialProjection(cookedRecord());
-
-    expect(projection).toMatchObject({
-      materialGuid: 'material-leaf',
-      specializationKey: 'specialization-key',
-      artifactHash: 'sha256:artifact',
-      passes: [
-        {
-          name: 'forward',
-          module: 'project::standard',
-          vertexEntry: 'vs_main',
-          fragmentEntry: 'fs_main',
-        },
-      ],
-    });
-    expect('authored' in projection).toBe(false);
-    expect(projection.passes[0]?.artifactHash).toBe('sha256:artifact');
-  });
-
-  it('builds a pipeline projection from the cooked artifact, not the parent chain', () => {
-    const projection = assembleMaterialProjection(cookedRecord());
-    const pipeline = projectMaterialPipeline(projection);
-
-    expect(pipeline).toEqual({
-      specializationKey: 'specialization-key',
-      artifactHash: 'sha256:artifact',
-      passes: projection.passes,
-    });
-  });
-
-  it('keeps projections isolated when adjacent slots use different cooked identities', () => {
-    const firstRecord = cookedRecord();
-    const secondRecord: CookedMaterialRecord = {
-      ...firstRecord,
-      guid: 'material-slot-2' as never,
-      authored: {
-        kind: 'material',
-        ...firstRecord.authored,
-        parent: 'material-parent-2' as never,
-        values: { baseColor: [0, 1, 0, 1] },
-      },
-      resolved: {
-        ...firstRecord.resolved,
-        values: { baseColor: [0.8, 0.1, 0.2, 1] },
-      },
-      artifact: {
-        ...firstRecord.artifact,
-        path: 'material-slot-2.wgsl',
-        digest: 'sha256:artifact-2',
-        bytes: new Uint8Array([4, 5, 6]),
-      },
-      receipt: {
-        ...firstRecord.receipt,
-        inputDigest: 'specialization-key-2',
-        outputDigest: 'sha256:artifact-2',
-      },
-    };
-
-    const first = assembleMaterialProjection(firstRecord);
-    const second = assembleMaterialProjection(secondRecord);
-
-    expect(second).not.toBe(first);
-    expect(first.materialGuid).toBe('material-leaf');
-    expect(first.specializationKey).toBe('specialization-key');
-    expect(first.artifactHash).toBe('sha256:artifact');
-    expect(second.materialGuid).toBe('material-slot-2');
-    expect(second.specializationKey).toBe('specialization-key-2');
-    expect(second.artifactHash).toBe('sha256:artifact-2');
-    expect(second.runtimeValues).not.toBe(first.runtimeValues);
-    expect('authored' in second).toBe(false);
+describe('standard material cooked projection', () => {
+  it('uses one schema for reflection, uniform layout, and resource bindings', () => {
+    const derived = derive(DEFAULT_STANDARD_PBR_PARAM_SCHEMA);
+    const names = derived.numericMembers.map((member) => member.name);
+    expect(names).toEqual(expect.arrayContaining(['transmission', 'ior', 'thickness']));
+    expect(derived.coordinateRecords.map((record) => record.parameter)).toEqual(
+      expect.arrayContaining(['transmissionTexture', 'thicknessTexture']),
+    );
+    expect(derived.resourceBindings.map((binding) => binding.name)).toEqual(
+      expect.arrayContaining([
+        'transmissionTexture_sampler',
+        'transmissionTexture',
+        'thicknessTexture_sampler',
+        'thicknessTexture',
+      ]),
+    );
   });
 });

package/src/__tests__/material-static-dynamic-route.unit.test.ts

@@ -1,5 +1,3 @@
-import { resolveTilesetRuntime } from '@forgeax/engine-assets-runtime';
-import { World } from '@forgeax/engine-ecs';
 import type { CookedMaterialRecord } from '@forgeax/engine-pack';
 import { describe, expect, it, vi } from 'vitest';
 import { assembleMaterialProjection } from '../assembly/material/assembly.js';
@@ -9,13 +7,18 @@ import {
 } from '../assembly/material/pipeline-projection.js';
 
 const record: CookedMaterialRecord = {
-  schemaVersion: 'material-cook/2',
+  schemaVersion: 'material-cook/3',
   guid: 'material-route',
+  specializationKey: 'route-key',
+  authored: {
+    kind: 'material',
+    values: { useNormalMap: false },
+  },
   resolved: {
     passes: [{ name: 'forward', program: { module: 'project::standard' } }],
     parameters: [
       { name: 'baseColor', type: 'color' },
-      { name: 'useNormalMap', type: 'bool', static: true },
+      { name: 'useNormalMap', type: 'bool' },
     ],
     values: { baseColor: [1, 1, 1, 1], useNormalMap: false },
   },
@@ -27,13 +30,30 @@ const record: CookedMaterialRecord = {
     bytes: new Uint8Array([4]),
   },
   receipt: {
-    schemaVersion: 'material-cook/2',
+    schemaVersion: 'material-cook/3',
     sourceClosure: ['project::standard'],
     profile: 'forgeax-material-wgsl-v1',
     compilerVersion: 'compiler/1',
-    inputDigest: 'route-key',
-    outputDigest: 'sha256:route',
-    layoutIdentity: 'sha256:layout',
+    identity: {
+      materialContractDigest: 'sha256:contract',
+      sourceRevision: 'sha256:source',
+      sourceClosureDigest: 'sha256:closure',
+      layoutIdentity: 'sha256:layout',
+      programIdentity: 'sha256:program',
+      pipelineIdentity: 'sha256:pipeline',
+      materialPublicationIdentity: 'sha256:publication',
+      cookIdentity: 'sha256:input',
+      compilerFingerprint: 'sha256:compiler',
+      wasm: {
+        sourceContentKey: 'unavailable',
+        artifactSha256: 'unavailable',
+        glueSha256: 'unavailable',
+      },
+      artifactDigest: 'sha256:route',
+      valueGeneration: 1,
+      dependencyGeneration: 1,
+      cookGeneration: 1,
+    },
     derivedInterface: { layoutIdentity: 'sha256:layout' },
   },
 };
@@ -72,23 +92,3 @@ describe('cooked material static and dynamic routing', () => {
     });
   });
 });
-
-describe('tileset atlas material projection', () => {
-  it('fails closed for a missing or wrong-kind atlas payload', () => {
-    const world = new World();
-    const missing = resolveTilesetRuntime(world, 'missing-atlas', () => undefined);
-    const wrongKind = resolveTilesetRuntime(
-      world,
-      'wrong-atlas',
-      () => ({ kind: 'audio' }) as never,
-    );
-
-    expect(missing).toMatchObject({ ok: false, error: { code: 'tileset-atlas-not-found' } });
-    expect(wrongKind).toMatchObject({ ok: false, error: { code: 'tileset-atlas-kind-mismatch' } });
-  });
-
-  it('reports stale atlas payloads instead of casting them into a handle', () => {
-    const result = resolveTilesetRuntime(new World(), 'stale-atlas', () => ({ code: 'stale' }));
-    expect(result).toMatchObject({ ok: false, error: { code: 'tileset-atlas-stale' } });
-  });
-});