@forgeax/engine-runtime 0.1.3 → 0.1.6

package/src/__tests__/render-system-cross-world-overlay-queue.test.ts

@@ -26,14 +26,14 @@
 //     depthWriteEnabled=false existing mechanism)
 //   plan-strategy §4 risk "cross-world Overlay sort fails" countermeasure
 
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import type { RenderAssetPort } from '@forgeax/engine-render/internal';
-import { Camera, extractFrames, MeshFilter, MeshRenderer } from '@forgeax/engine-render/internal';
+import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { Transform } from '@forgeax/engine-scene';
 import { ShaderRegistry, type ShaderRegistryDevice } from '@forgeax/engine-shader';
 import type { Handle, MaterialAsset, MaterialPass, MeshAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { createTestRenderAssetOwner } from './helpers/render-asset-port';
+import { extractFrames } from '../../../render/src/render-system-extract';
 
 // Two-index owner shape w4-w6 introduces (see w1 for rationale).
 interface OwnerSplit {
@@ -43,7 +43,7 @@ interface OwnerSplit {
 type ExtractFramesOwnerSplit = (
   worlds: readonly World[],
   owner: OwnerSplit,
-  assets?: RenderAssetPort | null,
+  assets?: AssetRegistry | null,
 ) => ReturnType<typeof extractFrames>;
 const extractFramesSplit = extractFrames as unknown as ExtractFramesOwnerSplit;
 
@@ -144,7 +144,7 @@ describe('cross-world Overlay queue merge (w2, AC-03)', () => {
     // editorWorld (index 1): the gizmo overlay renderable at queue=4000.
     const editorWorld = makeRenderableWorld(QUEUE_OVERLAY);
 
-    const assets = createTestRenderAssetOwner(makeShaderRegistry());
+    const assets = new AssetRegistry(makeShaderRegistry());
     // cameraOwner=0 (scene camera), resourceOwner=0 (scene singletons); the
     // editorWorld contributes renderables that must merge into the global queue.
     const frame = extractFramesSplit(

package/src/__tests__/render-system-extract-dispatch-ordering.test.ts

@@ -2,7 +2,7 @@
 //
 // Regression lock for the M2.5 `pendingDispatch` + `flushPendingDispatch`
 // pairing that ships with the Stage 1 aabb restore. After M1 restored
-// The quad primitive's local-space aabb lets builtin quads enter the frustum-cull
+// HANDLE_QUAD's local-space aabb, builtin quads enter the frustum-cull
 // three-gate branch at `render-system-extract.ts` like any user asset.
 // Before M2.5 the three `dispatch.push` sites ran BEFORE the cull `continue`
 // so a culled entity left dangling dispatch entries whose `renderableIndex`
@@ -49,21 +49,14 @@
 // cross-stage checks live in the hello-shadow-opt-out / deferred-shading
 // dawn smokes (per plan-strategy §5.5).
 
+import { AssetRegistry, HANDLE_QUAD } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  Camera,
-  extractFrame,
-  Instances,
-  MeshFilter,
-  MeshRenderer,
-  prepareExtractContext,
-} from '@forgeax/engine-render/internal';
+import { Camera, Instances, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { propagateTransforms, Transform } from '@forgeax/engine-scene';
 import type { MaterialAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
-import { createTestRenderAssetOwner } from './helpers/render-asset-port';
 
 function identityTransform() {
   return {
@@ -123,10 +116,6 @@ function registerUnlitMaterial(world: World, rgb: readonly [number, number, numb
   });
 }
 
-function createQuadHandle(world: World) {
-  return world.internSharedRef('MeshAsset', createPrimitiveMesh('quad').unwrap());
-}
-
 function expectSlotAlignment(
   frame: ReturnType<typeof extractFrame>,
   { requireBaseColorEquality }: { requireBaseColorEquality: boolean },
@@ -156,8 +145,7 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     // renderable pushes into slot 0. Distinct materials make the aliasing
     // observable via paramSnapshot.baseColor equality.
     const world = new World();
-    const quadHandle = createQuadHandle(world);
-    const assets = createTestRenderAssetOwner(makeMockShaderRegistry());
+    const assets = new AssetRegistry(makeMockShaderRegistry());
     spawnFrontFacingCamera(world);
 
     const matGreen = registerUnlitMaterial(world, [0, 1, 0]);
@@ -166,14 +154,14 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     world
       .spawn(
         { component: Transform, data: transformAtZ(100) },
-        { component: MeshFilter, data: { assetHandle: quadHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: { materials: [matGreen] } },
       )
       .unwrap();
     world
       .spawn(
         { component: Transform, data: identityTransform() },
-        { component: MeshFilter, data: { assetHandle: quadHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: { materials: [matRed] } },
       )
       .unwrap();
@@ -201,20 +189,19 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     // at push-sites B and C. plan-strategy §D-7 explicitly names this branch
     // as part of the M2.5 fix scope (shadow-opt-out AC-13 depends on it).
     const world = new World();
-    const quadHandle = createQuadHandle(world);
     spawnFrontFacingCamera(world);
 
     world
       .spawn(
         { component: Transform, data: transformAtZ(100) },
-        { component: MeshFilter, data: { assetHandle: quadHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: {} as never },
       )
       .unwrap();
     world
       .spawn(
         { component: Transform, data: identityTransform() },
-        { component: MeshFilter, data: { assetHandle: quadHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: {} as never },
       )
       .unwrap();
@@ -243,8 +230,7 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     // Transform + local aabb (pre-instance transforms), so an Instances
     // entity at posZ=100 is culled the same way a plain entity is.
     const world = new World();
-    const quadHandle = createQuadHandle(world);
-    const assets = createTestRenderAssetOwner(makeMockShaderRegistry());
+    const assets = new AssetRegistry(makeMockShaderRegistry());
     spawnFrontFacingCamera(world);
 
     const matBlue = registerUnlitMaterial(world, [0, 0, 1]);
@@ -263,7 +249,7 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     world
       .spawn(
         { component: Transform, data: transformAtZ(100) },
-        { component: MeshFilter, data: { assetHandle: quadHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: { materials: [matBlue] } },
         { component: Instances, data: { transforms: instanceTransforms } },
       )
@@ -271,7 +257,7 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     world
       .spawn(
         { component: Transform, data: identityTransform() },
-        { component: MeshFilter, data: { assetHandle: quadHandle } },
+        { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
         { component: MeshRenderer, data: { materials: [matYellow] } },
         { component: Instances, data: { transforms: instanceTransforms } },
       )
@@ -289,14 +275,13 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
     expectSlotAlignment(frame, { requireBaseColorEquality: true });
   });
 
-  it('push A + flush 3 negative path (all quad entities out of view): zero renderables and zero dispatch', () => {
-    // Edge case from requirements §edge-cases row 4: with all quad
+  it('push A + flush 3 negative path (all HANDLE_QUAD entities out of view): zero renderables and zero dispatch', () => {
+    // Edge case from requirements §edge-cases row 4: with all HANDLE_QUAD
     // entities off-frustum, `renderables` and `dispatch` both empty; the
     // per-entity `pendingDispatch` is dropped on every cull `continue` so
     // no dangling entries leak into the shared `dispatch[]`.
     const world = new World();
-    const quadHandle = createQuadHandle(world);
-    const assets = createTestRenderAssetOwner(makeMockShaderRegistry());
+    const assets = new AssetRegistry(makeMockShaderRegistry());
     spawnFrontFacingCamera(world);
 
     const matGrey = registerUnlitMaterial(world, [0.5, 0.5, 0.5]);
@@ -304,7 +289,7 @@ describe('render-system-extract M2.5 dispatch/renderable slot pairing (AC-06)',
       world
         .spawn(
           { component: Transform, data: transformAtZ(100 + n) },
-          { component: MeshFilter, data: { assetHandle: quadHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_QUAD } },
           { component: MeshRenderer, data: { materials: [matGrey] } },
         )
         .unwrap();

package/src/__tests__/render-system-extract.test.ts

@@ -6,22 +6,18 @@
 // Each original file body sits in its own block-scope so helper names
 // cannot collide; describe() inside still registers globally with vitest.
 
+import { AssetRegistry, HANDLE_CUBE, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
 import { mat4, vec3 } from '@forgeax/engine-math';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
-import type { RenderAssetPort } from '@forgeax/engine-render/internal';
 import {
   Camera,
   DirectionalLight,
-  extractFrame,
-  extractFrames,
   MeshFilter,
   MeshRenderer,
   PointLight,
-  prepareExtractContext,
   SpotLight,
-} from '@forgeax/engine-render/internal';
+} from '@forgeax/engine-render';
 import { ChildOf, propagateTransforms, Transform } from '@forgeax/engine-scene';
 import { ShaderRegistry, type ShaderRegistryDevice } from '@forgeax/engine-shader';
 import type {
@@ -33,12 +29,12 @@ import type {
 } from '@forgeax/engine-types';
 import { srgbChannelToLinear } from '@forgeax/engine-types';
 import { describe, expect, it, vi } from 'vitest';
-import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 import {
-  createTestRenderAssetOwner,
-  createTestRenderAssetStore,
-  type TestRenderAssetResolver,
-} from './helpers/render-asset-port';
+  extractFrame,
+  extractFrames,
+  prepareExtractContext,
+} from '../../../render/src/render-system-extract';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
 
 // ─── from render-system-extract.test.ts ───
 {
@@ -153,15 +149,11 @@ import {
     });
   }
 
-  function registerBuiltinCube(world: World): Handle<'MeshAsset', 'shared'> {
-    return world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
-  }
-
   describe('render-system-extract consumer migration (w9, AC-07 / AC-15)', () => {
     it('reuses one frame-local material snapshot for repeated shared handles', () => {
       const world = new World();
       spawnCamera(world);
-      const assets = createTestRenderAssetOwner(makeMockShaderRegistry());
+      const assets = new AssetRegistry(makeMockShaderRegistry());
       const mesh = registerMesh(world);
       const material = registerMaterial(world);
 
@@ -188,7 +180,6 @@ import {
 
     it('mesh-walk: RenderableSnapshot.transform.world is the resolved world mat4 (parent x child), zero per-snapshot compose', () => {
       const world = new World();
-      const cubeHandle = registerBuiltinCube(world);
       world
         .spawn(
           { component: Transform, data: { ...identity(), pos: [12, 3, 5] } },
@@ -202,7 +193,7 @@ import {
         .spawn(
           { component: Transform, data: { ...identity(), pos: [2, 3, 0] } },
           { component: ChildOf, data: { parent } },
-          { component: MeshFilter, data: { assetHandle: cubeHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
           { component: MeshRenderer, data: {} },
         )
         .unwrap();
@@ -223,7 +214,6 @@ import {
 
     it('mesh-walk: flat root world mat4 equals compose(local)', () => {
       const world = new World();
-      const cubeHandle = registerBuiltinCube(world);
       world
         .spawn(
           { component: Transform, data: { ...identity(), pos: [5, 6, 12] } },
@@ -233,7 +223,7 @@ import {
       world
         .spawn(
           { component: Transform, data: { ...identity(), pos: [5, 6, 7], scale: [2, 1, 1] } },
-          { component: MeshFilter, data: { assetHandle: cubeHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
           { component: MeshRenderer, data: {} },
         )
         .unwrap();
@@ -380,12 +370,11 @@ import {
 
     it('AC-02: builtin MeshAsset AABB enters the same frustum path as imported meshes', () => {
       const world = new World();
-      const cubeHandle = registerBuiltinCube(world);
       spawnCamera(world);
       world
         .spawn(
           { component: Transform, data: { ...identity(), pos: [0, 0, 200] } },
-          { component: MeshFilter, data: { assetHandle: cubeHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
           { component: MeshRenderer, data: {} },
         )
         .unwrap();
@@ -407,18 +396,17 @@ import {
         .unwrap();
 
       const sceneWorld = new World();
-      const cubeHandle = registerBuiltinCube(sceneWorld);
       sceneWorld
         .spawn(
           { component: Transform, data: { ...identity(), pos: [0, 0, 0] } },
-          { component: MeshFilter, data: { assetHandle: cubeHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
           { component: MeshRenderer, data: {} },
         )
         .unwrap();
       sceneWorld
         .spawn(
           { component: Transform, data: { ...identity(), pos: [0, 0, 200] } },
-          { component: MeshFilter, data: { assetHandle: cubeHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
           { component: MeshRenderer, data: {} },
         )
         .unwrap();
@@ -477,12 +465,11 @@ import {
 
     it('AC-15: mesh-walk reads world via the column array view, not a per-renderable world.get materialization', () => {
       const world = new World();
-      const cubeHandle = registerBuiltinCube(world);
       spawnCamera(world);
       world
         .spawn(
           { component: Transform, data: { ...identity(), pos: [1, 2, 3] } },
-          { component: MeshFilter, data: { assetHandle: cubeHandle } },
+          { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
           { component: MeshRenderer, data: {} },
         )
         .unwrap();
@@ -580,7 +567,7 @@ import {
   // that GUID; the returned handle is what MeshRenderer.materials carries.
   function registerMaterial(
     world: World,
-    resolver: TestRenderAssetResolver,
+    assets: AssetRegistry,
     passes: MaterialPass[] | undefined,
     parentGuid?: AssetGuid,
     values?: Readonly<Record<string, unknown>>,
@@ -594,7 +581,7 @@ import {
       (asset as { parent: AssetGuid }).parent = parentGuid;
     }
     const guid = AssetGuid.random();
-    resolver.publish(AssetGuid.format(guid), asset);
+    assets.catalog(guid, asset);
     const handle = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', asset);
     return { handle, guid };
   }
@@ -665,11 +652,11 @@ import {
     it('AC-05 core signal: child no-passes inherits passes from parent via extract', () => {
       const world = makeWorldWithComponents();
       spawnCamera(world);
-      const { port: assets, resolver } = createTestRenderAssetStore(makeMockShaderRegistry());
+      const assets = new AssetRegistry(makeMockShaderRegistry());
       const mesh = registerTestMesh(world);
 
-      const parentMat = registerMaterial(world, resolver, [FORWARD_PBR_PASS]);
-      const childMat = registerMaterial(world, resolver, undefined, parentMat.guid);
+      const parentMat = registerMaterial(world, assets, [FORWARD_PBR_PASS]);
+      const childMat = registerMaterial(world, assets, undefined, parentMat.guid);
 
       spawnRenderable(world, mesh, childMat.handle);
 
@@ -692,14 +679,14 @@ import {
     it('AC-06 shoot-76 equivalent: N children inherit from 1 parent', () => {
       const world = makeWorldWithComponents();
       spawnCamera(world);
-      const { port: assets, resolver } = createTestRenderAssetStore(makeMockShaderRegistry());
+      const assets = new AssetRegistry(makeMockShaderRegistry());
       const mesh = registerTestMesh(world);
 
-      const parentMat = registerMaterial(world, resolver, [FORWARD_PBR_PASS]);
+      const parentMat = registerMaterial(world, assets, [FORWARD_PBR_PASS]);
 
       const childCount = 76;
       for (let i = 0; i < childCount; i++) {
-        const childMat = registerMaterial(world, resolver, undefined, parentMat.guid);
+        const childMat = registerMaterial(world, assets, undefined, parentMat.guid);
         // Spread across Z axis (0 to -60) so all entities stay within
         // the perspective camera frustum (far=100, fov=PI/4 at (0,0,5)).
         spawnRenderable(world, mesh, childMat.handle, 0, 0, -i * 0.8);
@@ -726,14 +713,14 @@ import {
     it('AC-06 values shallow-merge: child overrides parent, parent-only key retained', () => {
       const world = makeWorldWithComponents();
       spawnCamera(world);
-      const { port: assets, resolver } = createTestRenderAssetStore(makeMockShaderRegistry());
+      const assets = new AssetRegistry(makeMockShaderRegistry());
       const mesh = registerTestMesh(world);
 
-      const parentMat = registerMaterial(world, resolver, [FORWARD_PBR_PASS], undefined, {
+      const parentMat = registerMaterial(world, assets, [FORWARD_PBR_PASS], undefined, {
         metallic: 0.3,
         roughness: 0.7,
       });
-      const childMat = registerMaterial(world, resolver, undefined, parentMat.guid, {
+      const childMat = registerMaterial(world, assets, undefined, parentMat.guid, {
         metallic: 0.9,
       });
 
@@ -759,10 +746,10 @@ import {
     it('no-parent regression: material without parent still extracts correctly', () => {
       const world = makeWorldWithComponents();
       spawnCamera(world);
-      const { port: assets, resolver } = createTestRenderAssetStore(makeMockShaderRegistry());
+      const assets = new AssetRegistry(makeMockShaderRegistry());
       const mesh = registerTestMesh(world);
 
-      const mat = registerMaterial(world, resolver, [FORWARD_UNLIT_PASS], undefined, {
+      const mat = registerMaterial(world, assets, [FORWARD_UNLIT_PASS], undefined, {
         baseColor: [0.2, 0.3, 0.4],
       });
 
@@ -877,10 +864,10 @@ import {
 
   function spawnSpriteScene(values: Record<string, unknown>): {
     world: World;
-    assets: RenderAssetPort;
+    assets: AssetRegistry;
   } {
     const world = new World();
-    const assets = createTestRenderAssetOwner(makeShaderRegistryWithSprite());
+    const assets = new AssetRegistry(makeShaderRegistryWithSprite());
     const mesh = registerSpriteMesh(world);
     const matHandle = world.allocSharedRef<'MaterialAsset', MaterialAsset>('MaterialAsset', {
       kind: 'material',
@@ -1219,12 +1206,10 @@ import {
   describe('render-system-extract heightTexture (4th texture) snapshot pass-through (M2 w3)', () => {
     it('resolves a binary AssetGuid texture reference through the material owner path', () => {
       const world = new World();
-      const { port: assets, resolver } = createTestRenderAssetStore(
-        makeShaderRegistryWithParallax(),
-      );
+      const assets = new AssetRegistry(makeShaderRegistryWithParallax());
       const mesh = registerQuadMesh(world);
       const textureGuid = AssetGuid.random();
-      resolver.publish(AssetGuid.format(textureGuid), {
+      assets.catalog(textureGuid, {
         kind: 'texture',
         width: 1,
         height: 1,
@@ -1251,14 +1236,14 @@ import {
       const frame = extractFrame(world, prepareExtractContext(world, { assets }));
       const textureHandle = frame.renderables[0]?.material.textureHandles?.get('baseColorTexture');
       expect(textureHandle).toBeDefined();
-      expect(
-        world.sharedRefs.resolve<string, TextureAsset>(textureHandle as never).unwrap().kind,
-      ).toBe('texture');
+      expect(resolveAssetHandle<TextureAsset>(world, textureHandle as never).unwrap().kind).toBe(
+        'texture',
+      );
     });
 
     it('MaterialSnapshot.textureHandles carries heightTexture handle (non-undefined, matches input)', () => {
       const world = new World();
-      const assets = createTestRenderAssetOwner(makeShaderRegistryWithParallax());
+      const assets = new AssetRegistry(makeShaderRegistryWithParallax());
       const mesh = registerQuadMesh(world);
 
       const baseColorHandle = makeTextureHandle(world);
@@ -1331,7 +1316,7 @@ import {
 
     it('keeps built-in PBR texture handles when its manifest schema is empty', () => {
       const world = new World();
-      const assets = createTestRenderAssetOwner(makeShaderRegistryWithEmptyBuiltinPbrSchema());
+      const assets = new AssetRegistry(makeShaderRegistryWithEmptyBuiltinPbrSchema());
       const mesh = registerQuadMesh(world);
       const baseColorHandle = makeTextureHandle(world);
       const metallicRoughnessHandle = makeTextureHandle(world);