@forgeax/engine-render 0.1.4 → 0.1.7

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,16 +1,13 @@
 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 {
-    schemaVersion: 'material-cook/2',
+    schemaVersion: 'material-cook/3',
     guid: 'material-leaf' as never,
+    specializationKey: 'specialization-key',
     authored: {
       kind: 'material',
       parent: 'material-parent' as never,
@@ -44,63 +41,36 @@ function cookedRecord(): CookedMaterialRecord {
       bytes: new Uint8Array([1, 2, 3]),
     },
     receipt: {
-      schemaVersion: 'material-cook/2',
+      schemaVersion: 'material-cook/3',
       sourceClosure: ['project::standard'],
       profile: 'forgeax-material-wgsl-v1',
       compilerVersion: 'compiler/1',
-      inputDigest: 'specialization-key',
-      outputDigest: 'sha256:artifact',
-      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:artifact',
+        valueGeneration: 1,
+        dependencyGeneration: 1,
+        cookGeneration: 1,
+      },
       derivedInterface: { layoutIdentity: 'sha256:layout' },
     },
   };
 }
 
 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 +98,6 @@ describe('cooked material render projection', () => {
     expect(pipeline).toEqual({
       specializationKey: 'specialization-key',
       artifactHash: 'sha256:artifact',
-      layoutIdentity: 'sha256:layout',
       passes: projection.passes,
     });
   });
@@ -156,9 +125,13 @@ describe('cooked material render projection', () => {
       },
       receipt: {
         ...firstRecord.receipt,
-        inputDigest: 'specialization-key-2',
-        outputDigest: 'sha256:artifact-2',
+        identity: {
+          ...firstRecord.receipt.identity,
+          cookIdentity: 'sha256:input-2',
+          artifactDigest: 'sha256:artifact-2',
+        },
       },
+      specializationKey: 'specialization-key-2',
     };
 
     const first = assembleMaterialProjection(firstRecord);

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,22 +1,24 @@
-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',
+  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 },
   },
@@ -28,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' },
   },
 };
@@ -68,46 +87,8 @@ describe('cooked material static and dynamic routing', () => {
       kind: 'error',
       error: {
         code: 'material-specialization-not-cooked',
-        detail: { material: 'material-route', staticSelection: ['useNormalMap'] },
-      },
-    });
-  });
-});
-
-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' } });
-  });
-});
-
-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],
-        },
+        detail: { specializationKey: 'uncooked-static-selection' },
       },
     });
-    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 = [

package/src/__tests__/mesh-buffer-usage-surface.unit.test.ts

@@ -14,12 +14,13 @@ import {
 const ownerSource = readFileSync(new URL('../gpu-usage.ts', import.meta.url), 'utf8');
 const meshSsboSource = readFileSync(new URL('../record/mesh-ssbo.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 consumerSources = [
   readFileSync(new URL('../render-data.ts', import.meta.url), 'utf8'),
-  readFileSync(new URL('../gpu-resource-store.ts', import.meta.url), 'utf8'),
+  readFileSync(new URL('../device/gpu-residency.ts', import.meta.url), 'utf8'),
+  rendererFactorySource,
 ];
 const featureBufferSources = [
   {
@@ -31,7 +32,7 @@ const featureBufferSources = [
     names: ['GPU_BUFFER_USAGE_UNIFORM', 'GPU_BUFFER_USAGE_COPY_DST'],
   },
   {
-    source: readFileSync(new URL('../ibl/face-uniforms.ts', import.meta.url), 'utf8'),
+    source: readFileSync(new URL('../device/gpu-residency.ts', import.meta.url), 'utf8'),
     names: ['GPU_BUFFER_USAGE_UNIFORM', 'GPU_BUFFER_USAGE_COPY_DST'],
   },
   {
@@ -73,7 +74,7 @@ describe('render buffer usage owner', () => {
     expect(ownerSource.match(/export const GPU_BUFFER_USAGE_/g)).toHaveLength(8);
   });
 
-  it('routes mesh descriptor and update consumers through the owner', () => {
+  it('routes mesh descriptor, update, and bootstrap consumers through the owner', () => {
     for (const source of consumerSources) {
       expect(source).toContain('GPU_BUFFER_USAGE_VERTEX');
       expect(source).toContain('GPU_BUFFER_USAGE_INDEX');
@@ -92,10 +93,8 @@ describe('render buffer usage owner', () => {
     }
   });
 
-  it('routes shadow-depth readback staging through the owner', () => {
-    expect(rendererFactorySource).toContain(
-      'GPU_BUFFER_USAGE_COPY_DST | GPU_BUFFER_USAGE_MAP_READ',
-    );
+  it('keeps shadow-depth readback out of the renderer factory', () => {
+    expect(rendererFactorySource).not.toContain('GPU_BUFFER_USAGE_MAP_READ');
     expect(rendererFactorySource).not.toMatch(/const (COPY_DST|MAP_READ)\s*=\s*0x/);
   });