@forgeax/engine-runtime 0.1.4 → 0.1.7

package/src/__tests__/dawn/instances-uniform-fallback.dawn.test.ts

@@ -109,11 +109,11 @@ describe('w6 -- AC-07 storage+uniform variant test (degraded best-effort)', () =
     // end-to-end on dawn.
 
     const { World } = await import('@forgeax/engine-ecs');
-    const { createPrimitiveMesh } = await import('@forgeax/engine-geometry');
-    const { Camera, MeshRenderer } = await import('@forgeax/engine-render/internal');
-    const { Instances } = await import('@forgeax/engine-render/internal');
-    const { createRenderer } = await import('@forgeax/engine-runtime');
-    const { MeshFilter } = await import('@forgeax/engine-render/internal');
+    const { AssetRegistry, HANDLE_CUBE } = await import('@forgeax/engine-assets-runtime');
+    const { Camera, MeshRenderer } = await import('@forgeax/engine-render');
+    const { Instances } = await import('@forgeax/engine-render');
+    const { constructRuntimeRendererHost } = await import('../../renderer-host');
+    const { MeshFilter } = await import('@forgeax/engine-render');
     const { Transform } = await import('@forgeax/engine-scene');
     const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
     const ENGINE_MANIFEST_W6 = await buildEngineShaderManifest();
@@ -173,9 +173,9 @@ describe('w6 -- AC-07 storage+uniform variant test (degraded best-effort)', () =
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(
+      host = await constructRuntimeRendererHost(
         mockCanvas,
         {},
         { shaderManifestUrl: ENGINE_MANIFEST_URL_W6 },
@@ -183,11 +183,11 @@ describe('w6 -- AC-07 storage+uniform variant test (degraded best-effort)', () =
     } finally {
       globalThis.navigator.gpu.requestAdapter = origReq;
     }
-    expect(renderer.backend).toBe('webgpu');
-
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
-    if (!ready.ok) return;
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer, assets } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
+    expect(assets).toBeInstanceOf(AssetRegistry);
 
     const matAsset: MaterialAsset = {
       kind: 'material',
@@ -222,7 +222,6 @@ describe('w6 -- AC-07 storage+uniform variant test (degraded best-effort)', () =
     }
 
     const world = new World();
-    const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     const matHandle = world.allocSharedRef<'MaterialAsset', MaterialAsset>(
       'MaterialAsset',
       matAsset,
@@ -236,7 +235,7 @@ describe('w6 -- AC-07 storage+uniform variant test (degraded best-effort)', () =
           scale: [0.3, 0.3, 0.3],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle] } },
       { component: Instances, data: { transforms } },
     );

package/src/__tests__/dawn/material-alpha.dawn.test.ts

@@ -6,11 +6,11 @@ import {
   Materials,
   MeshFilter,
   MeshRenderer,
-} from '@forgeax/engine-render/internal';
-import { createRenderer } from '@forgeax/engine-runtime';
+} from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import type { TextureAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { constructRuntimeRendererHost } from '../../renderer-host';
 
 const WIDTH = 64;
 const HEIGHT = 64;
@@ -175,18 +175,25 @@ async function captureCase(testCase: AlphaCase): Promise<[number, number, number
     addEventListener() {},
     removeEventListener() {},
   } as unknown as HTMLCanvasElement;
-  let renderer: Awaited<ReturnType<typeof createRenderer>>;
+  let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
   try {
-    renderer = await createRenderer(canvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+    host = await constructRuntimeRendererHost(
+      canvas,
+      {},
+      {
+        shaderManifestUrl: ENGINE_MANIFEST_URL,
+      },
+    );
   } finally {
     globalThis.navigator.gpu.requestAdapter = original;
   }
-  const ready = await renderer.ready;
-  expect(ready.ok).toBe(true);
-  if (!ready.ok || device === undefined) throw new Error('runtime Dawn renderer not ready');
+  expect(host.ok).toBe(true);
+  if (!host.ok || device === undefined) throw new Error('runtime Dawn renderer not ready');
+  const { renderer } = host.value;
+  expect(renderer.inspect().state).toBe('alive');
 
   const world = new World();
-  const attachment = renderer.attachWorld(world);
+  const attachment = renderer.attach(world);
   if (!attachment.ok) throw attachment.error;
   const plane = createPlaneGeometry(2.8, 2.8);
   expect(plane.ok).toBe(true);
@@ -196,18 +203,8 @@ async function captureCase(testCase: AlphaCase): Promise<[number, number, number
     testCase.textureColor === undefined ? undefined : makeTexture(testCase.textureColor);
   const textureHandle =
     texture === undefined ? undefined : world.allocSharedRef('TextureAsset', texture);
-  if (texture !== undefined && textureHandle !== undefined) {
-    const uploaded = await renderer.store.uploadTexture(textureHandle, texture, {
-      bytes: texture.data,
-      width: 1,
-      height: 1,
-      mime: 'image/png',
-      colorSpace: 'srgb',
-      mipmap: false,
-    });
-    expect(uploaded.ok).toBe(true);
-    if (!uploaded.ok) throw new Error('texture upload failed');
-  }
+  // The renderer-owned record stage derives GPU residency from this world
+  // asset. No renderer store upload is part of the public contract.
   const renderState =
     testCase.mode === 'BLEND'
       ? {
@@ -242,16 +239,7 @@ async function captureCase(testCase: AlphaCase): Promise<[number, number, number
     renderState,
     ...(textureHandle === undefined
       ? {}
-      : {
-          baseColorTexture: {
-            texture: textureHandle as never,
-            coordinates: {
-              set: 0,
-              transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-              physicalUvScale: [1, 1],
-            },
-          },
-        }),
+      : { baseColorTexture: { texture: textureHandle as never } }),
     ...(testCase.mode === 'MASK' && testCase.cutoff !== undefined
       ? { alphaCutoff: testCase.cutoff }
       : {}),
@@ -274,7 +262,11 @@ async function captureCase(testCase: AlphaCase): Promise<[number, number, number
     data: { direction: [0, 0, -1], color: [1, 1, 1], intensity: 1, castShadow: false },
   });
   world.update().unwrap();
-  const drawn = renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+  const drawn = renderer.draw({
+    leases: [attachment.value],
+    camera: { lease: attachment.value },
+    environment: { lease: attachment.value },
+  });
   expect(drawn.ok).toBe(true);
   if (!drawn.ok) throw new Error(`draw failed: ${drawn.error.code}`);
   await device.queue.onSubmittedWorkDone();

package/src/__tests__/dawn/material-cooked-fixture.dawn.test.ts

@@ -3,14 +3,20 @@ import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
 type CookedRecord = {
-  readonly key: string;
-  readonly bytes: string;
-  readonly values: unknown;
+  readonly specializationKey: string;
+  readonly artifactDigest: string;
+  readonly artifact: { readonly digest: string; readonly bytes: readonly number[] };
   readonly resolved?: {
     readonly values?: unknown;
   };
   readonly receipt?: {
-    readonly layoutIdentity?: string;
+    readonly identity?: {
+      readonly layoutIdentity?: string;
+      readonly programIdentity?: string;
+      readonly pipelineIdentity?: string;
+      readonly cookIdentity?: string;
+      readonly compilerFingerprint?: string;
+    };
     readonly schemaVersion?: string;
   };
 };
@@ -41,16 +47,25 @@ describe('custom-shader cooked MaterialAsset fixture', () => {
     const derived = fixture.assets.find((asset) => asset.payload.role === 'derived');
     expect(root?.payload.cooked).toBeDefined();
     expect(derived?.payload.cooked).toBeDefined();
-    expect(derived?.payload.cooked?.key).toBe(root?.payload.cooked?.key);
-    expect(derived?.payload.cooked?.bytes).toBe(root?.payload.cooked?.bytes);
-    expect(derived?.payload.cooked?.values).toEqual(root?.payload.cooked?.values);
+    expect(derived?.payload.cooked?.specializationKey).toBe(
+      root?.payload.cooked?.specializationKey,
+    );
+    expect(derived?.payload.cooked?.artifactDigest).toBe(root?.payload.cooked?.artifactDigest);
+    expect(derived?.payload.cooked?.artifact.bytes).toEqual(root?.payload.cooked?.artifact.bytes);
+    expect(derived?.payload.cooked?.resolved?.values).toEqual(
+      root?.payload.cooked?.resolved?.values,
+    );
   });
 
   it('keeps cooked layout identity and authored coordinate transforms', () => {
     const root = fixture.assets.find((asset) => asset.payload.role === 'root');
     const cooked = root?.payload.cooked;
-    expect(cooked?.receipt?.schemaVersion).toBe('material-cook/2');
-    expect(cooked?.receipt?.layoutIdentity).toMatch(/^sha256-/);
+    expect(cooked?.receipt?.schemaVersion).toBe('material-cook/3');
+    expect(cooked?.receipt?.identity?.layoutIdentity).toMatch(/^sha256-/);
+    expect(cooked?.receipt?.identity?.programIdentity).toMatch(/^sha256:/);
+    expect(cooked?.receipt?.identity?.pipelineIdentity).toMatch(/^sha256:/);
+    expect(cooked?.receipt?.identity?.cookIdentity).toMatch(/^sha256:/);
+    expect(cooked?.receipt?.identity?.compilerFingerprint).toMatch(/^sha256-/);
     expect(cooked?.resolved?.values).toMatchObject({
       baseColorUvTransform: [0, 0, 1, 1],
       normalUvTransform: [0.125, 0.25, 2, 2],

package/src/__tests__/dawn/{mesh-update.dawn.test.ts → mesh-update-dawn.test.ts}

@@ -1,26 +1,23 @@
-// mesh-update.dawn.test.ts - updateMesh in-place re-upload dawn-tier test
+// mesh-update-dawn.test.ts - updateMesh in-place re-upload dawn-tier test
 // (feat-20260531-world-space-msdf-text-rendering M3 / w12).
 //
-// Verifies that updateMesh correctly writes same-shape vertex/index data into
-// existing GPU buffers, while explicit replaceMesh owns shape changes — all
-// without changing the mesh handle id.
+// Verifies that updateMesh correctly writes new vertex/index data into
+// existing GPU buffers and, on expansion, creates new buffers while
+// destroying old ones — all without changing the mesh handle id.
 //
-// AC-08 falsification: if same-shape updateMesh leaked GPU buffers (create
-// without destroy), the dawn backend would surface this as resource exhaustion
-// or the buffer count would grow across repeated calls. This test validates the
-// structural invariants on a real GPU device.
+// AC-08 falsification: if updateMesh leaked GPU buffers (create without
+// destroy), the dawn backend would surface this as resource exhaustion
+// or the buffer count would grow across repeated calls. This test
+// validates the structural invariants on a real GPU device.
 
+import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import {
-  deriveVertexLayoutProjection,
-  PROCEDURAL_FLOATS_PER_VERTEX,
-} from '@forgeax/engine-geometry';
+import { PROCEDURAL_FLOATS_PER_VERTEX } from '@forgeax/engine-geometry';
 import { mat4 } from '@forgeax/engine-math';
-import { GpuResourceStore } from '@forgeax/engine-render/internal';
-import { ok, type RhiDevice } from '@forgeax/engine-rhi';
-import { rhi } from '@forgeax/engine-rhi-webgpu';
+import { ok } from '@forgeax/engine-rhi';
 import type { EquirectAsset, MeshAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { GpuResidencyCache } from '../../../../render/src/device/gpu-residency';
 
 const mockCaps = {
   backendKind: 'webgpu' as const,
@@ -44,32 +41,13 @@ const mockCaps = {
   maxColorAttachments: 8,
 };
 
-// feat-20260601-gpu-resource-store-extraction M1: mesh GPU residency + updateMesh
+// feat-20260601-device/gpu-residency-extraction M1: mesh GPU residency + updateMesh
 // moved to the store, and register no longer auto-uploads (push severed). The
 // pull-model test premise: register the POD, then explicitly
 // `store.ensureResident(handle, pod)` to upload, then assert + updateMesh.
 
 const dawnReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
 
-async function requestRhiDevice(): Promise<RhiDevice | undefined> {
-  const adapterResult = await rhi.requestAdapter();
-  expect(adapterResult.ok).toBe(true);
-  if (!adapterResult.ok) return undefined;
-  const deviceResult = await adapterResult.value.requestDevice();
-  expect(deviceResult.ok).toBe(true);
-  if (!deviceResult.ok) return undefined;
-  return deviceResult.value;
-}
-
-function canonicalAttributes(vertexCount: number): MeshAsset['attributes'] {
-  return {
-    position: new Float32Array(vertexCount * 3),
-    normal: new Float32Array(vertexCount * 3),
-    uv: new Float32Array(vertexCount * 2),
-    tangent: new Float32Array(vertexCount * 4),
-  };
-}
-
 function makeSmallMesh(): MeshAsset {
   const vertices = new Float32Array(4 * PROCEDURAL_FLOATS_PER_VERTEX);
   const indices = new Uint16Array([0, 1, 2, 0, 2, 3]);
@@ -77,7 +55,7 @@ function makeSmallMesh(): MeshAsset {
     kind: 'mesh',
     vertices,
     indices,
-    attributes: canonicalAttributes(4),
+    attributes: {},
     aabb: new Float32Array(6),
     submeshes: [
       {
@@ -100,7 +78,7 @@ function makeLargerMesh(): MeshAsset {
     kind: 'mesh',
     vertices,
     indices,
-    attributes: canonicalAttributes(8),
+    attributes: {},
     aabb: new Float32Array(6),
     submeshes: [
       {
@@ -120,13 +98,16 @@ describe('w12 - updateMesh dawn-tier (AC-08)', () => {
   it.skipIf(!dawnReady)(
     '(a) updateMesh in-place re-upload does not create new vbo/ibo',
     async () => {
-      const device = await requestRhiDevice();
-      if (device === undefined) return;
+      const adapter = await navigator.gpu.requestAdapter();
+      expect(adapter).not.toBeNull();
+      if (adapter === null) return;
+      const device = await adapter.requestDevice();
 
-      const store = new GpuResourceStore();
+      const store = new GpuResidencyCache();
       const world = new World();
       store.configureGpuDevice(
-        device,
+        // biome-ignore lint/suspicious/noExplicitAny: structural rhi device shim
+        device as any,
         undefined,
         (w: World, pod: EquirectAsset) => ok(w.allocSharedRef('EquirectAsset', pod)),
         mockCaps,
@@ -162,15 +143,18 @@ describe('w12 - updateMesh dawn-tier (AC-08)', () => {
   );
 
   it.skipIf(!dawnReady)(
-    '(b) shape mismatch is explicit, then replaceMesh rebuilds buffers with same handle id',
+    '(b) updateMesh expansion creates new buffers and destroys old ones, same handle id',
     async () => {
-      const device = await requestRhiDevice();
-      if (device === undefined) return;
+      const adapter = await navigator.gpu.requestAdapter();
+      expect(adapter).not.toBeNull();
+      if (adapter === null) return;
+      const device = await adapter.requestDevice();
 
-      const store = new GpuResourceStore();
+      const store = new GpuResidencyCache();
       const world = new World();
       store.configureGpuDevice(
-        device,
+        // biome-ignore lint/suspicious/noExplicitAny: structural rhi device shim
+        device as any,
         undefined,
         (w: World, pod: EquirectAsset) => ok(w.allocSharedRef('EquirectAsset', pod)),
         mockCaps,
@@ -186,15 +170,10 @@ describe('w12 - updateMesh dawn-tier (AC-08)', () => {
       const vboBefore = before.vertexBuffer;
       const iboBefore = before.indexBuffer;
 
-      // A shape change must not be silently reinterpreted by updateMesh.
+      // Expansion: larger data exceeds current buffer capacity.
       const larger = makeLargerMesh();
       if (!(larger.indices instanceof Uint16Array)) return;
-      const rejected = store.updateMesh(handle, larger.vertices, larger.indices);
-      expect(rejected.ok).toBe(false);
-      if (!rejected.ok) expect(rejected.error.code).toBe('mesh-shape-mismatch');
-
-      const replaced = store.replaceMesh(handle, larger.vertices, larger.indices);
-      expect(replaced.ok).toBe(true);
+      store.updateMesh(handle, larger.vertices, larger.indices);
 
       const after = store.getMeshGpuHandles(handle);
       expect(after).toBeDefined();
@@ -213,96 +192,25 @@ describe('w12 - updateMesh dawn-tier (AC-08)', () => {
       // indexCount should reflect the larger data.
       expect(after.indexCount).toBe(larger.indices.length);
 
-      // The owning World still resolves the same handle after replacement.
-      const result = world.sharedRefs.resolve<string, MeshAsset>(handle);
+      // The handle id is unchanged — resolveAssetHandle still returns the payload.
+      const result = resolveAssetHandle<MeshAsset>(world, handle);
       expect(result.ok).toBe(true);
     },
   );
 
   it.skipIf(!dawnReady)(
-    '(c) Uint32 + projected skin and multi-UV attributes survive whole and range updates',
-    async () => {
-      const device = await requestRhiDevice();
-      if (device === undefined) return;
-
-      const store = new GpuResourceStore();
-      const world = new World();
-      store.configureGpuDevice(
-        device,
-        undefined,
-        (w: World, pod: EquirectAsset) => ok(w.allocSharedRef('EquirectAsset', pod)),
-        mockCaps,
-      );
-
-      const vertexCount = 4;
-      const indices = new Uint32Array([0, 1, 2, 0, 2, 3]);
-      const attributes: MeshAsset['attributes'] = {
-        position: new Float32Array(vertexCount * 3),
-        normal: new Float32Array(vertexCount * 3),
-        uv: new Float32Array(vertexCount * 2),
-        tangent: new Float32Array(vertexCount * 4),
-        skinIndex: new Uint16Array(vertexCount * 4),
-        skinWeight: new Float32Array(vertexCount * 4),
-        uv1: new Float32Array(vertexCount * 2),
-      };
-      const layoutProjection = deriveVertexLayoutProjection(attributes);
-      const vertices = new Float32Array(
-        (vertexCount * layoutProjection.arrayStride) / Float32Array.BYTES_PER_ELEMENT,
-      );
-      const mesh: MeshAsset = {
-        kind: 'mesh',
-        vertices,
-        indices,
-        attributes,
-        aabb: new Float32Array(6),
-        submeshes: [
-          {
-            indexOffset: 0,
-            indexCount: indices.length,
-            vertexCount,
-            topology: 'triangle-list',
-            materialSlot: 0,
-          },
-        ],
-        materialSlots: [{ slotName: 'Default' }],
-      };
-      const handle = world.allocSharedRef('MeshAsset', mesh);
-      const resident = store.ensureResident(handle, mesh);
-      expect(resident.ok).toBe(true);
-      const before = store.getMeshGpuHandles(handle);
-      expect(before?.indexFormat).toBe('uint32');
-      expect(before?.layoutProjection).toEqual(layoutProjection);
-      expect(before?.layoutProjection.arrayStride).toBe(layoutProjection.arrayStride);
-      expect(before?.vertexCount).toBe(vertexCount);
-
-      const whole = store.updateMesh(handle, vertices, indices);
-      expect(whole.ok).toBe(true);
-      const range = store.updateMeshVertexRange(
-        handle,
-        new Float32Array(layoutProjection.arrayStride / Float32Array.BYTES_PER_ELEMENT),
-        1,
-        1,
-      );
-      expect(range.ok).toBe(true);
-      const after = store.getMeshGpuHandles(handle);
-      expect(after?.indexFormat).toBe('uint32');
-      expect(after?.layoutProjection).toEqual(layoutProjection);
-      expect(after?.layoutProjection.arrayStride).toBe(layoutProjection.arrayStride);
-      expect(after?.vertexCount).toBe(vertexCount);
-      expect(after?.indexCount).toBe(indices.length);
-    },
-  );
-
-  it.skipIf(!dawnReady)(
-    '(d) repeated 50-frame same-size updateMesh does not grow GPU buffer count',
+    '(c) repeated 50-frame same-size updateMesh does not grow GPU buffer count',
     async () => {
-      const device = await requestRhiDevice();
-      if (device === undefined) return;
+      const adapter = await navigator.gpu.requestAdapter();
+      expect(adapter).not.toBeNull();
+      if (adapter === null) return;
+      const device = await adapter.requestDevice();
 
-      const store = new GpuResourceStore();
+      const store = new GpuResidencyCache();
       const world = new World();
       store.configureGpuDevice(
-        device,
+        // biome-ignore lint/suspicious/noExplicitAny: structural rhi device shim
+        device as any,
         undefined,
         (w: World, pod: EquirectAsset) => ok(w.allocSharedRef('EquirectAsset', pod)),
         mockCaps,

package/src/__tests__/dawn/mipmap-srgb-linear.dawn.test.ts

@@ -11,22 +11,27 @@
 //   correct mid-gray on mip level 1 of a 2x2 -> 1x1 source.
 //
 // The 6-fixture coverage promised in plan-tasks T-M3-02 acceptanceCheck:
+//   - 1x1 / 2x2 / 256x256 / non-pow2 dimension boundaries -> covered by
+//     the pure-formula `numMipLevels` unit tests (T-M3-01 (b) -- the formula
+//     SSOT does not need real-GPU verification);
 //   - sRGB / linear physics -> covered by this dawn integration file
 //     (the `*-srgb` view spec path is the only scenario requiring real GPU).
 //
 // Red-stage scaffolding: implementation lands in T-M3-04 (mipmap-generator.ts)
 // + T-M3-05 (uploadTexture call site).
 
+import { numMipLevels } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { GpuResourceStore } from '@forgeax/engine-render/internal';
 import type { DecodedImage, TextureAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { GpuResidencyCache } from '../../../../render/src/device/gpu-residency';
 
-// feat-20260601-gpu-resource-store-extraction M1: uploadTexture moved to the
+// feat-20260601-device/gpu-residency-extraction M1: uploadTexture moved to the
 // store (POD carries format + mipmap flag, decoded carries pixel bytes; D-2).
 // These cases wire no GPU device, so the upload short-circuits to ok after the
 // consistency assertion (the actual mipmap blit needs a wired + prewarmed
-// device; that path is exercised by the smoke harness).
+// device; that path is exercised by the smoke harness). numMipLevels assertions
+// are pure-formula and unaffected.
 
 function makeTexture(
   format: GPUTextureFormat,
@@ -77,11 +82,12 @@ describe('T-M3-02 dawn mipmap chain on rgba8unorm-srgb (sRGB physics)', () => {
       bytes[i * 4 + 2] = 188;
       bytes[i * 4 + 3] = 255;
     }
-    const store = new GpuResourceStore();
+    const store = new GpuResidencyCache();
     const pod = makeTexture('rgba8unorm-srgb', 2, 2, 'srgb', true);
     const handle = world.allocSharedRef<'TextureAsset', TextureAsset>('TextureAsset', pod);
     const res = await store.uploadTexture(handle, pod, decoded(bytes, 2, 2, 'srgb', true));
     expect(res.ok).toBe(true);
+    expect(numMipLevels({ width: 2, height: 2 })).toBe(2);
   });
 });
 
@@ -98,17 +104,18 @@ describe('T-M3-02 dawn mipmap chain on rgba8unorm (linear physics)', () => {
       bytes[i * 4 + 2] = 128;
       bytes[i * 4 + 3] = 255;
     }
-    const store = new GpuResourceStore();
+    const store = new GpuResidencyCache();
     const pod = makeTexture('rgba8unorm', 2, 2, 'linear', true);
     const handle = world.allocSharedRef<'TextureAsset', TextureAsset>('TextureAsset', pod);
     const res = await store.uploadTexture(handle, pod, decoded(bytes, 2, 2, 'linear', true));
     expect(res.ok).toBe(true);
   });
 
-  it('accepts a 256x256 mipmapped texture', async () => {
+  it('256x256 mipmap chain produces 9 levels (numMipLevels SSOT)', async () => {
+    expect(numMipLevels({ width: 256, height: 256 })).toBe(9);
     const world = new World();
     const bytes = new Uint8Array(256 * 256 * 4).fill(128);
-    const store = new GpuResourceStore();
+    const store = new GpuResidencyCache();
     const pod = makeTexture('rgba8unorm', 256, 256, 'linear', true);
     const handle = world.allocSharedRef<'TextureAsset', TextureAsset>('TextureAsset', pod);
     const res = await store.uploadTexture(handle, pod, decoded(bytes, 256, 256, 'linear', true));

package/src/__tests__/dawn/per-entity-material-texture-isolation.dawn.test.ts

@@ -20,18 +20,12 @@
 import { World } from '@forgeax/engine-ecs';
 import { createBoxGeometry } from '@forgeax/engine-geometry';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
-import {
-  Camera,
-  DirectionalLight,
-  MeshFilter,
-  MeshRenderer,
-} from '@forgeax/engine-render/internal';
-import { createRenderer } from '@forgeax/engine-runtime';
+import { Camera, DirectionalLight, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import type { MaterialAsset, MeshAsset, TextureAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { constructRuntimeRendererHost } from '../../renderer-host';
 import { drawPublished } from '../draw-published';
-import { createTestRenderAssetStore } from '../helpers/render-asset-port';
 
 const WIDTH = 256;
 const HEIGHT = 256;
@@ -207,25 +201,22 @@ describe('bug-20260522 AC-01 per-entity material texture isolation (dawn)', () =
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    const assetStore = createTestRenderAssetStore();
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(
+      host = await constructRuntimeRendererHost(
         mockCanvas,
         {},
         {
           shaderManifestUrl: ENGINE_MANIFEST_URL,
-          assetResolver: assetStore.resolver,
         },
       );
     } finally {
       globalThis.navigator.gpu.requestAdapter = originalRequestAdapter;
     }
-    expect(renderer.backend).toBe('webgpu');
-
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
-    if (!ready.ok) return;
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer, assets } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
 
     const device = sharedDevice;
     expect(device).toBeDefined();
@@ -239,7 +230,7 @@ describe('bug-20260522 AC-01 per-entity material texture isolation (dawn)', () =
     // GUID; the extract stage resolves it via assets.lookup(guid) then mints a
     // user-tier column handle via world.allocSharedRef.
     const texGreenGuid = AssetGuid.random();
-    assetStore.resolver.publish(AssetGuid.format(texGreenGuid), makeChequerTexture(0, 200, 0));
+    assets.catalog(texGreenGuid, makeChequerTexture(0, 200, 0));
     const matA = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', {
       kind: 'material',
       passes: [
@@ -421,25 +412,22 @@ describe('bug-20260522 AC-01 per-entity material texture isolation (dawn)', () =
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    const assetStore = createTestRenderAssetStore();
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(
+      host = await constructRuntimeRendererHost(
         mockCanvas,
         {},
         {
           shaderManifestUrl: ENGINE_MANIFEST_URL,
-          assetResolver: assetStore.resolver,
         },
       );
     } finally {
       globalThis.navigator.gpu.requestAdapter = originalRequestAdapter;
     }
-    expect(renderer.backend).toBe('webgpu');
-
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
-    if (!ready.ok) return;
+    expect(host.ok).toBe(true);
+    if (!host.ok) throw host.error;
+    const { renderer, assets } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
 
     const device = sharedDevice;
     expect(device).toBeDefined();
@@ -451,7 +439,7 @@ describe('bug-20260522 AC-01 per-entity material texture isolation (dawn)', () =
     // texture POD is catalogued (GUID->payload SSOT) and the extract stage
     // resolves it to a user-tier column handle via world.allocSharedRef.
     const texGreenGuid2 = AssetGuid.random();
-    assetStore.resolver.publish(AssetGuid.format(texGreenGuid2), makeChequerTexture(0, 200, 0));
+    assets.catalog(texGreenGuid2, makeChequerTexture(0, 200, 0));
     const matA = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', {
       kind: 'material',
       passes: [