@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/clamp-to-last.e2e.browser.test.ts

@@ -32,12 +32,12 @@
 //
 // Runs via pnpm test:browser against wgpu-wasm/WebGL2 backend.
 
+import { HANDLE_CUBE } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render/internal';
+import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { afterEach, describe, expect, it } from 'vitest';
-import { Engine } from '../index';
+import { constructRuntimeRendererHost } from '../renderer-host';
 
 const W = 256;
 const H = 256;
@@ -61,12 +61,8 @@ const SUT_ATTRIBUTABLE_RENDER_CODES: ReadonlySet<string> = new Set([
   'vertex-storage-buffer-unavailable',
   'mesh-ssbo-capacity-exceeded',
   'mesh-ssbo-ceiling-reached',
-  'hdrp-caps-insufficient',
   'hdrp-light-budget-exceeded',
   'hdrp-index-list-overflow',
-  'hdrp-deferred-caps-insufficient',
-  'gbuffer-rt-alloc-failed',
-  'gbuffer-attachment-count-mismatch',
 ]);
 
 // Suppress WebGPU teardown race: chromium fires unhandled OperationError
@@ -83,11 +79,21 @@ if (typeof window !== 'undefined') {
 
 const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
 
-type EngineRenderer = Awaited<ReturnType<typeof Engine.create>>;
+type EngineRenderer = import('@forgeax/engine-render').Renderer;
 
 async function buildRenderer(canvas: HTMLCanvasElement): Promise<EngineRenderer> {
-  const r = await Engine.create(canvas, {}, { shaderManifestUrl: '/shaders/manifest.json' });
-  return r;
+  const host = await constructRuntimeRendererHost(
+    canvas,
+    {},
+    {
+      shaderManifestUrl: '/shaders/manifest.json',
+    },
+  );
+  if (!host.ok) throw host.error;
+  if (host.value.renderer.inspect().state !== 'alive') {
+    throw new Error('runtime renderer host did not reach alive state');
+  }
+  return host.value.renderer;
 }
 
 describe('clamp-to-last e2e browser (m3-w6)', () => {
@@ -117,7 +123,7 @@ describe('clamp-to-last e2e browser (m3-w6)', () => {
   //
   // Design: built-in PBR falls back to single UV; multi-UV is consumed
   // only by custom materials (per user verdict in implement-review).
-  // The unit cube carries exactly 1 UV set, which is the default PBR
+  // HANDLE_CUBE carries exactly 1 UV set, which is the default PBR
   // baseline — PSO build must succeed and draw must not fire
   // SUT-attributable errors.
   //
@@ -136,11 +142,8 @@ describe('clamp-to-last e2e browser (m3-w6)', () => {
     document.body.appendChild(canvas);
 
     renderer = await buildRenderer(canvas);
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
 
     const world = new World();
-    const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
     world.spawn(
       {
         component: Transform,
@@ -150,7 +153,7 @@ describe('clamp-to-last e2e browser (m3-w6)', () => {
           scale: [1, 1, 1],
         },
       },
-      { component: MeshFilter, data: { assetHandle: cubeHandle } },
+      { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: {} },
     );
     world.spawn(
@@ -166,14 +169,21 @@ describe('clamp-to-last e2e browser (m3-w6)', () => {
     );
 
     const sutErrors: Array<{ code: string }> = [];
-    renderer.onError((e) => {
-      sutErrors.push(e);
+    renderer.subscribe((event) => {
+      if (event.kind !== 'error') return;
+      sutErrors.push(event.error);
     });
 
-    expect(renderer.attachWorld(world).ok).toBe(true);
+    const attachment = renderer.attach(world);
+    expect(attachment.ok).toBe(true);
+    if (!attachment.ok) throw attachment.error;
     for (let f = 0; f < 10; f++) {
       world.update(1 / 60).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);
     }
 

package/src/__tests__/collect-scene-asset.test.ts

@@ -1,3 +1,5 @@
+import * as SceneOwner from '@forgeax/engine-scene';
+
 // w9 — writeback round-trip semantic equivalence tests, migrated to
 // rootsToSceneAsset (plan-strategy D-1: semantic equivalence not byte
 // equivalence because full writeback materializes defaults — decisions #8 OOS).
@@ -20,33 +22,32 @@
 //   component-level keys, not entity-level entries.
 //   VERDICT: zero expectations encoded pre-fix bug.
 
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { type Component, defineComponent as defineEcsComponent, World } from '@forgeax/engine-ecs';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { SceneInstance } from '@forgeax/engine-render';
+import { ChildOf, Children, Transform } from '@forgeax/engine-scene';
 import type { LocalEntityId, SceneAsset, SceneEntity } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import '@forgeax/engine-render/internal';
-import '@forgeax/engine-render/internal';
-import * as SceneOwner from '@forgeax/engine-scene';
-import { Transform } from '@forgeax/engine-scene';
 import { rootsToSceneAsset, serializeSceneAssetToPack } from '../collect-scene-asset';
-import { registerSceneComponents } from './helpers/register-scene-components';
-import { createTestSceneAssetStore } from './helpers/scene-asset-port';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 
 const TEST_COMPONENTS: Component[] = [];
-type EcsDefineComponent = typeof defineEcsComponent;
-
-function defineComponent(
-  name: Parameters<EcsDefineComponent>[0],
-  fields: Parameters<EcsDefineComponent>[1],
-  options?: Parameters<EcsDefineComponent>[2],
-): ReturnType<EcsDefineComponent> {
-  const component = defineEcsComponent(name, fields, options);
+
+function defineComponent(name: string, fields: Record<string, unknown>): Component {
+  const component = defineEcsComponent(name, fields as never);
   TEST_COMPONENTS.push(component);
   return component;
 }
 
-function makeRegistry() {
-  return createTestSceneAssetStore();
+function registerSceneComponents(world: World): void {
+  for (const component of [SceneInstance, ChildOf, Children, Transform, ...TEST_COMPONENTS]) {
+    world.components.register(component).unwrap();
+  }
+}
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
 }
 
 function localId(n: number): LocalEntityId {
@@ -55,7 +56,7 @@ function localId(n: number): LocalEntityId {
 
 // biome-ignore lint/suspicious/noExplicitAny: allocSharedRef('SceneAsset') returns branded Handle<"SceneAsset", ...> but instantiateScene expects Handle<string, ...>
 function registerSceneAsset(world: World, asset: SceneAsset): any {
-  registerSceneComponents(world, TEST_COMPONENTS);
+  registerSceneComponents(world);
   return world.allocSharedRef('SceneAsset', asset);
 }
 
@@ -96,14 +97,14 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -130,14 +131,14 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -164,14 +165,14 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -187,7 +188,7 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     // Empty scene may still instantiate; root should be present.
@@ -195,7 +196,7 @@ describe('w9 — round-trip semantic equivalence', () => {
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -217,14 +218,14 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -256,14 +257,14 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -288,14 +289,14 @@ describe('w9 — round-trip semantic equivalence', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const scene = collected.value;
@@ -317,9 +318,7 @@ describe('w9 — round-trip semantic equivalence', () => {
   });
 
   it('(h) serializeSceneAssetToPack produces valid pack envelope', () => {
-    const component = defineComponent('Test_Pack', { a: 'f32' });
-    const world = new World();
-    world.components.register(component).unwrap();
+    defineComponent('Test_Pack', { a: 'f32' });
 
     const asset: SceneAsset = {
       kind: 'scene',
@@ -328,7 +327,7 @@ describe('w9 — round-trip semantic equivalence', () => {
 
     const packResult = serializeSceneAssetToPack(
       asset,
-      world.components.entries(),
+      new Map(),
       'aaaaaaaa-bbbb-4ccc-dddd-eeeeeeeeeeee',
     );
     expect(packResult.ok).toBe(true);
@@ -368,7 +367,7 @@ describe('w9 — round-trip semantic equivalence', () => {
   });
 
   it('(j) full round-trip instantiate->collect->serialize->check', () => {
-    const component = defineComponent('Test_Full', {
+    defineComponent('Test_Full', {
       posX: 'f32',
       posY: 'f32',
       name: 'string',
@@ -383,17 +382,16 @@ describe('w9 — round-trip semantic equivalence', () => {
     };
 
     const world = new World();
-    world.components.register(component).unwrap();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
     const root = res.value.root;
 
-    const collected = rootsToSceneAsset(reg.port, world, [root]);
+    const collected = rootsToSceneAsset(reg, world, [root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     // root + 2 children = 3 entities.
@@ -452,13 +450,13 @@ describe('w1 — field-level transient collect skip (AC-02 + AC-03)', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -506,13 +504,13 @@ describe('w1 — field-level transient collect skip (AC-02 + AC-03)', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -538,13 +536,13 @@ describe('w1 — field-level transient collect skip (AC-02 + AC-03)', () => {
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
     if (!res.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [res.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -560,23 +558,22 @@ describe('w1 — field-level transient collect skip (AC-02 + AC-03)', () => {
 // Pack v2 payload so marker components such as AudioListener survive reopen.
 describe('marker component scene-pack round-trip', () => {
   it('preserves an authored empty-schema component', () => {
-    const component = defineComponent('Test_EmptySchemaMarker', {});
+    defineComponent('Test_EmptySchemaMarker', {});
     const asset: SceneAsset = {
       kind: 'scene',
       entities: [{ localId: localId(0), components: { Test_EmptySchemaMarker: {} } }],
     };
 
     const world = new World();
-    world.components.register(component).unwrap();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const instantiated = SceneOwner.worldInstantiateScene(world, handle);
     expect(instantiated.ok).toBe(true);
     if (!instantiated.ok) return;
 
-    const collected = rootsToSceneAsset(reg.port, world, [instantiated.value.root]);
+    const collected = rootsToSceneAsset(reg, world, [instantiated.value.root]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
     const collectedEntity = findEntityWith(collected.value.entities, 'Test_EmptySchemaMarker');
@@ -615,7 +612,7 @@ describe('w4 -- Transform vec serialization shape (AC-05)', () => {
       })
       .unwrap();
 
-    const collected = rootsToSceneAsset(reg.port, world, [e]);
+    const collected = rootsToSceneAsset(reg, world, [e]);
     expect(collected.ok).toBe(true);
     if (!collected.ok) return;
 
@@ -656,7 +653,7 @@ describe('w4 -- old-shape scene JSON downgrade regression (research Finding 3)',
     const world = new World();
     const reg = makeRegistry();
     const sg = AssetGuid.parse('00000000-0000-0000-0000-000000000000');
-    if (sg.ok) reg.add(sg.value, asset);
+    if (sg.ok) reg.catalog(sg.value, asset);
     const handle = registerSceneAsset(world, asset);
     const res = SceneOwner.worldInstantiateScene(world, handle);
     expect(res.ok).toBe(true);
@@ -672,7 +669,7 @@ describe('w4 -- old-shape scene JSON downgrade regression (research Finding 3)',
     // The carrying entity degrades to the identity transform (defaults).
     const tfEntity = findEntityWith(
       (() => {
-        const collected = rootsToSceneAsset(reg.port, world, [res.value.root]);
+        const collected = rootsToSceneAsset(reg, world, [res.value.root]);
         if (!collected.ok) throw new Error('collect failed');
         return collected.value.entities;
       })(),