@forgeax/engine-runtime 0.1.28 → 0.1.29

package/src/__tests__/parse-scene-payload-refs.cases.unit.test.ts

@@ -436,22 +436,24 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A, GUID_B];
       const payload = {
-        entities: [
-          {
-            localId: 0,
+        entities: {
+          'entity-0': {
             components: {
               MeshFilter: { assetHandle: 0 },
               MeshRenderer: { materials: [1] },
             },
           },
-        ],
+        },
       };
       const asset = fn('scene', payload, refs);
       expect(asset).toBeDefined();
       if (!asset) return;
       expect(asset.kind).toBe('scene');
-      expect(asset.entities.length).toBe(1);
-      const comp = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
+      expect(Object.keys(asset.entities).length).toBe(1);
+      const comp = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       expect(comp.MeshFilter?.assetHandle).toBe(GUID_A); // refs[0]
       expect(comp.MeshRenderer?.materials).toEqual([GUID_B]); // refs[1]
     });
@@ -461,17 +463,15 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A];
       const payload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: 0 } },
-          },
-        ],
+        entities: { 'entity-0': { components: { MeshFilter: { assetHandle: 0 } } } },
       };
       const asset = fn('scene', payload, refs);
       expect(asset).toBeDefined();
       if (!asset) return;
-      const comp = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
+      const comp = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       expect(comp.MeshFilter?.assetHandle).toBe(GUID_A);
     });
 
@@ -480,20 +480,22 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A];
       const payload = {
-        entities: [
-          {
-            localId: 0,
+        entities: {
+          'entity-0': {
             components: {
               Transform: { pos: [1.5, 2.7, -3.2] },
               DirectionalLight: { color: 'white', intensity: 0.8 },
             },
           },
-        ],
+        },
       };
       const asset = fn('scene', payload, refs);
       expect(asset).toBeDefined();
       if (!asset) return;
-      const comp = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
+      const comp = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       // Non-integer float values are not refs indices — passed through unchanged.
       expect(comp.Transform?.pos).toEqual([1.5, 2.7, -3.2]);
       expect(comp.DirectionalLight?.color).toBe('white');
@@ -505,23 +507,25 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A];
       const payload = {
-        entities: [
-          {
-            localId: 0,
+        entities: {
+          'entity-0': {
             components: {
-              ChildOf: { parent: 0 },
+              ChildOf: { parent: 'entity-0' },
               Transform: { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] },
               MeshFilter: { assetHandle: 0 },
             },
           },
-        ],
+        },
       };
       const asset = fn('scene', payload, refs);
       expect(asset).toBeDefined();
       if (!asset) return;
-      const comp = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
+      const comp = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       // Non-handle integer fields are kept as-is (M1-fixup F-1)
-      expect(comp.ChildOf?.parent).toBe(0);
+      expect(comp.ChildOf?.parent).toBe('entity-0');
       expect(comp.Transform?.pos).toEqual([0, 0, 0]);
       expect(comp.Transform?.quat).toEqual([0, 0, 0, 1]);
       expect(comp.Transform?.scale).toEqual([1, 1, 1]);
@@ -534,28 +538,28 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A, GUID_B];
       const payload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: 0 } },
-          },
-          {
-            localId: 1,
-            components: { MeshFilter: { assetHandle: 1 } },
-          },
-          {
-            localId: 2,
-            components: { MeshRenderer: { materials: [0] } },
-          },
-        ],
+        entities: {
+          'entity-0': { components: { MeshFilter: { assetHandle: 0 } } },
+          'entity-1': { components: { MeshFilter: { assetHandle: 1 } } },
+          'entity-2': { components: { MeshRenderer: { materials: [0] } } },
+        },
       };
       const asset = fn('scene', payload, refs);
       expect(asset).toBeDefined();
       if (!asset) return;
-      expect(asset.entities.length).toBe(3);
-      const comp0 = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
-      const comp1 = asset.entities[1]?.components as Record<string, Record<string, unknown>>;
-      const comp2 = asset.entities[2]?.components as Record<string, Record<string, unknown>>;
+      expect(Object.keys(asset.entities).length).toBe(3);
+      const comp0 = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
+      const comp1 = asset.entities['entity-1']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
+      const comp2 = asset.entities['entity-2']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       expect(comp0.MeshFilter?.assetHandle).toBe(GUID_A);
       expect(comp1.MeshFilter?.assetHandle).toBe(GUID_B);
       expect(comp2.MeshRenderer?.materials).toEqual([GUID_A]);
