@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/dawn/hello-sprite-nineslice-section.dawn.test.ts

@@ -44,21 +44,14 @@
 // Each scene captures the rendered RGBA, then the comparator across the two
 // captured byte arrays asserts mid-band divergence.
 
-import { createWorldContext, World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import { renderComponentsPlugin } from '@forgeax/engine-render';
+import { AssetRegistry, HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { SPRITE_PREMULTIPLIED_ALPHA_BLEND } from '@forgeax/engine-render/authoring';
-import {
-  ANTIALIAS_NONE,
-  Camera,
-  MeshFilter,
-  MeshRenderer,
-  TONEMAP_NONE,
-} from '@forgeax/engine-render/internal';
-import { createRenderer } from '@forgeax/engine-runtime';
-import { scenePlugin, Transform } from '@forgeax/engine-scene';
+import { Transform } from '@forgeax/engine-scene';
 import type { MaterialAsset, TextureAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { constructRuntimeRendererHost } from '../../renderer-host';
 import { drawPublished } from '../draw-published';
 
 const WIDTH = 64;
@@ -179,39 +172,28 @@ async function renderOneFrame(opts: {
     removeEventListener() {},
   } as unknown as HTMLCanvasElement;
 
-  let renderer: Awaited<ReturnType<typeof createRenderer>>;
+  let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
   try {
-    renderer = await createRenderer(mockCanvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+    host = await constructRuntimeRendererHost(
+      mockCanvas,
+      {},
+      {
+        shaderManifestUrl: ENGINE_MANIFEST_URL,
+      },
+    );
   } finally {
     globalThis.navigator.gpu.requestAdapter = originalRequestAdapter;
   }
-  expect(renderer.backend).toBe('webgpu');
-
-  const ready = await renderer.ready;
-  expect(ready.ok).toBe(true);
-  if (!ready.ok) throw new Error('renderer not ready');
+  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 world = new World();
-  await createWorldContext(world, [renderComponentsPlugin(), scenePlugin()]);
-  const nineSliceHandle = world.internSharedRef(
-    'MeshAsset',
-    createPrimitiveMesh('nine-slice-quad').unwrap(),
-  );
 
   const texAsset = makeCornerCheckerTexture();
   const texHandle = world.allocSharedRef<'TextureAsset', TextureAsset>('TextureAsset', texAsset);
-  // feat-20260601-gpu-resource-store-extraction M1: explicit texture GPU upload.
-  const texUploadRes = await renderer.store.uploadTexture(texHandle, texAsset, {
-    bytes: texAsset.data as Uint8Array,
-    width: texAsset.width,
-    height: texAsset.height,
-    mime: 'image/png',
-    colorSpace: texAsset.colorSpace,
-    mipmap: texAsset.mipmap,
-  });
-  expect(texUploadRes.ok).toBe(true);
-  if (!texUploadRes.ok) throw new Error('texture upload failed');
-
   // D-4 explicit constraint: tile mode uses the sprite pipeline's shared
   // renderer-owned repeat sampler, so vertex-shader-emitted uv > 1 wraps via
   // the hardware sampler. Both scenes use that same configuration; the only
@@ -237,37 +219,28 @@ async function renderOneFrame(opts: {
       { name: 'baseColorTexture', type: 'texture', optional: true },
     ],
     values: {
-      colorTint: [1, 1, 1, 1],
-      region: [0, 0, 1, 1],
-      pivotAndSize: [0.5, 0.5, 1, 1],
       // feat-20260625 M3 / w11 (D-4): UBO-aligned field names. The
       // extract-stage backwards-compat fold (render-system-extract.ts
       // L2344) keeps the legacy `slices` + `sliceMode` split working for
       // unmigrated demos, but new tests declare the UBO-aligned
       // `slicesAndMode` vec4 directly: `.xyz` = [left, top, right] in UV,
       // `.w` carries the sliceMode sentinel (>=0 stretch, <0 tile).
-      baseColorTexture: {
-        texture: texHandle as unknown as never,
-        coordinates: {
-          set: 0,
-          transform: { offset: [0, 0], scale: [1, 1], rotation: 0 },
-          physicalUvScale: [1, 1],
-        },
-      },
+      baseColorTexture: { texture: texHandle as unknown as never },
       slicesAndMode: [0.25, 0.25, 0.25, opts.sliceMode === 1 ? -0.25 : 0.25],
     },
   });
 
   const errors: unknown[] = [];
-  renderer.onError((e) => {
-    errors.push(e);
+  renderer.subscribe((event) => {
+    if (event.kind !== 'error') return;
+    errors.push(event.error);
   });
 
   // ASYMMETRIC scale: x=4*y. Under uniform 9-slice mapping the corners stay
   // square so the central band is highly stretched; without 9-slice (legacy
   // path) the entire quad stretches as one. The asymmetry amplifies the
   // mid-band pixel divergence between the two modes after w15 lands.
-  const spriteSpawn = world.spawn(
+  world.spawn(
     {
       component: Transform,
       data: {
@@ -276,12 +249,10 @@ async function renderOneFrame(opts: {
         scale: [opts.scaleX, opts.scaleY, 1],
       },
     },
-    { component: MeshFilter, data: { assetHandle: nineSliceHandle } },
+    { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
     { component: MeshRenderer, data: { materials: [matHandle] } },
   );
-  expect(spriteSpawn.ok).toBe(true);
-
-  const cameraSpawn = world.spawn(
+  world.spawn(
     {
       component: Transform,
       data: {
@@ -292,17 +263,9 @@ async function renderOneFrame(opts: {
     },
     {
       component: Camera,
-      data: {
-        fov: Math.PI / 4,
-        aspect: 1,
-        near: 0.1,
-        far: 100,
-        tonemap: TONEMAP_NONE,
-        antialias: ANTIALIAS_NONE,
-      },
+      data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 },
     },
   );
-  expect(cameraSpawn.ok).toBe(true);
 
   const drawn = drawPublished(renderer, world);
   expect(drawn.ok).toBe(true);
@@ -371,6 +334,7 @@ describe('feat-20260527-sprite-nineslice w14 dawn smoke (stretch vs tile diverge
     // x-band differ between modes; pre-w15 the two scenes are byte-identical.
     const stretch = await renderOneFrame({ sliceMode: 0, scaleX: 4, scaleY: 1 });
     const tile = await renderOneFrame({ sliceMode: 1, scaleX: 4, scaleY: 1 });
+
     expect(stretch.errors).toEqual([]);
     expect(tile.errors).toEqual([]);
 

package/src/__tests__/dawn/ibl-precompute-readback.dawn.test.ts

@@ -16,14 +16,16 @@
 
 import { World } from '@forgeax/engine-ecs';
 import { composeShader } from '@forgeax/engine-naga';
+import { ok, type RhiDevice, type Texture } from '@forgeax/engine-rhi';
+import { _internal_getRawDevice, createShaderModule, rhi } from '@forgeax/engine-rhi-webgpu';
+import type { EquirectAsset, TextureFormat } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { DeviceScope } from '../../../../render/src/device/device-scope';
+import { GpuResidencyCache } from '../../../../render/src/device/gpu-residency';
 import {
-  GpuResourceStore,
   getOrCreateIblCache,
   setIblComposedShaders,
-} from '@forgeax/engine-render/internal';
-import { ok } from '@forgeax/engine-rhi';
-import type { EquirectAsset, TextureFormat } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
+} from '../../../../render/src/ibl/IblPipelineCache';
 
 const mockCaps = {
   backendKind: 'webgpu' as const,
@@ -47,7 +49,7 @@ const mockCaps = {
   maxColorAttachments: 8,
 };
 
-// feat-20260601-gpu-resource-store-extraction M1 (D-3 falsifiable anchor): a
+// feat-20260601-device/gpu-residency-extraction M1 (D-3 falsifiable anchor): a
 // single store._uploadCubemapFromEquirect(world, srcHandle, srcPod) returns the
 // cube handle, and store.getCubemapGpuTexture(cubeHandle) reads it back -- the
 // single-call contract is preserved. The cube POD register-relay is injected
@@ -114,8 +116,17 @@ function makeWhiteEquirect(): EquirectAsset {
   };
 }
 
-// biome-ignore lint/suspicious/noExplicitAny: native GPUDevice has minimal typing here
-async function readbackRgba16f(device: any, texture: any, arrayLayer: number, mipLevel: number) {
+/** Raw resource conversion is confined to this Dawn readback boundary. */
+function rawTexture(texture: Texture): GPUTexture {
+  return texture as unknown as GPUTexture;
+}
+
+async function readbackRgba16f(
+  device: GPUDevice,
+  texture: GPUTexture,
+  arrayLayer: number,
+  mipLevel: number,
+): Promise<number[]> {
   // Read one pixel from (0,0) of (face=arrayLayer, mip=mipLevel).
   const bytesPerRow = 256;
   const buffer = device.createBuffer({
@@ -159,81 +170,79 @@ describe('t51 (M3.5) -- dawn IBL 4-pass non-zero readback', () => {
       // dawn-node tests stand in for vite-plugin-shader by composing on
       // demand via @forgeax/engine-naga.
       await composeIblShadersForDawn();
-      // biome-ignore lint/suspicious/noExplicitAny: dynamic global navigator typed minimally
-      const adapter = await (navigator as any).gpu.requestAdapter();
-      const device = await adapter.requestDevice();
-
-      const store = new GpuResourceStore();
+      const adapterResult = await rhi.requestAdapter();
+      if (!adapterResult.ok) throw adapterResult.error;
+      const deviceResult = await adapterResult.value.requestDevice();
+      if (!deviceResult.ok) throw deviceResult.error;
+      const rhiDevice: RhiDevice = deviceResult.value;
+      const rawDevice = _internal_getRawDevice(rhiDevice);
+      if (rawDevice === undefined) {
+        throw new Error('Dawn IBL readback requires the RHI WebGPU raw-device test boundary');
+      }
+
+      const store = new GpuResidencyCache();
+      const scope = DeviceScope.create(0, 'ibl-dawn-test');
+      store.bindDeviceScope(scope);
       const world = new World();
       const equirect = makeWhiteEquirect();
       const equirectHandle = world.allocSharedRef('EquirectAsset', equirect);
 
-      // We pass the raw GPUDevice directly so the runtime exercises the
-      // same dawn path that user-mesh-upload.dawn.test.ts uses. The cube POD
-      // register-relay is injected here (D-3).
+      // The production path receives the opaque RhiDevice and the same
+      // Result-returning shader factory used by the WebGPU backend. Raw GPU
+      // access remains confined to readback below.
       store.configureGpuDevice(
-        // biome-ignore lint/suspicious/noExplicitAny: dawn device shape
-        device as any,
-        // biome-ignore lint/suspicious/noExplicitAny: dawn device shape
-        async (d: any, desc: { code: string; label?: string }) => {
-          const mod = d.createShaderModule({ code: desc.code, label: desc.label });
-          // biome-ignore lint/suspicious/noExplicitAny: matching shim Result shape
-          return { ok: true, value: mod, unwrap: () => mod, unwrapOr: () => mod } as any;
-        },
+        rhiDevice,
+        undefined,
         (w: World, pod: EquirectAsset) => ok(w.allocSharedRef('EquirectAsset', pod)),
         mockCaps,
       );
+      store.configureIblDevice(rhiDevice, createShaderModule);
 
       // Single call returns the cube handle (D-3 single-call contract). The
       // projection method is @internal (private) after feat-20260630 M2 / w11;
       // the dawn test reaches it through the store internals.
-      // biome-ignore lint/suspicious/noExplicitAny: private method access for the dawn IBL readback probe
-      const result = await (store as any)._uploadCubemapFromEquirect(
-        world,
-        equirectHandle,
-        equirect,
-      );
+      const result = await store._uploadCubemapFromEquirect(world, equirectHandle, equirect);
       expect(result.ok).toBe(true);
       if (!result.ok) return;
 
       const cubeHandle = result.value;
-      // biome-ignore lint/suspicious/noExplicitAny: opaque GPU texture
-      const cubeTexture = store.getCubemapGpuTexture(cubeHandle as any);
+      const cubeTexture = store.getCubemapGpuTexture(cubeHandle);
       expect(cubeTexture).toBeDefined();
+      if (cubeTexture === undefined) return;
 
-      // feat-20260612 M3 / w11 (1c76c1b9): GpuResourceStore handle maps now
+      // feat-20260612 M3 / w11 (1c76c1b9): GpuResidencyCache handle maps now
       // hold the GpuTexture wrapper (`{handle, isDestroyed, destroy()}`).
       // dawn-node `copyTextureToBuffer` consumes the raw GPUTexture handle,
       // so the wrapper unwrap goes via `.handle` here. The IBL cache slots
       // below still hold raw textures (the ibl/IblPipelineCache wrapping is
       // OOS for this feat -- D-8 / OOS-10).
-      // biome-ignore lint/suspicious/noExplicitAny: opaque GPU texture
-      const cubeRaw = (cubeTexture as any).handle;
+      const cubeRaw = rawTexture(cubeTexture.handle);
 
       // (a) equirect-to-cube face 0 center pixel != 0
-      const cubePx = await readbackRgba16f(device, cubeRaw, 0, 0);
+      const cubePx = await readbackRgba16f(rawDevice, cubeRaw, 0, 0);
       expect(cubePx.some((c) => c !== 0)).toBe(true);
 
       // (b) irradiance, (c) prefilter, (d) brdfLut: the textures live on
-      // IblPipelineCache after t52/t53. Read via cache slots.
-      const cache = getOrCreateIblCache(device);
-      // biome-ignore lint/suspicious/noExplicitAny: cache slots typed any
-      const irrTex = (cache as any).irradianceTexture;
-      // biome-ignore lint/suspicious/noExplicitAny: cache slots typed any
-      const prefTex = (cache as any).prefilterTexture;
-      // biome-ignore lint/suspicious/noExplicitAny: cache slots typed any
-      const brdfTex = (cache as any).brdfLutTexture;
+      // IblPipelineCache after t52/t53. Read opaque cache slots through the
+      // test-only raw texture boundary.
+      const cache = getOrCreateIblCache(scope);
+      const {
+        irradianceTexture: irrTex,
+        prefilterTexture: prefTex,
+        brdfLutTexture: brdfTex,
+      } = cache;
       expect(irrTex).toBeDefined();
       expect(prefTex).toBeDefined();
       expect(brdfTex).toBeDefined();
+      if (irrTex === undefined || prefTex === undefined || brdfTex === undefined) return;
 
-      const irrPx = await readbackRgba16f(device, irrTex, 0, 0);
+      const irrPx = await readbackRgba16f(rawDevice, rawTexture(irrTex), 0, 0);
       expect(irrPx.some((c) => c !== 0)).toBe(true);
 
-      const prefPx = await readbackRgba16f(device, prefTex, 0, 0);
+      const prefPx = await readbackRgba16f(rawDevice, rawTexture(prefTex), 0, 0);
       expect(prefPx.some((c) => c !== 0)).toBe(true);
 
-      const brdfPx = await readbackRgba16f(device, brdfTex, 0, 0);
+      const brdfPx = await readbackRgba16f(rawDevice, rawTexture(brdfTex), 0, 0);
       expect(brdfPx.some((c) => c !== 0)).toBe(true);
     },
     60_000,

package/src/__tests__/dawn/instances-per-instance-pbr.dawn.test.ts

@@ -24,19 +24,19 @@
 // Falsification is exercised by the parity smoke (AC-08) and learn-render
 // M3 smoke (AC-09).
 
+import { AssetRegistry, HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
 import {
   Camera,
   DirectionalLight,
   Instances,
   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 { MaterialAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { constructRuntimeRendererHost } from '../../renderer-host';
 import { drawPublished } from '../draw-published';
 
 const WIDTH = 512;
@@ -147,17 +147,23 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(mockCanvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      host = await constructRuntimeRendererHost(
+        mockCanvas,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
     } 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');
+    expect(assets).toBeInstanceOf(AssetRegistry);
 
     // Material creation (PBR standard). D-18: a shared-ref handle is per-World;
     // each frame's World allocs the same payload to get a handle it can resolve.
@@ -182,7 +188,6 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
 
     // --- Frame A: instances=N (grid spread) ---
     const worldN = new World();
-    const cubeHandleN = worldN.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     const matHandleN = worldN.allocSharedRef<'MaterialAsset', MaterialAsset>(
       'MaterialAsset',
       matAsset,
@@ -196,7 +201,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
           scale: [0.5, 0.5, 0.5],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandleN } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandleN] } },
       { component: Instances, data: { transforms: transformsN } },
     );
@@ -263,7 +268,6 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
     singleTransform[15] = 1;
 
     const world1 = new World();
-    const cubeHandle1 = world1.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     const matHandle1 = world1.allocSharedRef<'MaterialAsset', MaterialAsset>(
       'MaterialAsset',
       matAsset,
@@ -277,7 +281,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
           scale: [0.5, 0.5, 0.5],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle1 } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle1] } },
       { component: Instances, data: { transforms: singleTransform } },
     );
@@ -428,17 +432,23 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    let renderer2: Awaited<ReturnType<typeof createRenderer>>;
+    let host2: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer2 = await createRenderer(mockCanvas2, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      host2 = await constructRuntimeRendererHost(
+        mockCanvas2,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
     } finally {
       globalThis.navigator.gpu.requestAdapter = origReqAdapter2;
     }
-    expect(renderer2.backend).toBe('webgpu');
-
-    const ready2 = await renderer2.ready;
-    expect(ready2.ok).toBe(true);
-    if (!ready2.ok) return;
+    expect(host2.ok).toBe(true);
+    if (!host2.ok) throw host2.error;
+    const { renderer: renderer2, assets: assets2 } = host2.value;
+    expect(renderer2.inspect().state).toBe('alive');
+    expect(assets2).toBeInstanceOf(AssetRegistry);
 
     // Unlit material
     const matAsset2: MaterialAsset = {
@@ -457,7 +467,6 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
 
     // Frame A: N instances
     const worldN2 = new World();
-    const cubeHandleN2 = worldN2.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     const matHandleN2 = worldN2.allocSharedRef<'MaterialAsset', MaterialAsset>(
       'MaterialAsset',
       matAsset2,
@@ -471,7 +480,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
           scale: [0.5, 0.5, 0.5],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandleN2 } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandleN2] } },
       { component: Instances, data: { transforms: transformsN2 } },
     );
@@ -486,11 +495,17 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
       },
       { component: Camera, data: { fov: (45 * Math.PI) / 180, aspect: 1, near: 0.1, far: 200 } },
     );
-    expect(renderer2.attachWorld(worldN2).ok).toBe(true);
+    const attachmentN2 = renderer2.attach(worldN2);
+    expect(attachmentN2.ok).toBe(true);
+    if (!attachmentN2.ok) throw attachmentN2.error;
 
     for (let i = 0; i < 5; i++) {
       worldN2.update(1 / 60).unwrap();
-      const r = renderer2.draw([worldN2], { cameraOwner: 0, resourceOwner: 0 });
+      const r = renderer2.draw({
+        leases: [attachmentN2.value],
+        camera: { lease: attachmentN2.value },
+        environment: { lease: attachmentN2.value },
+      });
       if (!r.ok) throw new Error(`draw N frame ${i} error: ${r.error.code}`);
     }
 
@@ -531,7 +546,6 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
     singleTransform2[15] = 1;
 
     const world12 = new World();
-    const cubeHandle12 = world12.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     const matHandle12 = world12.allocSharedRef<'MaterialAsset', MaterialAsset>(
       'MaterialAsset',
       matAsset2,
@@ -545,7 +559,7 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
           scale: [0.5, 0.5, 0.5],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle12 } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle12] } },
       { component: Instances, data: { transforms: singleTransform2 } },
     );
@@ -560,11 +574,17 @@ describe('w2 -- PBR dual-state dawn smoke (AC-01 / AC-06, RED before w4)', () =>
       },
       { component: Camera, data: { fov: (45 * Math.PI) / 180, aspect: 1, near: 0.1, far: 200 } },
     );
-    expect(renderer2.attachWorld(world12).ok).toBe(true);
+    const attachment12 = renderer2.attach(world12);
+    expect(attachment12.ok).toBe(true);
+    if (!attachment12.ok) throw attachment12.error;
 
     for (let i = 0; i < 5; i++) {
       world12.update(1 / 60).unwrap();
-      const r = renderer2.draw([world12], { cameraOwner: 0, resourceOwner: 0 });
+      const r = renderer2.draw({
+        leases: [attachment12.value],
+        camera: { lease: attachment12.value },
+        environment: { lease: attachment12.value },
+      });
       if (!r.ok) throw new Error(`draw 1 frame ${i} error: ${r.error.code}`);
     }
     await device2.queue.onSubmittedWorkDone();

package/src/__tests__/dawn/instances-shadow.dawn.test.ts

@@ -30,19 +30,19 @@
 // gate passes while browser renders black) + comparison-demo-exposes-frozen-fxaa
 // (assert two states differ, don't match one self-made baseline).
 
+import { AssetRegistry, HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
 import {
   Camera,
   DirectionalLight,
   Instances,
   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 { MaterialAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { constructRuntimeRendererHost } from '../../renderer-host';
 
 const WIDTH = 256;
 const HEIGHT = 256;
@@ -154,20 +154,25 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
       removeEventListener() {},
     } as unknown as HTMLCanvasElement;
 
-    let renderer: Awaited<ReturnType<typeof createRenderer>>;
+    let host: Awaited<ReturnType<typeof constructRuntimeRendererHost>>;
     try {
-      renderer = await createRenderer(mockCanvas, {}, { shaderManifestUrl: ENGINE_MANIFEST_URL });
+      host = await constructRuntimeRendererHost(
+        mockCanvas,
+        {},
+        {
+          shaderManifestUrl: ENGINE_MANIFEST_URL,
+        },
+      );
     } finally {
       globalThis.navigator.gpu.requestAdapter = _saved;
     }
-    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 world = new World();
-    const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
 
     const matHandle = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', {
       kind: 'material',
@@ -217,7 +222,7 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
           scale: [12, 0.2, 12],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [floorMatHandle] } },
     );
 
@@ -275,17 +280,23 @@ describe('w10 -- shadow instanced dawn smoke (AC-05 behavioral)', () => {
           scale: [0.5, 0.5, 0.5],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [matHandle] } },
       { component: Instances, data: { transforms: instanceTransforms } },
     );
 
     // Render 300 frames for temporal stability (PCF shadow, light accumulation)
-    expect(renderer.attachWorld(world).ok).toBe(true);
+    const attachment = renderer.attach(world);
+    expect(attachment.ok).toBe(true);
+    if (!attachment.ok) throw attachment.error;
     let drawErrors = 0;
     for (let i = 0; i < 300; i++) {
       world.update(1 / 60).unwrap();
-      const r = renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      const r = renderer.draw({
+        leases: [attachment.value],
+        camera: { lease: attachment.value },
+        environment: { lease: attachment.value },
+      });
       if (!r.ok) drawErrors++;
     }
     expect(drawErrors).toBe(0);