@forgeax/engine-runtime 0.1.28 → 0.1.29

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

@@ -12,6 +12,7 @@ import type { Renderer as RendererType } from '@forgeax/engine-render';
 import {
   Camera,
   DirectionalLight,
+  InstanceCollectionStore,
   Instances,
   MeshFilter,
   MeshRenderer,
@@ -213,6 +214,7 @@ function drawPublished(renderer: RendererType, world: WorldType) {
             },
             setVertexBuffer: () => undefined,
             setIndexBuffer: () => undefined,
+            setViewport: () => undefined,
             setBindGroup: (groupIndex: number, _bg: unknown, dynamicOffsets?: number[]) => {
               log.setBindGroupCount++;
               // w8-A: capture mesh uniform buffer offset at group=2.
@@ -297,6 +299,7 @@ function drawPublished(renderer: RendererType, world: WorldType) {
       materialShaders: [
         materialShaderStub('forgeax::default-standard-pbr'),
         materialShaderStub('forgeax::default-unlit'),
+        materialShaderStub('forgeax::default-shadow-caster'),
       ],
     };
     return `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
@@ -435,7 +438,10 @@ function drawPublished(renderer: RendererType, world: WorldType) {
       drawPublished(renderer, world as WorldType);
 
       // DirectionalLight with merged shadow fields.
-      expect(errors).toHaveLength(0);
+      expect(
+        errors,
+        JSON.stringify(errors, (_key, value) => (value instanceof Error ? value.stack : value)),
+      ).toHaveLength(0);
       // Standard Cluster owns the shadow, G-buffer, lighting, forward, and
       // output topology stages. Keep this structural rather than freezing a
       // pass-count literal that changes when a named stage is split.
@@ -1523,33 +1529,16 @@ describe('RenderSystem Skylight extract + record phase contract (plan-strategy D
   });
 });
 
-// ─── from render-system-stride.test.ts ───
+// ─── from render-system-instance-collection.test.ts ───
 {
-  // w14 - RenderSystem extract entry stride defensive test (M3, AC-06).
-  //
-  // Locks the AC-06 invariant: when an entity carries an `Instances` component
-  // whose `transforms` array<f32> snapshot has a length that is NOT a multiple
-  // of 16, the RenderSystem extract stage MUST emit a structured `EcsError`
-  // with `code: 'instance-transforms-stride-mismatch'` BEFORE the GPU upload
-  // path is reached. The error carries a discriminated `.detail` per
-  // `EcsErrorDetail`:
-  //
-  //   detail = { actualLength: number, expectedStride: 16 }
+  // Renderer-owned collection authoring and extract boundary coverage.
   //
-  // Coverage matrix:
-  //   (a) length === 16  -> pass; no error fires; renderable lands.
-  //   (b) length === 32  -> pass; no error fires; renderable lands.
-  //   (c) length === 15  -> fail; structured error fires with detail; no
-  //                         renderable lands.
-  //   (d) length === 17  -> fail; structured error fires with detail; no
-  //                         renderable lands.
+  // The ECS component carries only a collection id. The renderer validates the
+  // canonical packed matrix payload before publication and reports a typed
+  // InstanceCollectionError; malformed input never reaches GPU upload.
   //
-  // The defensive lives in `packages/runtime/src/render-system-extract.ts`
-  // inside the `Instances` archetype loop, immediately after the
-  // `world.get(entity, Instances)` snapshot is extracted but BEFORE any
-  // per-element copy / GPU upload. Violation routes through Layer-3
-  // `World._errorHandler` (set via `world.setErrorHandler`); the renderable
-  // MUST NOT be pushed (fail-fast halts the per-entity branch).
+  // Coverage keeps legal collection association visible and rejects malformed
+  // stride/range input with the Render-owned error facts.
 
   interface CollectedError {
     readonly code: string;
@@ -1564,7 +1553,11 @@ describe('RenderSystem Skylight extract + record phase contract (plan-strategy D
     return { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] };
   }
 
-  function makeWorld(): { world: World; collected: CollectedError[] } {
+  function makeWorld(): {
+    world: World;
+    collected: CollectedError[];
+    instanceCollections: InstanceCollectionStore;
+  } {
     const collected: CollectedError[] = [];
     const world = new World();
     vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
@@ -1599,10 +1592,15 @@ describe('RenderSystem Skylight extract + record phase contract (plan-strategy D
         },
       })
       .unwrap();
-    return { world, collected };
+    return { world, collected, instanceCollections: new InstanceCollectionStore() };
   }
 
-  function spawnInstancedEntity(world: World, transforms: Float32Array): void {
+  function spawnInstancedEntity(
+    world: World,
+    instanceCollections: InstanceCollectionStore,
+    transforms: Float32Array,
+  ): void {
+    const collection = instanceCollections.create({ transforms }).unwrap();
     world
       .spawn(
         { component: Transform, data: makeIdentityTransform() },
@@ -1614,58 +1612,48 @@ describe('RenderSystem Skylight extract + record phase contract (plan-strategy D
           component: MeshRenderer,
           data: {} as never,
         },
-        { component: Instances, data: { transforms } },
+        { component: Instances, data: { collectionId: collection.collectionId } },
       )
       .unwrap();
   }
 
-  describe('render-system-extract stride defensive (w14, AC-06)', () => {
+  describe('renderer-owned instance collection validation', () => {
     it('(a) length === 16: no error; renderable lands', () => {
-      const { world, collected } = makeWorld();
+      const { world, collected, instanceCollections } = makeWorld();
       const transforms = new Float32Array(16);
-      spawnInstancedEntity(world, transforms);
-      const frame = extractFrame(world, prepareExtractContext(world));
-      expect(collected.filter((c) => c.code === 'instance-transforms-stride-mismatch').length).toBe(
-        0,
-      );
+      spawnInstancedEntity(world, instanceCollections, transforms);
+      const frame = extractFrame(world, prepareExtractContext(world, { instanceCollections }));
+      expect(collected).toHaveLength(0);
       expect(frame.renderables.length).toBe(1);
     });
 
     it('(b) length === 32: no error; renderable lands', () => {
-      const { world, collected } = makeWorld();
+      const { world, collected, instanceCollections } = makeWorld();
       const transforms = new Float32Array(32);
-      spawnInstancedEntity(world, transforms);
-      const frame = extractFrame(world, prepareExtractContext(world));
-      expect(collected.filter((c) => c.code === 'instance-transforms-stride-mismatch').length).toBe(
-        0,
-      );
+      spawnInstancedEntity(world, instanceCollections, transforms);
+      const frame = extractFrame(world, prepareExtractContext(world, { instanceCollections }));
+      expect(collected).toHaveLength(0);
       expect(frame.renderables.length).toBe(1);
     });
 
-    it('(c) length === 15: structured error fires; detail.actualLength === 15; expectedStride === 16; no renderable', () => {
-      const { world, collected } = makeWorld();
+    it('(c) length === 15: structured authoring error carries typed facts', () => {
+      const { instanceCollections } = makeWorld();
       const transforms = new Float32Array(15);
-      spawnInstancedEntity(world, transforms);
-      const frame = extractFrame(world, prepareExtractContext(world));
-      const stride = collected.filter((c) => c.code === 'instance-transforms-stride-mismatch');
-      expect(stride.length).toBe(1);
-      const detail = stride[0]?.detail as { actualLength: number; expectedStride: 16 };
-      expect(detail.actualLength).toBe(15);
-      expect(detail.expectedStride).toBe(16);
-      expect(frame.renderables.length).toBe(0);
+      const result = instanceCollections.create({ transforms });
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.code).toBe('instance-collection-invalid');
+      expect(result.error.detail?.actual).toBe(15);
     });
 
-    it('(d) length === 17: structured error fires; detail.actualLength === 17; expectedStride === 16; no renderable', () => {
-      const { world, collected } = makeWorld();
+    it('(d) length === 17: structured authoring error carries typed facts', () => {
+      const { instanceCollections } = makeWorld();
       const transforms = new Float32Array(17);
-      spawnInstancedEntity(world, transforms);
-      const frame = extractFrame(world, prepareExtractContext(world));
-      const stride = collected.filter((c) => c.code === 'instance-transforms-stride-mismatch');
-      expect(stride.length).toBe(1);
-      const detail = stride[0]?.detail as { actualLength: number; expectedStride: 16 };
-      expect(detail.actualLength).toBe(17);
-      expect(detail.expectedStride).toBe(16);
-      expect(frame.renderables.length).toBe(0);
+      const result = instanceCollections.create({ transforms });
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error.code).toBe('instance-collection-invalid');
+      expect(result.error.detail?.actual).toBe(17);
     });
   });
 }

package/src/__tests__/renderer-device-loss-provider-feasibility.dawn.test.ts

@@ -112,7 +112,6 @@ describe('real Dawn device-loss provider feasibility', () => {
               'No test-visible non-destroyed loss injection method is exposed by the real Dawn GPU, adapter, or device objects',
             providerSurface,
           };
-    console.log(`[dawn-loss-feasibility] ${JSON.stringify(evidence)}`);
     expect(evidence.submittedWork).toBe(true);
     expect(['available', 'insufficient-evidence']).toContain(evidence.status);
     if (evidence.status === 'available') {

package/src/__tests__/renderer-device-loss-recovery.dawn.test.ts

@@ -39,9 +39,6 @@ describe('real Dawn renderer device-loss recovery', () => {
         'A non-destroyed raw loss was observed, but this fixture does not exercise public Renderer recovery',
       );
     }
-    console.log(
-      `[dawn-loss-recovery] ${JSON.stringify({ ...evidence, rawLoss: rawLoss ?? 'provider-missing' })}`,
-    );
     expect(evidence.submittedWork).toBe(true);
     expect(evidence.worlds).toHaveLength(2);
     expect(evidence.status).toBe('insufficient-evidence');