@@ -568,12 +572,7 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A]; // length=1, valid indices: 0 only
       const payload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: 1 } }, // N=1 >= refs.length
-          },
-        ],
+        entities: { 'entity-0': { components: { MeshFilter: { assetHandle: 1 } } } },
       };
       const result = fn('scene', payload, refs);
       expect(result).toBeUndefined();
@@ -584,12 +583,7 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs: string[] = [];
       const payload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: 0 } }, // N=0 >= refs.length (0 >= 0)
-          },
-        ],
+        entities: { 'entity-0': { components: { MeshFilter: { assetHandle: 0 } } } },
       };
       const result = fn('scene', payload, refs);
       expect(result).toBeUndefined();
@@ -600,16 +594,10 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A]; // length=1
       const payload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: 1 } }, // first node: out of bounds
-          },
-          {
-            localId: 1,
-            components: { MeshFilter: { assetHandle: 0 } }, // second node: valid, but should not be reached
-          },
-        ],
+        entities: {
+          'entity-0': { components: { MeshFilter: { assetHandle: 1 } } },
+          'entity-1': { components: { MeshFilter: { assetHandle: 0 } } },
+        },
       };
       // parseScenePayload returns undefined on first error, so result is undefined
       // regardless of the second node's validity
@@ -622,12 +610,7 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A];
       const payload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: -1 } },
-          },
-        ],
+        entities: { 'entity-0': { components: { MeshFilter: { assetHandle: -1 } } } },
       };
       const result = fn('scene', payload, refs);
       expect(result).toBeUndefined();
@@ -637,21 +620,23 @@ type __MergedKeep =
       const reg = new AssetRegistry(makeMockShaderRegistry());
       const fn = accessParseScenePayload(reg);
       const payload = {
-        entities: [
-          {
-            localId: 0,
+        entities: {
+          'entity-0': {
             components: {
               MeshFilter: { assetHandle: 42 },
               MeshRenderer: { materials: [1024] },
             },
           },
-        ],
+        },
       };
       // No refs passed -- old call signature, numbers should pass through
       const asset = fn('scene', payload);
       expect(asset).toBeDefined();
       if (!asset) return;
-      const comp = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
+      const comp = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       expect(comp.MeshFilter?.assetHandle).toBe(42);
       expect(comp.MeshRenderer?.materials).toEqual([1024]);
     });
