@forgeax/engine-render 0.1.4 → 0.1.6

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

@@ -3,8 +3,8 @@ import { describe, expect, it } from 'vitest';
 import { GpuScene } from '../gpu-scene';
 import { GPU_SCENE_LAYOUTS, gpuSceneFieldOffset } from '../gpu-scene-schema';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ } from '../gpu-usage';
-import { RenderSceneProjection } from '../render-scene-projection';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 const material = {
   baseColor: new Float32Array([0.25, 0.5, 0.75]),
@@ -28,9 +28,6 @@ function snapshot(entityKey: number, translationX: number): RenderableSnapshot {
     localAabb: new Float32Array([-1, -2, -3, 1, 2, 3]),
     gpuDrivenDraws: [
       {
-        submeshIndex: 0,
-        passIndex: 0,
-        queue: 2000,
         kind: 'indexed',
         first: 3,
         count: 36,
@@ -56,7 +53,7 @@ describe('GpuScene Dawn residency', () => {
     const availability = GpuScene.create(device, 2).unwrap();
     expect(availability.status).toBe('available');
     if (availability.status !== 'available') return;
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     const first = snapshot(7, 3);
     const firstDraw = first.gpuDrivenDraws?.[0];
     const secondMaterial = {
@@ -67,7 +64,6 @@ describe('GpuScene Dawn residency', () => {
     if (firstDraw === undefined) throw new Error('GPU draw fixture unavailable');
     availability.scene
       .sync(
-        projection,
         projection.apply([
           {
             kind: 'create',

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

@@ -3,8 +3,8 @@ import { RhiNullCommandEncoder, RhiNullDevice, RhiNullQueue } from '@forgeax/eng
 import { describe, expect, it } from 'vitest';
 import { GpuScene } from '../gpu-scene';
 import { GPU_SCENE_LAYOUTS, gpuSceneFieldOffset } from '../gpu-scene-schema';
-import { RenderSceneProjection } from '../render-scene-projection';
 import type { MaterialSnapshot, RenderableSnapshot } from '../render-system-extract';
+import { RenderScene } from '../scene/render-scene';
 
 interface WriteRecord {
   readonly offset: number;
@@ -71,32 +71,24 @@ describe('GpuScene', () => {
     const created = GpuScene.create(createDevice(queue), 4).unwrap();
     expect(created.status).toBe('available');
     if (created.status !== 'available') return;
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
 
     const initial = projection.apply([
       { kind: 'create', snapshot: snapshot(0) },
       { kind: 'create', snapshot: snapshot(1) },
       { kind: 'create', snapshot: snapshot(2) },
     ]);
-    expect(created.scene.sync(projection, initial).unwrap()).toMatchObject({
-      ranges: 5,
-      bytes: 1344,
-    });
+    expect(created.scene.sync(initial).unwrap()).toMatchObject({ ranges: 5, bytes: 1344 });
     const writesAfterInitial = queue.writes.length;
 
-    created.scene.sync(projection, projection.apply([])).unwrap();
+    created.scene.sync(projection.apply([])).unwrap();
     expect(queue.writes).toHaveLength(writesAfterInitial);
 
     const dirty = projection.apply([
       { kind: 'update-transform', worldId: 0, entityKey: 0, world: snapshot(0, 4).transform.world },
       { kind: 'update-transform', worldId: 0, entityKey: 2, world: snapshot(2, 8).transform.world },
     ]);
-    // Transform-only Scene Fact deltas touch only the transform table; the
-    // primitive/instance/draw/material rows stay resident.
-    expect(created.scene.sync(projection, dirty).unwrap()).toMatchObject({
-      ranges: 2,
-      bytes: 256,
-    });
+    expect(created.scene.sync(dirty).unwrap()).toMatchObject({ ranges: 10 });
     expect(queue.writes.length).toBeGreaterThan(writesAfterInitial);
     expect(created.scene.inspect()).toMatchObject({ noChangeFrames: 1 });
   });
@@ -105,10 +97,9 @@ describe('GpuScene', () => {
     const queue = new RecordingQueue();
     const created = GpuScene.create(createDevice(queue), 2).unwrap();
     if (created.status !== 'available') return;
-    const projection = new RenderSceneProjection();
+    const projection = new RenderScene();
     created.scene
       .sync(
-        projection,
         projection.apply([
           { kind: 'create', snapshot: snapshot(0) },
           { kind: 'create', snapshot: snapshot(1) },
@@ -119,16 +110,14 @@ describe('GpuScene', () => {
     expect(created.scene.inspect()).toMatchObject({ capacity: 8, capacityGrows: 1 });
 
     const beforeRemove = queue.writes.length;
-    created.scene
-      .sync(projection, projection.apply([{ kind: 'remove', worldId: 0, entityKey: 1 }]))
-      .unwrap();
+    created.scene.sync(projection.apply([{ kind: 'remove', worldId: 0, entityKey: 1 }])).unwrap();
     expect(queue.writes.slice(beforeRemove)).toHaveLength(5);
     expect(queue.writes.at(-1)?.bytes.every((value) => value === 0)).toBe(true);
     expect(created.scene.inspect().clearedSlots).toBe(1);
 
     const rebuilt = GpuScene.create(createDevice(new RecordingQueue()), 1).unwrap();
     if (rebuilt.status !== 'available') return;
-    expect(rebuilt.scene.rebuild(projection).unwrap()).toMatchObject({ ranges: 5 });
+    expect(rebuilt.scene.rebuild(projection.slotsSnapshot()).unwrap()).toMatchObject({ ranges: 5 });
     expect(rebuilt.scene.inspect()).toMatchObject({ capacity: 4, fullRebuilds: 1 });
   });
 
@@ -136,14 +125,11 @@ describe('GpuScene', () => {
     const queue = new RecordingQueue();
     const created = GpuScene.create(createDevice(queue), 1).unwrap();
     if (created.status !== 'available') return;
-    const projection = new RenderSceneProjection();
-    created.scene
-      .sync(projection, projection.apply([{ kind: 'create', snapshot: snapshot(1, 2) }]))
-      .unwrap();
+    const projection = new RenderScene();
+    created.scene.sync(projection.apply([{ kind: 'create', snapshot: snapshot(1, 2) }])).unwrap();
 
     created.scene
       .sync(
-        projection,
         projection.apply([
           { kind: 'remove', worldId: 0, entityKey: 1 },
           { kind: 'create', snapshot: snapshot(1, 9) },

package/src/__tests__/ibl/face-uniforms.unit.test.ts

@@ -0,0 +1,46 @@
+import { RhiNullAdapter } from '@forgeax/engine-rhi-null';
+import { describe, expect, it } from 'vitest';
+import {
+  createFaceUniformsBuffer,
+  createPrefilterUniformsBuffer,
+  writeAllFaceUniforms,
+  writeAllPrefilterUniforms,
+  writeFaceUniforms,
+  writePrefilterUniforms,
+} from '../../device/gpu-residency';
+
+async function createDevice() {
+  const adapterResult = await new RhiNullAdapter().requestDevice();
+  if (!adapterResult.ok) throw adapterResult.error;
+  return adapterResult.value;
+}
+
+describe('IBL face uniform RHI contract', () => {
+  it('allocates opaque buffers and writes all dynamic uniform slots', async () => {
+    const device = await createDevice();
+    const faceBuffer = createFaceUniformsBuffer(device);
+    const prefilterBuffer = createPrefilterUniformsBuffer(device);
+
+    expect(faceBuffer.ok).toBe(true);
+    expect(prefilterBuffer.ok).toBe(true);
+    if (!faceBuffer.ok || !prefilterBuffer.ok) return;
+
+    expect(writeAllFaceUniforms(device, faceBuffer.value).ok).toBe(true);
+    expect(writeAllPrefilterUniforms(device, prefilterBuffer.value).ok).toBe(true);
+  });
+
+  it('returns structured RHI errors for invalid uniform coordinates', async () => {
+    const device = await createDevice();
+    const bufferResult = createFaceUniformsBuffer(device);
+    expect(bufferResult.ok).toBe(true);
+    if (!bufferResult.ok) return;
+
+    const badFace = writeFaceUniforms(device, bufferResult.value, 6, new Float32Array(16));
+    const badMatrix = writeFaceUniforms(device, bufferResult.value, 0, new Float32Array(15));
+    const badSubPass = writePrefilterUniforms(device, bufferResult.value, 30, 0.5, 128);
+
+    expect(badFace).toMatchObject({ ok: false, error: { code: 'webgpu-runtime-error' } });
+    expect(badMatrix).toMatchObject({ ok: false, error: { code: 'webgpu-runtime-error' } });
+    expect(badSubPass).toMatchObject({ ok: false, error: { code: 'webgpu-runtime-error' } });
+  });
+});

package/src/__tests__/infinite-grid-no-vertex-probe.unit.test.ts

@@ -1,7 +1,7 @@
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createRenderFeatureHost, runRenderFeatureFrame } from '../features/host';
-import { createRenderFeatureTarget } from '../features/targets';
+import type { RenderFeaturePlan } from '../features/plan';
 import type { RenderFeature } from '../features/types';
 
 const caps = {
@@ -26,68 +26,42 @@ const caps = {
   maxColorAttachments: 8,
 } as const;
 
-const colorTarget = createRenderFeatureTarget({
-  kind: 'scene-color',
-  format: 'rgba8unorm',
-  sampleCount: 1,
-});
-const depthTarget = createRenderFeatureTarget({
-  kind: 'scene-depth',
-  format: 'depth24plus',
-  sampleCount: 1,
-});
-
 function noVertexFeature(): RenderFeature<{ readonly drawCount: number }> {
-  let pipeline: import('../features/prepared-graphics').RenderFeaturePreparedRef<'pipeline'>;
-  let bindings: import('../features/prepared-graphics').RenderFeaturePreparedRef<'bindings'>;
-
   return {
     identity: 'editor.infinite-grid.probe',
     extract: () => ok({ drawCount: 1 }),
-    prepare: (_data, context) => {
-      const preparedPipeline = context.graphics.preparePipeline('fullscreen', {
-        shader: 'editor.infinite-grid.probe',
-        vertexLayout: 'none',
-        colorFormats: [colorTarget.format],
-        depthFormat: depthTarget.format,
-        sampleCount: colorTarget.sampleCount,
-        topology: 'triangle-list',
-      });
-      if (!preparedPipeline.ok) return preparedPipeline;
-      const preparedBindings = context.graphics.prepareBindings('view', {
-        pipeline: preparedPipeline.value,
-        values: { vertexShaderUsesVertexIndex: true },
-      });
-      if (!preparedBindings.ok) return preparedBindings;
-      pipeline = preparedPipeline.value;
-      bindings = preparedBindings.value;
-      return ok(undefined);
-    },
-    contribute: (_data, context) => {
-      if (pipeline === undefined || bindings === undefined) return ok(undefined);
-      return context.staging.addGraphicsPass('infinite-grid', {
-        attachments: {
-          colors: [
-            { resource: colorTarget, format: colorTarget.format, loadOp: 'load', storeOp: 'store' },
-          ],
-          depthStencil: {
-            resource: depthTarget,
-            format: depthTarget.format,
-            depthLoadOp: 'load',
-            depthStoreOp: 'store',
+    plan: () => {
+      const value: RenderFeaturePlan = {
+        resources: [
+          {
+            kind: 'graphics-program',
+            name: 'fullscreen',
+            program: {
+              shader: 'editor.infinite-grid.probe',
+              vertexLayout: 'none',
+              colorFormats: ['rgba8unorm'],
+            },
           },
-        },
-        draws: [
+          { kind: 'graphics-bindings', name: 'view', program: 'fullscreen', values: {} },
+        ],
+        passes: [
           {
-            kind: 'draw',
-            pipeline,
-            bindings: [bindings],
-            vertexData: [],
-            vertexLayout: 'none',
-            command: { vertexCount: 3, instanceCount: 1 },
+            kind: 'raster',
+            name: 'infinite-grid',
+            colorAttachments: [{ target: 'swapchain', loadOp: 'load', storeOp: 'store' }],
+            draws: [
+              {
+                program: 'fullscreen',
+                bindings: ['view'],
+                vertexData: [],
+                vertexLayout: 'none',
+                draw: { kind: 'draw', vertexCount: 3, instanceCount: 1 },
+              },
+            ],
           },
         ],
-      });
+      };
+      return ok(value);
     },
   };
 }
@@ -103,22 +77,16 @@ describe('public no-vertex RenderFeature seam probe', () => {
     });
 
     expect(result.errors).toEqual([]);
-    expect(result.contributions).toHaveLength(1);
-    expect(result.contributions[0]?.passes[0]?.graphics?.draws[0]).toMatchObject({
-      kind: 'draw',
-      vertexLayout: 'none',
-      vertexData: [],
-      command: { vertexCount: 3, instanceCount: 1 },
+    expect(result.plans).toHaveLength(1);
+    expect(result.plans[0]?.plan.passes[0]).toMatchObject({
+      kind: 'raster',
+      draws: [{ vertexLayout: 'none', vertexData: [], draw: { kind: 'draw' } }],
     });
     expect(host.diagnostics()[0]).toMatchObject({
       identity: 'editor.infinite-grid.probe',
       status: 'active',
       latestError: undefined,
     });
-    expect(result.stageEvents.map((event) => event.stage)).toEqual([
-      'extract',
-      'prepare',
-      'contribute',
-    ]);
+    expect(result.stageEvents.map((event) => event.stage)).toEqual(['extract', 'plan']);
   });
 });

package/src/__tests__/ktx2-basis-gpu-consumer.dawn.test.ts

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import {
   ktx2ColorSpace,
   parseKtx2,
@@ -12,6 +13,7 @@ import {
 } from '@forgeax/engine-codec';
 import { basisEncode } from '@forgeax/engine-codec/encode';
 import { World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
 import type { RhiDevice, Texture } from '@forgeax/engine-rhi';
 import { ok } from '@forgeax/engine-rhi';
 import { createShaderModule, rhi } from '@forgeax/engine-rhi-webgpu';
@@ -21,7 +23,7 @@ import type {
   BasisEncoderModule,
   BasisModuleFactory,
 } from '../../../codec/src/wasm/basis-types.js';
-import { GpuResourceStore } from '../gpu-resource-store.js';
+import { GpuResidencyCache } from '../device/gpu-residency.js';
 import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_MAP_READ } from '../gpu-usage.js';
 
 const ENCODER_GLUE = new URL('../../../codec/pkg/encode/basis_encoder.mjs', import.meta.url);
@@ -554,7 +556,7 @@ describe.skipIf(!pkgBuilt)('KTX2/Basis real GPU texture consumer matrix', () =>
       return;
     }
     const device = deviceResult.value;
-    const store = new GpuResourceStore();
+    const store = new GpuResidencyCache();
     store.configureGpuDevice(
       device as never,
       undefined,
@@ -609,8 +611,15 @@ describe.skipIf(!pkgBuilt)('KTX2/Basis real GPU texture consumer matrix', () =>
           });
           continue;
         }
-        const handle = world.allocSharedRef('TextureAsset', result.texture);
-        const resident = store.ensureResident(handle, result.texture);
+        const registry = new AssetRegistry({} as never);
+        const parsedGuid = AssetGuid.parse(guid);
+        if (!parsedGuid.ok) throw new Error('GPU matrix GUID construction failed');
+        const catalog = registry.catalog(parsedGuid.value, result.texture);
+        if (!catalog.ok) throw new Error(`GPU matrix catalog failed: ${catalog.error.code}`);
+        const loaded = await registry.loadByGuid<TextureAsset>(parsedGuid.value);
+        if (!loaded.ok) throw new Error(`GPU matrix loadByGuid failed: ${loaded.error.code}`);
+        const handle = world.allocSharedRef('TextureAsset', loaded.value);
+        const resident = store.ensureResident(handle, loaded.value);
         if (!resident.ok) {
           rows.push({
             source: input.id,
@@ -633,7 +642,7 @@ describe.skipIf(!pkgBuilt)('KTX2/Basis real GPU texture consumer matrix', () =>
         const gpuTexture = store._getTextureGpuTexture(handle);
         if (gpuTexture === undefined) throw new Error('GPU matrix residency returned no texture');
         try {
-          const readback = await readbackTexture(device, result.texture, gpuTexture);
+          const readback = await readbackTexture(device, loaded.value, gpuTexture);
           const readbackBytes = readback.some((value) => value !== 0) ? readback.length : 0;
           const normalized = normalizedComparison(input, readback, result.texture.format);
           const status =

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

@@ -1,17 +1,10 @@
 import type { Vec3 } from '@forgeax/engine-math';
 import { describe, expect, it } from 'vitest';
-import {
-  BYTES_PER_LIGHT_SLOT,
-  LIGHTSLOT_LAYOUT,
-  LightSlotKind,
-  packLightSlot,
-  packSpotLight,
-} from '../light-buffer-layout';
+import { packSpotLight } from '../light-buffer-layout';
 import type { SpotLightSnapshot } from '../render-system-extract';
 
 const snapshot: SpotLightSnapshot = {
   kind: 'spot',
-  entity: 7,
   position: new Float32Array([2, 3, 4]) as Vec3,
   direction: new Float32Array([0, 1, 0]) as Vec3,
   color: new Float32Array([4, 2, 1]) as Vec3,
@@ -19,12 +12,12 @@ const snapshot: SpotLightSnapshot = {
   invRangeSquared: 0.25,
   cosInner: 0.98,
   cosOuter: 0.7,
-  castShadow: true,
-  lightViewProj: new Float32Array(16),
+  castShadow: false,
+  lightViewProj: undefined,
   mapSize: 2048,
   nearPlane: 0.1,
   farPlane: 50,
-  shadowAtlasTile: 3,
+  shadowAtlasTile: -1,
 };
 
 describe('direct light snapshot buffer layout', () => {
@@ -44,42 +37,4 @@ describe('direct light snapshot buffer layout', () => {
     expect(packed[5]).toBe(snapshot.color[1]);
     expect(packed[6]).toBe(snapshot.color[2]);
   });
-
-  it('keeps the HDRP LightSlot at 64 bytes and writes raw kind/tile lanes', () => {
-    const packed = packLightSlot(snapshot);
-    const i32 = new Int32Array(packed.buffer);
-    const u32 = new Uint32Array(packed.buffer);
-
-    expect(BYTES_PER_LIGHT_SLOT).toBe(64);
-    expect(LIGHTSLOT_LAYOUT.byteSize).toBe(64);
-    expect(LIGHTSLOT_LAYOUT.shadowPayloadOffset).toBe(52);
-    expect(LIGHTSLOT_LAYOUT.shadowAtlasTileOffset).toBe(52);
-    expect(u32[12]).toBe(LightSlotKind.SPOT);
-    expect(i32[13]).toBe(3);
-    expect(packed[14]).toBe(0);
-    expect(packed[15]).toBe(0);
-  });
-
-  it('keeps the point shadow layer and near/far lanes intact', () => {
-    const point = {
-      kind: 'point' as const,
-      position: new Float32Array([0, 1, 2]) as Vec3,
-      color: new Float32Array([1, 0.5, 0.25]) as Vec3,
-      intensity: 2,
-      invRangeSquared: 0.04,
-    };
-    const packed = packLightSlot(point, { shadowAtlasLayer: 2, near: 0.1, far: 25 });
-    const i32 = new Int32Array(packed.buffer);
-
-    expect(new Uint32Array(packed.buffer)[12]).toBe(LightSlotKind.POINT);
-    expect(i32[13]).toBe(2);
-    expect(packed[14]).toBeCloseTo(0.1, 5);
-    expect(packed[15]).toBe(25);
-  });
-
-  it('preserves -1 for a clipped fifth caster fixture', () => {
-    const clipped = { ...snapshot, shadowAtlasTile: -1 };
-    const packed = packLightSlot(clipped);
-    expect(new Int32Array(packed.buffer)[13]).toBe(-1);
-  });
 });

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

@@ -1,11 +1,7 @@
 import type { CookedMaterialRecord } from '@forgeax/engine-pack';
-import type { ShaderRegistry } from '@forgeax/engine-shader';
-import type { MaterialAsset, ParamSchemaEntry } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import type { RenderAssetPort } from '../assets/render-asset-port.js';
-import { resolveMaterialFromPort } from '../extract/material-interface.js';
-import { assembleMaterialProjection } from '../renderer/material/assembly.js';
-import { projectMaterialPipeline } from '../renderer/material/pipeline-projection.js';
+import { assembleMaterialProjection } from '../assembly/material/assembly.js';
+import { projectMaterialPipeline } from '../assembly/material/pipeline-projection.js';
 
 function cookedRecord(): CookedMaterialRecord {
   return {
@@ -57,50 +53,6 @@ function cookedRecord(): CookedMaterialRecord {
 }
 
 describe('cooked material render projection', () => {
-  it('registers the cooked shader at the Render boundary and projects resolved fields', () => {
-    const record = cookedRecord();
-    const installed = new Map<
-      string,
-      { source: string; paramSchema: readonly ParamSchemaEntry[] }
-    >();
-    const shaderRegistry = {
-      findMaterialArtifact(identifier: string) {
-        const entry = installed.get(identifier);
-        return entry === undefined
-          ? { ok: false, error: new Error('not registered') }
-          : { ok: true, value: entry };
-      },
-      installMaterialArtifact(
-        identifier: string,
-        entry: { source: string; paramSchema: readonly ParamSchemaEntry[] },
-      ) {
-        installed.set(identifier, entry);
-      },
-    } as unknown as ShaderRegistry;
-    const assets: RenderAssetPort = {
-      epoch: 0,
-      shaderRegistry,
-      lookup: () => undefined,
-      guidOf: () => 'material-leaf',
-      materialShaderTextureFieldNames: () => [],
-    };
-    const material = {
-      kind: 'material' as const,
-      cooked: record,
-    } as MaterialAsset & { readonly cooked: CookedMaterialRecord };
-
-    const resolved = resolveMaterialFromPort(material, assets);
-
-    expect(resolved.ok).toBe(true);
-    if (!resolved.ok) return;
-    expect(resolved.value.passes).toEqual(record.resolved.passes);
-    expect(resolved.value.values).toEqual(record.resolved.values);
-    expect(installed.get('project::standard')).toEqual({
-      source: new TextDecoder().decode(record.artifact.bytes),
-      paramSchema: [{ name: 'baseColor', type: 'color' }],
-    });
-  });
-
   it('projects cooked passes and artifact identity without exposing authored inheritance', () => {
     const projection = assembleMaterialProjection(cookedRecord());
 
@@ -128,7 +80,6 @@ describe('cooked material render projection', () => {
     expect(pipeline).toEqual({
       specializationKey: 'specialization-key',
       artifactHash: 'sha256:artifact',
-      layoutIdentity: 'sha256:layout',
       passes: projection.passes,
     });
   });

package/src/__tests__/material-snapshot-mutation.integration.test.ts

@@ -1,21 +1,17 @@
+import { AssetRegistry, HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  extractFrames,
-  type MaterialSnapshotCachesByWorld,
-  MeshFilter,
-  MeshRenderer,
-} from '@forgeax/engine-render/internal';
 import { Transform } from '@forgeax/engine-scene';
 import type { ShaderRegistry } from '@forgeax/engine-shader';
 import type { MaterialAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { createRenderAssetPort } from '../assets/render-asset-port';
+import { MeshFilter } from '../components/mesh-filter';
+import { MeshRenderer } from '../components/mesh-renderer';
+import { extractFrames, type MaterialSnapshotCachesByWorld } from '../render-system-extract';
 
 describe('material snapshot mutation', () => {
   it('projects in-place material value updates into the next extracted frame', () => {
     const world = new World();
-    const assets = createRenderAssetPort({
+    const assets = new AssetRegistry({
       findMaterialArtifact: () => ({ ok: false, error: new Error('not registered') }),
     } as unknown as ShaderRegistry);
     const values: Record<string, unknown> = {
@@ -35,23 +31,22 @@ describe('material snapshot mutation', () => {
       values: values as NonNullable<MaterialAsset['values']>,
     };
     const materialHandle = world.allocSharedRef('MaterialAsset', material);
-    const meshHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
 
     world.spawn(
       { component: Transform, data: {} },
-      { component: MeshFilter, data: { assetHandle: meshHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [materialHandle] } },
     );
     const materialCaches: MaterialSnapshotCachesByWorld = new WeakMap();
 
-    const first = extractFrames([world], 0, assets, undefined, undefined, materialCaches)
-      .renderables[0]?.material;
+    const first = extractFrames([world], 0, assets, undefined, materialCaches).renderables[0]
+      ?.material;
     expect(first?.baseColor).toEqual(new Float32Array([1, 0, 0]));
 
     values.baseColor = [0, 1, 0, 1];
 
-    const second = extractFrames([world], 0, assets, undefined, undefined, materialCaches)
-      .renderables[0]?.material;
+    const second = extractFrames([world], 0, assets, undefined, materialCaches).renderables[0]
+      ?.material;
     expect(second?.baseColor).toEqual(new Float32Array([0, 1, 0]));
     expect(second).not.toBe(first);
   });

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

@@ -1,13 +1,12 @@
+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 { writeDerivedMaterialPayload } from '../record/material-payload.js';
-import { assembleMaterialProjection } from '../renderer/material/assembly.js';
+import { assembleMaterialProjection } from '../assembly/material/assembly.js';
 import {
   routeMaterialPipeline,
   updateMaterialRuntimeValues,
-} from '../renderer/material/pipeline-projection.js';
-import { resolveTilesetRuntime } from '../tilemap/resolve-tileset-runtime';
+} from '../assembly/material/pipeline-projection.js';
 
 const record: CookedMaterialRecord = {
   schemaVersion: 'material-cook/2',
@@ -68,7 +67,7 @@ describe('cooked material static and dynamic routing', () => {
       kind: 'error',
       error: {
         code: 'material-specialization-not-cooked',
-        detail: { material: 'material-route', staticSelection: ['useNormalMap'] },
+        detail: { specializationKey: 'uncooked-static-selection' },
       },
     });
   });
@@ -93,21 +92,3 @@ describe('tileset atlas material projection', () => {
     expect(result).toMatchObject({ ok: false, error: { code: 'tileset-atlas-stale' } });
   });
 });
-
-describe('material coordinate projection route', () => {
-  it('keeps coordinate metadata on the derived slot path', () => {
-    const result = writeDerivedMaterialPayload({
-      material: 'route-coordinates',
-      schema: [{ name: 'albedo', type: 'texture2d' }],
-      values: {},
-      coordinates: {
-        albedo: {
-          set: 3,
-          transform: { offset: [0.25, 0.5], scale: [2, 2], rotation: 0.75 },
-          physicalUvScale: [0.9, 0.8],
-        },
-      },
-    });
-    expect(result.ok).toBe(true);
-  });
-});

package/src/__tests__/material-stride-surface.unit.test.ts

@@ -2,9 +2,9 @@ import { readFileSync } from 'node:fs';
 import { describe, expect, it } from 'vitest';
 import { MATERIAL_PER_ENTITY_STRIDE } from '../render-system';
 
-const ownerSource = readFileSync(new URL('../render-system.ts', import.meta.url), 'utf8');
+const ownerSource = readFileSync(new URL('../record/render-context.ts', import.meta.url), 'utf8');
 const rendererFactorySource = readFileSync(
-  new URL('../renderer/renderer-factory.ts', import.meta.url),
+  new URL('../assembly/factory.ts', import.meta.url),
   'utf8',
 );
 const recordSources = [