@forgeax/engine-runtime 0.1.4 → 0.1.7

package/src/__tests__/fxaa-pixel-diff.dawn.test.ts

@@ -6,8 +6,8 @@
 // Follows the user-handle-mesh-render.dawn.test.ts pattern for canvas mock,
 // device capture, and pixel readback.
 
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
 import {
   ANTIALIAS_FXAA,
   ANTIALIAS_NONE,
@@ -15,10 +15,10 @@ import {
   MeshFilter,
   MeshRenderer,
   TONEMAP_NONE,
-} from '@forgeax/engine-render/internal';
+} from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../index';
+import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 
 const WIDTH = 256;
@@ -63,7 +63,6 @@ async function doReadPixels(device: GPUDevice, renderTarget: GPUTexture): Promis
 }
 
 function spawnCubeScene(world: World, antialias: number, tonemap?: number): void {
-  const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   world.spawn(
     {
       component: Transform,
@@ -73,7 +72,7 @@ function spawnCubeScene(world: World, antialias: number, tonemap?: number): void
         scale: [1, 1, 1],
       },
     },
-    { component: MeshFilter, data: { assetHandle: cubeHandle } },
+    { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
     { component: MeshRenderer, data: {} },
   );
   const cameraData: Record<string, number> = {
@@ -157,16 +156,22 @@ describe('feat-20260528-fxaa-post-processing M3 w16: AC-03 pixel diff + AC-04 to
       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 } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const device = sharedDevice;
     if (device === undefined) throw new Error('GPUDevice not captured');
 
@@ -256,16 +261,22 @@ describe('feat-20260528-fxaa-post-processing M3 w16: AC-03 pixel diff + AC-04 to
       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 } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const device = sharedDevice;
     if (device === undefined) throw new Error('GPUDevice not captured');
 

package/src/__tests__/fxaa-validation-and-resize.dawn.test.ts

@@ -8,17 +8,17 @@
 // Follows the user-handle-mesh-render.dawn.test.ts pattern for canvas mock,
 // device capture, and pixel readback.
 
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import { ANTIALIAS_FXAA, Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render/internal';
+import { ANTIALIAS_FXAA, Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../index';
+import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 
 const WIDTH = 256;
 const HEIGHT = 256;
-// feat-20260608 TASK-007 dropped clearColor from createRenderer; the
+// feat-20260608 TASK-007 dropped clearColor from runtime host options; the
 // per-Camera clearR/G/B/A is now the SSOT. AC-08 resize asserts
 // `r+g+b > 0` on the post-resize center pixel, which cannot rely on a
 // non-black default clear -- wire the original [0.06, 0.06, 0.08, 1]
@@ -70,7 +70,6 @@ async function doReadPixels(
 }
 
 function spawnCubeScene(world: World): void {
-  const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
   world.spawn(
     {
       component: Transform,
@@ -80,7 +79,7 @@ function spawnCubeScene(world: World): void {
         scale: [1, 1, 1],
       },
     },
-    { component: MeshFilter, data: { assetHandle: cubeHandle } },
+    { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
     { component: MeshRenderer, data: {} },
   );
   world.spawn(
@@ -163,16 +162,22 @@ describe('feat-20260528-fxaa-post-processing M3 w17: AC-07 validation + AC-08 re
       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 } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const device = sharedDevice;
     if (device === undefined) throw new Error('GPUDevice not captured');
 
@@ -295,16 +300,22 @@ describe('feat-20260528-fxaa-post-processing M3 w17: AC-07 validation + AC-08 re
       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 } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
     const device = sharedDevice;
     if (device === undefined) throw new Error('GPUDevice not captured');
 

package/src/__tests__/fxaa-zero-overhead.dawn.test.ts

@@ -8,12 +8,12 @@
 // Follows the user-handle-mesh-render.dawn.test.ts pattern for canvas mock,
 // device capture, and pixel readback.
 
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import { ANTIALIAS_NONE, Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render/internal';
+import { ANTIALIAS_NONE, Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../index';
+import { constructRuntimeRendererHost } from '../renderer-host';
 import { drawPublished } from './draw-published';
 
 const WIDTH = 256;
@@ -101,21 +101,25 @@ describe('feat-20260528-fxaa-post-processing M3 w14: AC-02 zero-overhead pixel t
       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 } = host.value;
+    expect(renderer.inspect().state).toBe('alive');
 
     // Build a hello-cube scene with antialias='none' (default).
     const world = new World();
-    const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     world.spawn(
       {
         component: Transform,
@@ -125,7 +129,7 @@ describe('feat-20260528-fxaa-post-processing M3 w14: AC-02 zero-overhead pixel t
           scale: [1, 1, 1],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: {} },
     );
     world.spawn(