@@ -661,17 +646,19 @@ type __MergedKeep =
       const fn = accessParseScenePayload(reg);
       const refs = [GUID_A];
       const payload = {
-        entities: [
-          {
-            localId: 0,
+        entities: {
+          'entity-0': {
             components: { Transform: { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
           },
-        ],
+        },
       };
       const asset = fn('scene', payload, refs);
       expect(asset).toBeDefined();
       if (!asset) return;
-      const comp = asset.entities[0]?.components as Record<string, Record<string, unknown>>;
+      const comp = asset.entities['entity-0']?.components as Record<
+        string,
+        Record<string, unknown>
+      >;
       // M1-fixup F-1: non-handle integer fields (Transform) are preserved as-is.
       // Only fields in the HANDLE_FIELD_NAMES allowlist get refs resolution.
       expect(comp.Transform?.pos).toEqual([0, 0, 0]);
@@ -690,12 +677,7 @@ type __MergedKeep =
       // parseAssetPayload returns { ok: false, error }, then fetchPackFile
       // wraps it as asset-parse-failed.
       const badPayload = {
-        entities: [
-          {
-            localId: 0,
-            components: { MeshFilter: { assetHandle: 5 } }, // refs length is 3, 5 is out of bounds
-          },
-        ],
+        entities: { 'entity-0': { components: { MeshFilter: { assetHandle: 5 } } } },
       };
       const packEntry = {
         guid: '00000000-0000-7000-8000-000000000099',
@@ -724,7 +706,7 @@ type __MergedKeep =
       // the LoaderOutput { ok: false, error } arm (no instance-slot side effect).
       const result = internal.parseAssetPayload('scene', badPayload, packEntry.refs) as {
         ok: false;
-        error: { index: number; refsLength: number };
+        error: { entityKey: string; index: number; refsLength: number };
       };
       expect(result.ok).toBe(false);
       expect(result.error.index).toBe(5);
@@ -735,12 +717,7 @@ type __MergedKeep =
       // biome-ignore lint/suspicious/noExplicitAny: private method access
       const internal = reg as any;
       const badPayload = {
-        entities: [
-          {
-            localId: 42,
-            components: { MeshFilter: { assetHandle: 5 } },
-          },
-        ],
+        entities: { 'entity-42': { components: { MeshFilter: { assetHandle: 5 } } } },
       };
       const refs = ['guid-a', 'guid-b']; // length=2, 5 is out of bounds
       // F21: the structured error is the return value's `error` field, not a
@@ -748,7 +725,7 @@ type __MergedKeep =
       const result = internal.parseAssetPayload('scene', badPayload, refs) as {
         ok: false;
         error: {
-          localId: number;
+          entityKey: string;
           component: string;
           field: string;
           index: number;
@@ -757,7 +734,7 @@ type __MergedKeep =
       };
       expect(result.ok).toBe(false);
       const err = result.error;
-      expect(err.localId).toBe(42);
+      expect(err.entityKey).toBe('entity-42');
       expect(err.component).toBe('MeshFilter');
       expect(err.field).toBe('assetHandle');
       expect(err.index).toBe(5);

package/src/__tests__/pbr-pipeline.unit.test.ts

@@ -102,7 +102,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('pbr-material-merged', () => {
-    it('24 entries: user-region 15 (derived) + ibl 7 + transmission 2', () => {
+    it('25 entries: user-region 15 + ibl 7 + transmission 2 + scene material 1', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-material-merged',
@@ -114,10 +114,18 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
       const afterIbl = [...userRegion, ...appendInjection(userRegion, 'ibl')];
       const expected = {
         label: 'pbr-material-skylight-bgl',
-        entries: [...afterIbl, ...appendInjection(afterIbl, 'transmission')],
+        entries: [
+          ...afterIbl,
+          ...appendInjection(afterIbl, 'transmission'),
+          {
+            binding: 46,
+            visibility: 0x1 | 0x2,
+            buffer: { type: 'read-only-storage', hasDynamicOffset: false },
+          },
+        ],
       };
       expect(out).toEqual(expected);
-      expect(out.entries.length).toBe(24);
+      expect(out.entries.length).toBe(25);
     });
 
     it('adds only authored physical map pairs after the canonical injection chain', () => {
@@ -131,10 +139,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
         kind: 'pbr-material-merged',
         materialParamSchema: schema,
       });
-      expect(out.entries.map((entry) => entry.binding)).toEqual([
-        ...Array.from({ length: 28 }, (_, index) => index),
-      ]);
-      expect(out.entries.slice(24).map((entry) => entry.binding)).toEqual([24, 25, 26, 27]);
+      expect(out.entries.slice(24).map((entry) => entry.binding)).toEqual([26, 27, 30, 31, 46]);
     });
   });
 
@@ -168,7 +173,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('pbr-instances', () => {
-    it('storageBuffer=true: 1 entry with read-only-storage, no dynamic offset', () => {
+    it('storageBuffer=true: one vertex-visible read-only-storage entry', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-instances',
@@ -186,13 +191,22 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
       });
     });
 
-    it('storageBuffer=false: falls back to uniform', () => {
+    it('storageBuffer=false: one entry falls back to uniform', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-instances',
         caps: { storageBuffer: false },
       });
-      expect(out.entries[0]?.buffer?.type).toBe('uniform');
+      expect(out).toEqual({
+        label: 'pbr-instances-bgl',
+        entries: [
+          {
+            binding: 0,
+            visibility: 0x3,
+            buffer: { type: 'uniform', hasDynamicOffset: false },
+          },
+        ],
+      });
     });
   });
 
@@ -208,7 +222,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
         entries: [
           {
             binding: 0,
-            visibility: 0x1,
+            visibility: 0x3,
             buffer: { type: 'read-only-storage', hasDynamicOffset: true },
           },
           {

package/src/__tests__/point-light-shadow.browser.test.ts

@@ -232,7 +232,11 @@ function spawnPointShadowScene(world: World, withShadow: boolean): void {
     .unwrap();
   world
     .spawn(
-      { component: Transform, data: { pos: [0, -1.65, 0], scale: [3.5, 0.15, 3.5] } },
+      // A receiver wall sits behind the cube so the point light's occlusion
+      // lands on a camera-visible surface. The old floor-only witness could
+      // miss the shadow entirely at the fixed camera pose and make a valid
+      // shadow pass look identical to the no-shadow baseline.
+      { component: Transform, data: { pos: [0, 0, -0.65], scale: [5, 5, 0.1] } },
       { component: MeshFilter, data: { assetHandle: HANDLE_CUBE } },
       { component: MeshRenderer, data: { materials: [material] } },
     )
@@ -246,7 +250,9 @@ function spawnPointShadowScene(world: World, withShadow: boolean): void {
   world
     .spawn({
       component: DirectionalLight,
-      data: { direction: [-0.4, -0.8, -1], intensity: 0.35, castShadow: false },
+      // Keep the point light as the only direct source; a directional fill
+      // would mask a broken point-shadow factor in this pixel witness.
+      data: { direction: [-0.4, -0.8, -1], intensity: 0, castShadow: false },
     })
     .unwrap();
   const point = [1.8, 2.6, 2.2] as const;

package/src/__tests__/point-light-shadow.unit.test.ts

@@ -270,18 +270,49 @@ function spawnValidatedPointShadow(
         }
       });
 
-      it('AC-03: lightPos=(0,0,0) near=0.1 far=10 — face +X projects (1,0,0) into NDC z=1 (far) at depth-far plane', () => {
+      it('projects off-axis casters to the texel addressed by a raw cube direction on all six faces', () => {
+        const position = vec3.create(2, 3, 4);
+        const shadowMatrices = buildPointShadowMatrices(position, 0.1, 25);
+        // WebGPU cube face table: each direction addresses UV=(0.25,0.75).
+        // Independent of either camera/matrix helper, and not on a face axis.
+        const directions = [
+          [2, -1, 1],
+          [-2, -1, -1],
+          [-1, 2, 1],
+          [-1, -2, -1],
+          [-1, -1, 2],
+          [1, -1, -2],
+        ] as const;
+        for (const [index, matrix] of shadowMatrices.entries()) {
+          const direction = directions[index];
+          if (direction === undefined) throw new Error('missing cube direction');
+          const point = [
+            (position[0] ?? 0) + direction[0],
+            (position[1] ?? 0) + direction[1],
+            (position[2] ?? 0) + direction[2],
+            1,
+          ];
+          const clip = [0, 1, 2, 3].map((row) =>
+            point.reduce((sum, value, column) => sum + value * (matrix[column * 4 + row] ?? 0), 0),
+          );
+          const w = clip[3] ?? 1;
+          expect(((clip[0] ?? 0) / w) * 0.5 + 0.5).toBeCloseTo(0.25, 6);
+          expect(0.5 - ((clip[1] ?? 0) / w) * 0.5).toBeCloseTo(0.75, 6);
+        }
+      });
+
+      it('cube +X projects world -X far plane to NDC z=1', () => {
         // Reference: WebGPU [0, 1] NDC. far point on the face axis maps to ndc_z=1.
         const ms = buildPointShadowMatrices(vec3.create(0, 0, 0), 0.1, 10);
         const faceM = ms[0] ?? new Float32Array(16);
-        // A point at (10, 0, 0) — exactly far distance along +X — should project
+        // A point at (+10, 0, 0) — far distance along cube +X — should project
         // to NDC z = 1 (WebGPU convention, far plane).
         const p = projectPoint(faceM, 10, 0, 0);
         const ndcZ = p.z / p.w;
         expect(ndcZ).toBeCloseTo(1.0, 5);
       });
 
-      it('AC-03: face +X projects (0.1, 0, 0) — near point — to NDC z=0', () => {
+      it('cube +X projects world -X near plane to NDC z=0', () => {
         const ms = buildPointShadowMatrices(vec3.create(0, 0, 0), 0.1, 10);
         const faceM = ms[0] ?? new Float32Array(16);
         const p = projectPoint(faceM, 0.1, 0, 0);
@@ -291,8 +322,7 @@ function spawnValidatedPointShadow(
 
       it('AC-03: each face projects its forward axis point at far depth to NDC z=1', () => {
         const ms = buildPointShadowMatrices(vec3.create(0, 0, 0), 0.1, 10);
-        // For each face, the "far" point along the look direction (in world
-        // space) should map to NDC z = 1.
+        // Directions are in the negated-world cube basis used for sampling.
         const lookDirs: ReadonlyArray<readonly [number, number, number]> = [
           [10, 0, 0], // +X
           [-10, 0, 0], // -X
@@ -330,7 +360,7 @@ function spawnValidatedPointShadow(
       });
 
       it('AC-03: WebGPU [0,1] NDC depth — out-of-frustum mid-distance maps to ndc_z in (0, 1)', () => {
-        // Pick a mid-point along +X face axis (5 units, between near=0.1 and far=10).
+        // Pick a mid-point along cube +X (world +X).
         const ms = buildPointShadowMatrices(vec3.create(0, 0, 0), 0.1, 10);
         const faceM = ms[0] ?? new Float32Array(16);
         const p = projectPoint(faceM, 5, 0, 0);
@@ -343,8 +373,7 @@ function spawnValidatedPointShadow(
       it('AC-03: lightPos translation — origin reference point at (lightPos + far*lookDir) maps to ndc_z=1', () => {
         const lightPos = vec3.create(2, 3, 4);
         const ms = buildPointShadowMatrices(lightPos, 0.1, 10);
-        // Face +X: world point at lightPos + (10, 0, 0) = (12, 3, 4) is at far
-        // plane along the +X face look direction.
+        // Cube +X: world point lightPos + (10, 0, 0) is on the far plane.
         // biome-ignore lint/style/noNonNullAssertion: ms.length === 6
         const faceM = ms[0]!;
         const p = projectPoint(faceM, 12, 3, 4);

package/src/__tests__/record-all-topology.cases.unit.test.ts

@@ -604,5 +604,57 @@ type __MergedKeep =
         expect(errors).toEqual([]);
       });
     }
+
+    it('vertex-only mesh uses draw() without an index buffer', async () => {
+      const spies = makePassSpies();
+      const { renderer } = await setupRenderer(spies);
+      const errors: string[] = [];
+      renderer.onError((e) => errors.push(e.code));
+
+      const world = await spawnScene(renderer, meshForTopology('line-list'));
+      if (!(renderer as unknown as RendererType).attach(world as WorldType).ok) {
+        throw new Error('World attachment failed');
+      }
+      (world as WorldType).update().unwrap();
+      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      spies.draw.mockClear();
+      spies.drawIndexed.mockClear();
+      spies.setIndexBuffer.mockClear();
+      spies.setVertexBuffer.mockClear();
+      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+
+      expect(spies.draw).toHaveBeenCalled();
+      expect(spies.drawIndexed).not.toHaveBeenCalled();
+      expect(spies.setIndexBuffer).not.toHaveBeenCalled();
+      expect(spies.setVertexBuffer).toHaveBeenCalled();
+      expect(spies.draw.mock.calls[0]?.[0]).toBe(3);
+      expect(errors).toEqual([]);
+    });
+
+    it('indexed mesh uses setIndexBuffer() and drawIndexed()', async () => {
+      const spies = makePassSpies();
+      const { renderer } = await setupRenderer(spies);
+      const errors: string[] = [];
+      renderer.onError((e) => errors.push(e.code));
+
+      const world = await spawnScene(renderer, meshForTopology('triangle-list'));
+      if (!(renderer as unknown as RendererType).attach(world as WorldType).ok) {
+        throw new Error('World attachment failed');
+      }
+      (world as WorldType).update().unwrap();
+      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      spies.draw.mockClear();
+      spies.drawIndexed.mockClear();
+      spies.setIndexBuffer.mockClear();
+      spies.setVertexBuffer.mockClear();
+      renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
+
+      expect(spies.setIndexBuffer).toHaveBeenCalled();
+      expect(spies.drawIndexed).toHaveBeenCalled();
+      expect(spies.setVertexBuffer).toHaveBeenCalled();
+      expect(errors).toEqual([]);
+    });
   });
 }

package/src/__tests__/record-draw-branch.cases.unit.test.ts

@@ -1,3 +1,4 @@
+// @perf-budget-skip: intentional full mock-GPU renderer setup for indexed/non-indexed draw dispatch.
 // @ts-nocheck — merged file: cross-source node:fs/node:path imports outside @types/node coverage in runtime tsconfig
 // Consolidated by feat-20260609-test-pool-startup-reduction-merge-tiny-test-files
 // biome-ignore-all lint/complexity/noUselessLoneBlockStatements: block-scope isolation between merged source files (consolidation paradigm)