@babylonjsmarket/arcade 0.3.11 → 0.3.12

package/src/Components/KeyboardMover/KeyboardMover.test.ts

@@ -98,4 +98,124 @@ describe('KeyboardMover', () => {
     const move = renderer.calls.find((c) => c.method === 'setMeshPosition');
     expect(move).toBeUndefined();
   });
+
+  it('bridges DOM keydown/keyup events to the bus and moves', () => {
+    // onInitialize installs window listeners in jsdom; a real DOM event should
+    // emit the bus event and drive the mover.
+    const playerEntity = world.createEntity('Player');
+    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: [0, 0, 0] });
+    mesh.handle = renderer.createMesh(playerEntity.id, { kind: 'capsule' });
+    playerEntity.add(mesh);
+    playerEntity.add(new KeyboardMoverComponent({ speed: 10, faceMotion: false }));
+
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyW' }));
+    renderer.calls.length = 0;
+    world.update(0.1);
+    // No camera → fallback forward = -X.
+    const move = renderer.calls.find((c) => c.method === 'setMeshPosition');
+    expect(move).toBeDefined();
+    expect(move!.args[1]).toBeCloseTo(-1, 3);
+
+    // A real keyup stops it.
+    window.dispatchEvent(new KeyboardEvent('keyup', { code: 'KeyW' }));
+    renderer.calls.length = 0;
+    world.update(0.1);
+    expect(renderer.calls.find((c) => c.method === 'setMeshPosition')).toBeUndefined();
+  });
+
+  it('moves along the fallback forward (-X) when there is no camera', () => {
+    const playerEntity = world.createEntity('Player');
+    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: [0, 0, 0] });
+    mesh.handle = renderer.createMesh(playerEntity.id, { kind: 'capsule' });
+    playerEntity.add(mesh);
+    playerEntity.add(new KeyboardMoverComponent({ speed: 10, faceMotion: false }));
+
+    eventBus.emit('keyboard.keydown', { code: 'KeyW' });
+    renderer.calls.length = 0;
+    world.update(0.1);
+
+    const move = renderer.calls.find((c) => c.method === 'setMeshPosition');
+    expect(move).toBeDefined();
+    expect(move!.args[1]).toBeCloseTo(-1, 3);
+    expect(move!.args[3]).toBeCloseTo(0, 3);
+  });
+
+  it('moves back (+X) on S and left (+Z) on A', () => {
+    const camEntity = world.createEntity('Camera');
+    const arc = new ArcCameraComponent({ alpha: 0 });
+    arc.handle = renderer.createArcCamera(camEntity.id, arc.toSpec());
+    getArcCameraRuntime(arc).initialized = true;
+    camEntity.add(arc);
+
+    const playerEntity = world.createEntity('Player');
+    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: [0, 0, 0] });
+    mesh.handle = renderer.createMesh(playerEntity.id, { kind: 'capsule' });
+    playerEntity.add(mesh);
+    playerEntity.add(new KeyboardMoverComponent({ speed: 10, faceMotion: false }));
+
+    // S = back: forward is -X, so back is +X.
+    eventBus.emit('keyboard.keydown', { code: 'KeyS' });
+    renderer.calls.length = 0;
+    world.update(0.1);
+    let move = renderer.calls.find((c) => c.method === 'setMeshPosition');
+    expect(move).toBeDefined();
+    expect(move!.args[1]).toBeCloseTo(1, 3);
+    eventBus.emit('keyboard.keyup', { code: 'KeyS' });
+
+    // A = left: right is (0,0,-1), so left is +Z.
+    mesh.position[0] = 0; mesh.position[2] = 0;
+    eventBus.emit('keyboard.keydown', { code: 'KeyA' });
+    renderer.calls.length = 0;
+    world.update(0.1);
+    move = renderer.calls.find((c) => c.method === 'setMeshPosition');
+    expect(move).toBeDefined();
+    expect(move!.args[3]).toBeCloseTo(1, 3);
+  });
+
+  it('normalizes diagonal input so combined speed is not exaggerated', () => {
+    const camEntity = world.createEntity('Camera');
+    const arc = new ArcCameraComponent({ alpha: 0 });
+    arc.handle = renderer.createArcCamera(camEntity.id, arc.toSpec());
+    getArcCameraRuntime(arc).initialized = true;
+    camEntity.add(arc);
+
+    const playerEntity = world.createEntity('Player');
+    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: [0, 0, 0] });
+    mesh.handle = renderer.createMesh(playerEntity.id, { kind: 'capsule' });
+    playerEntity.add(mesh);
+    playerEntity.add(new KeyboardMoverComponent({ speed: 10, faceMotion: false }));
+
+    // W + D: raw velocity (-1,-1) has length sqrt(2) > 1, so it normalizes.
+    eventBus.emit('keyboard.keydown', { code: 'KeyW' });
+    eventBus.emit('keyboard.keydown', { code: 'KeyD' });
+    renderer.calls.length = 0;
+    world.update(0.1);
+
+    const move = renderer.calls.find((c) => c.method === 'setMeshPosition');
+    expect(move).toBeDefined();
+    const dx = move!.args[1] as number;
+    const dz = move!.args[3] as number;
+    // Per-axis ≈ speed*dt/sqrt(2); combined magnitude ≈ speed*dt (1 unit), not sqrt(2).
+    expect(Math.hypot(dx, dz)).toBeCloseTo(1, 3);
+    expect(Math.abs(dx)).toBeCloseTo(Math.SQRT1_2, 3);
+    expect(Math.abs(dz)).toBeCloseTo(Math.SQRT1_2, 3);
+  });
+
+  it('yaws the mesh to face motion when faceMotion is on', () => {
+    const playerEntity = world.createEntity('Player');
+    const mesh = new MeshPrimitiveComponent({ primitive: 'capsule', position: [0, 0, 0] });
+    mesh.handle = renderer.createMesh(playerEntity.id, { kind: 'capsule' });
+    playerEntity.add(mesh);
+    playerEntity.add(new KeyboardMoverComponent({ speed: 10, faceMotion: true }));
+
+    eventBus.emit('keyboard.keydown', { code: 'KeyW' });
+    renderer.calls.length = 0;
+    world.update(0.1);
+
+    const rot = renderer.calls.find((c) => c.method === 'setMeshRotation');
+    expect(rot).toBeDefined();
+    // Fallback forward is -X (vx=-1, vz=0) → yaw = atan2(-1, 0) = -PI/2.
+    expect(mesh.rotation[1]).toBeCloseTo(Math.atan2(-1, 0), 3);
+    expect(rot!.args[2]).toBeCloseTo(Math.atan2(-1, 0), 3);
+  });
 });

package/src/Components/LineOfSight/LineOfSight.core.test.ts

@@ -57,6 +57,11 @@ describe('inSightCone', () => {
     expect(inSightCone(0, 0, 1, 0, 10, 10, 40, 100)).toBe(false)
     expect(inSightCone(0, 0, 1, 0, 10, 0, 40, 100)).toBe(true)
   })
+
+  it('always sees a target essentially at the viewer', () => {
+    // dist < 1e-4 short-circuits, even with a narrow cone facing away.
+    expect(inSightCone(0, 0, 1, 0, 0, 0, 40, 100)).toBe(true)
+  })
 })
 
 describe('rayFanEndpoints', () => {
@@ -74,6 +79,12 @@ describe('rayFanEndpoints', () => {
     expect(ends[0]![1]).toBeCloseTo(-0.6, 5)
     expect(ends[2]![1]).toBeCloseTo(0.6, 5)
   })
+
+  it('returns a single endpoint at the from point when the target coincides', () => {
+    // dist < 1e-4 short-circuits to one endpoint (no perpendicular axis).
+    const ends = rayFanEndpoints(0, 0, 0, 0, 3, 0.6)
+    expect(ends).toEqual([[0, 0]])
+  })
 })
 
 describe('rayReaches', () => {
@@ -92,6 +103,21 @@ describe('rayReaches', () => {
   it('is blocked by a wall box across the line', () => {
     expect(rayReaches(0, 0, 10, 0, [], 0.6, [{ minX: 4, maxX: 6, minZ: -2, maxZ: 2 }])).toBe(false)
   })
+
+  it('handles a degenerate zero-length segment (from == to)', () => {
+    // segLen2 < 1e-8 → t = 0; occluder at the point is within radius → blocked.
+    expect(rayReaches(0, 0, 0, 0, [{ x: 0, z: 0 }], 0.6)).toBe(false)
+  })
+
+  it('clamps the projection to the segment start when the occluder is behind A', () => {
+    // Occluder just behind A: projection t < 0, clamped to 0, within radius → blocked.
+    expect(rayReaches(0, 0, 10, 0, [{ x: -0.1, z: 0 }], 0.6)).toBe(false)
+  })
+
+  it('clamps the projection to the segment end when the occluder is beyond B', () => {
+    // Occluder just past B: projection t > 1, clamped to 1, within radius → blocked.
+    expect(rayReaches(0, 0, 10, 0, [{ x: 10.1, z: 0 }], 0.6)).toBe(false)
+  })
 })
 
 describe('hasLineOfSight', () => {

package/src/Components/LineOfSight/LineOfSight.test.ts

@@ -77,4 +77,42 @@ describe('LineOfSightSystem', () => {
     world.update(0.016)
     expect(renderer.calls.some((c) => c.method === 'disposeLineSystem')).toBe(true)
   })
+
+  it('updates facing as the seer moves between frames', () => {
+    makePlayer([5, 0.8, 0])
+    const seer = makeSeer([0, 0.5, 0])
+    const m = seer.get(MeshPrimitiveComponent)!
+    world.update(0.016)
+    // Move the seer >1e-3 so the facing-update block runs on the next frame.
+    m.position[0] = 2
+    expect(() => world.update(0.016)).not.toThrow()
+    // Still in clear view of the player → acquired (no spurious loss).
+    expect(acquired).toContain(seer.id)
+    expect(lost).not.toContain(seer.id)
+  })
+
+  it('updates both clear and blocked line systems with debug rays on', () => {
+    // Player in view; a second seer sits squarely between this seer and the
+    // player, blocking its rays. With rays on we expect both line systems to be
+    // updated and made visible (clear for the unblocked seer, blocked for the
+    // occluded one).
+    makePlayer([10, 0.8, 0])
+    makeSeer([5, 0.5, 0]) // blocker between
+    makeSeer([0, 0.5, 0]) // blocked seer
+    makeSeer([9, 0.5, 0]) // clear seer right next to the player
+
+    eventBus.emit(LineOfSightInputEvents.SET_DEBUG_RAYS, { enabled: true })
+    renderer.calls.length = 0
+    world.update(0.016)
+
+    const updates = renderer.calls.filter((c) => c.method === 'updateLineSystem')
+    expect(updates.length).toBeGreaterThanOrEqual(2)
+    // Both visibility toggles fire true (each set has at least one segment).
+    const visTrue = renderer.calls.filter(
+      (c) => c.method === 'setLineSystemVisible' && c.args[1] === true,
+    )
+    expect(visTrue.length).toBeGreaterThanOrEqual(2)
+    // The updates carry non-degenerate segments (more than the single DEGENERATE seg).
+    expect(updates.some((c) => (c.args[1] as unknown[]).length >= 1)).toBe(true)
+  })
 })

package/src/Components/Mesh/Mesh.test.ts

@@ -56,6 +56,20 @@ describe('MeshComponent', () => {
     const copy = new MeshComponent(original.serialize());
     expect(copy.params).toEqual(original.params);
   });
+
+  it('falls back to the default for a malformed position object', () => {
+    const c = new MeshComponent({
+      position: { x: 1, y: 2 } as unknown as { x: number; y: number; z: number },
+    });
+    expect(c.params.position).toEqual([0, 0, 0]);
+  });
+
+  it('falls back to the default for a wrong-length position array', () => {
+    const c = new MeshComponent({
+      position: [1, 2] as unknown as [number, number, number],
+    });
+    expect(c.params.position).toEqual([0, 0, 0]);
+  });
 });
 
 describe('MeshSystem', () => {
@@ -193,6 +207,101 @@ describe('MeshSystem', () => {
     const disposeCalls = renderer.calls.filter((c) => c.method === 'disposeMesh');
     expect(disposeCalls).toHaveLength(1);
   });
+
+  it('creates core instances for entities that existed before the system mounted', () => {
+    const eb = new EventBus();
+    const r = new MockRendererAdapter();
+    const w = new World({ eventBus: eb, renderer: r, detectRaces: false });
+    const entity = w.createEntity();
+    const comp = new MeshComponent({ src: '/pre.glb' });
+    entity.add(comp);
+    // No system yet — instance not created.
+    expect(comp.instance).toBeNull();
+    w.addSystem(new MeshSystem(eb));
+    w.initialize(); // onInitialize walks pre-existing entities → ensureInstance
+    expect(comp.instance).not.toBeNull();
+    expect(comp.instance?.getParams().src).toBe('/pre.glb');
+  });
+
+  it('leaves the core in "loading" when no renderer is attached (unit-test path)', () => {
+    const eb = new EventBus();
+    const w = new World({ eventBus: eb }); // no renderer
+    w.addSystem(new MeshSystem(eb));
+    w.initialize();
+    const entity = w.createEntity();
+    const comp = new MeshComponent({ src: '/a.glb' });
+    entity.add(comp);
+    w.update(1 / 60);
+    // beginLoad ran + LOADING emitted, but with no renderer the load can't
+    // complete, so state stays loading and no loadMesh was recorded.
+    expect(comp.instance?.getState().state).toBe('loading');
+  });
+
+  it('LOAD event finds the entity via the world even before the query indexes it', async () => {
+    const entity = world.createEntity();
+    entity.add(new MeshComponent({ src: '/a.glb', autoLoad: false }));
+    // findEntityById falls through to world.getEntity for this id.
+    eventBus.emit(MeshInputEvents.LOAD, { entityId: entity.id, src: '/override.glb' });
+    await Promise.resolve();
+    await Promise.resolve();
+    const loadCalls = renderer.calls.filter((c) => c.method === 'loadMesh');
+    expect(loadCalls).toHaveLength(1);
+    // The src override flowed through to the resolved url.
+    expect(String(loadCalls[0].args[1] && (loadCalls[0].args[1] as { url: string }).url)).toContain(
+      '/override.glb',
+    );
+  });
+
+  it('LOAD event for an unknown entity id is a no-op', () => {
+    expect(() =>
+      eventBus.emit(MeshInputEvents.LOAD, { entityId: 'ghost' }),
+    ).not.toThrow();
+    expect(renderer.calls.some((c) => c.method === 'loadMesh')).toBe(false);
+  });
+
+  it('stringifies a non-Error rejection into the ERROR event message', async () => {
+    vi.spyOn(renderer, 'loadMesh').mockRejectedValueOnce('plain string failure');
+    const errorSpy = vi.fn();
+    eventBus.on(MeshEvents.ERROR, errorSpy);
+    const entity = world.createEntity();
+    entity.add(new MeshComponent({ src: '/x.glb' }));
+    world.update(1 / 60);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ entityId: entity.id, error: 'plain string failure' }),
+    );
+  });
+
+  it('does not dispatch a load while the component has no src yet', async () => {
+    const entity = world.createEntity();
+    entity.add(new MeshComponent()); // autoLoad true, but src === ''
+    world.update(1 / 60);
+    await Promise.resolve();
+    await Promise.resolve();
+    // dispatchLoad bails at the empty-src guard → no loadMesh, still unloaded.
+    expect(renderer.calls.some((c) => c.method === 'loadMesh')).toBe(false);
+    expect(entity.get(MeshComponent)!.instance?.getState().state).toBe('idle');
+
+    // Once a src arrives via LOAD, the load goes through.
+    eventBus.emit(MeshInputEvents.LOAD, { entityId: entity.id, src: '/late.glb' });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(renderer.calls.some((c) => c.method === 'loadMesh')).toBe(true);
+  });
+
+  it('follow with no sibling MeshPrimitive is a no-op (does not throw)', async () => {
+    const entity = world.createEntity();
+    // follow:true but NOT instanced and NO MeshPrimitive sibling.
+    entity.add(new MeshComponent({ src: '/a.glb', follow: true }));
+    world.update(1 / 60);
+    await Promise.resolve();
+    await Promise.resolve();
+    renderer.calls.length = 0;
+    expect(() => world.update(1 / 60)).not.toThrow();
+    // updateFollow returns early at the missing-sibling guard → no follow writes.
+    expect(renderer.calls.some((c) => c.method === 'setMeshRotation')).toBe(false);
+  });
 });
 
 describe('MeshSystem — instanced clone + follow', () => {
@@ -302,6 +411,25 @@ describe('MeshSystem — instanced clone + follow', () => {
     expect(yawed).toBe(true);
   });
 
+  it('re-acquiring a non-following instanced entity reveals the clone without touching follow state', async () => {
+    const entity = world.createEntity('Enemy');
+    // instanced but follow:false → no followState is ever created.
+    entity.add(new MeshComponent({ src: 'enemy.glb', instanced: true }));
+    entity.add(new MeshPrimitiveComponent({ primitive: 'sphere', position: [0, 1, 0] }));
+
+    world.update(1 / 60);
+    await Promise.resolve();
+    await Promise.resolve();
+    world.update(1 / 60); // instantiate
+
+    entity.active = false;
+    renderer.calls.length = 0;
+    // Re-acquire: fs is undefined so the prevX/prevZ reseed is skipped (295 false).
+    entity.active = true;
+    expect(callsOf('setModelVisible').some((c) => c.args[1] === true)).toBe(true);
+    expect(callsOf('instantiateModel')).toHaveLength(0);
+  });
+
   it('parked (active=false) entity hides the clone but keeps it; true destroy disposes it', async () => {
     const parked = world.createEntity('ParkedEnemy');
     parked.add(new MeshComponent({ src: 'enemy.glb', instanced: true }));
@@ -329,6 +457,79 @@ describe('MeshSystem — instanced clone + follow', () => {
     expect(callsOf('disposeModel')[0].args[0]).toBe(destroyed.id);
   });
 
+  it('faceMode "proxy" copies the proxy yaw (+yawOffset) instead of inferring from movement', async () => {
+    const entity = world.createEntity('Player');
+    entity.add(
+      new MeshComponent({
+        src: 'player.glb',
+        instanced: true,
+        follow: true,
+        faceMode: 'proxy',
+        yawOffset: Math.PI / 4,
+        position: [0, 0.5, 0],
+      }),
+    );
+    const mp = new MeshPrimitiveComponent({ primitive: 'capsule', position: [0, 1, 0] });
+    entity.add(mp);
+
+    world.update(1 / 60);
+    await Promise.resolve();
+    await Promise.resolve();
+    world.update(1 / 60); // instantiate
+
+    // Aim the proxy without moving it — proxy faceMode reads rotation[1] directly.
+    mp.rotation[1] = Math.PI / 2;
+    world.update(1 / 60);
+
+    const rots = callsOf('setMeshRotation');
+    const expectedYaw = Math.PI / 2 + Math.PI / 4;
+    expect(rots.some((c) => c.args[1] === 0 && c.args[2] === expectedYaw && c.args[3] === 0)).toBe(
+      true,
+    );
+  });
+
+  it('instanced load leaves the core in "loading" when no renderer is attached', () => {
+    const eb = new EventBus();
+    const w = new World({ eventBus: eb }); // no renderer
+    w.addSystem(new MeshSystem(eb));
+    w.initialize();
+    const entity = w.createEntity('Enemy');
+    const comp = new MeshComponent({ src: 'enemy.glb', instanced: true });
+    entity.add(comp);
+    w.update(1 / 60);
+    // beginLoad ran (LOADING fired) but dispatchInstancedLoad returns at the
+    // no-renderer guard before requesting any template.
+    expect(comp.instance?.getState().state).toBe('loading');
+  });
+
+  it('retries the template load on a later frame after the first attempt rejects', async () => {
+    const fail = vi
+      .spyOn(renderer, 'loadModelTemplate')
+      .mockRejectedValueOnce(new Error('404'));
+
+    const entity = world.createEntity('Enemy');
+    entity.add(new MeshComponent({ src: 'enemy.glb', instanced: true }));
+
+    // First tick requests the template; the promise rejects → templateRequested
+    // is rolled back so a retry can happen.
+    world.update(1 / 60);
+    // Flush the rejected microtask so the .catch rolls back templateRequested.
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    expect(fail).toHaveBeenCalledTimes(1);
+    expect(callsOf('instantiateModel')).toHaveLength(0);
+
+    // Next frame: the template load is attempted again (the spy counts every
+    // invocation, including the once-rejected one and the retry).
+    world.update(1 / 60);
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    expect(fail.mock.calls.length).toBeGreaterThanOrEqual(2);
+
+    // And now it can instantiate.
+    world.update(1 / 60);
+    expect(callsOf('instantiateModel')).toHaveLength(1);
+    expect(entity.get(MeshComponent)!.instance?.getState().state).toBe('loaded');
+  });
+
   it('re-acquiring a parked instanced entity reveals the kept clone without re-instantiating', async () => {
     const entity = world.createEntity('Enemy');
     entity.add(new MeshComponent({ src: 'enemy.glb', instanced: true, follow: true }));

package/src/Components/MeshPrimitive/MeshPrimitive.test.ts

@@ -38,6 +38,80 @@ describe('MeshPrimitiveComponent (core)', () => {
     expect(c.position).toEqual([4, 5, 6]);
   });
 
+  it('falls back to [0,0,0] for a malformed position object (missing numeric x/y/z)', () => {
+    // A {x,y} object (no z, or non-numeric) is not Vec3-like → fallback, not NaN.
+    const c = new MeshPrimitiveComponent({
+      position: { x: 1, y: 2 } as unknown as { x: number; y: number; z: number },
+    });
+    expect(c.position).toEqual([0, 0, 0]);
+  });
+
+  it('falls back to the default for a wrong-length array position', () => {
+    const c = new MeshPrimitiveComponent({
+      position: [1, 2] as unknown as [number, number, number],
+    });
+    expect(c.position).toEqual([0, 0, 0]);
+  });
+
+  it('coerces non-numeric array entries to 0 in position', () => {
+    const c = new MeshPrimitiveComponent({
+      position: ['a', 2, null] as unknown as [number, number, number],
+    });
+    expect(c.position).toEqual([0, 2, 0]);
+  });
+
+  it('maps PBR texture material keys onto the material spec and ignores ambientColor', () => {
+    const c = new MeshPrimitiveComponent({
+      material: {
+        albedoTexture: '/a.png',
+        normalTexture: '/n.png',
+        roughnessTexture: '/r.png',
+        ambientTexture: '/ao.png',
+        metallic: 0.4,
+        roughness: 0.6,
+        uScale: 2,
+        vScale: 3,
+        ambientColor: [0.1, 0.1, 0.1],
+      },
+    });
+    expect(c.material?.albedoTexture).toBe('/a.png');
+    expect(c.material?.normalTexture).toBe('/n.png');
+    expect(c.material?.roughnessTexture).toBe('/r.png');
+    expect(c.material?.ambientTexture).toBe('/ao.png');
+    expect(c.material?.metallic).toBe(0.4);
+    expect(c.material?.roughness).toBe(0.6);
+    expect(c.material?.uScale).toBe(2);
+    expect(c.material?.vScale).toBe(3);
+    // ambientColor is a legacy key with no destination on the spec.
+    expect((c.material as Record<string, unknown>).ambient).toBeUndefined();
+  });
+
+  it('serialize round-trips a textured PBR material', () => {
+    const original = new MeshPrimitiveComponent({
+      material: { albedoTexture: '/a.png', metallic: 0.2, roughness: 0.8, uScale: 4 },
+    });
+    const copy = new MeshPrimitiveComponent(original.serialize());
+    expect(copy.material?.albedoTexture).toBe('/a.png');
+    expect(copy.material?.metallic).toBe(0.2);
+    expect(copy.material?.roughness).toBe(0.8);
+    expect(copy.material?.uScale).toBe(4);
+  });
+
+  it('serialize yields undefined material when none is set', () => {
+    const c = new MeshPrimitiveComponent();
+    expect(c.serialize().material).toBeUndefined();
+  });
+
+  it('handle getter/setter round-trips through the shared runtime map', () => {
+    const c = new MeshPrimitiveComponent();
+    expect(c.handle).toBeUndefined();
+    const fake = { __h: 1 } as unknown as NonNullable<typeof c.handle>;
+    c.handle = fake;
+    expect(c.handle).toBe(fake);
+    c.handle = undefined;
+    expect(c.handle).toBeUndefined();
+  });
+
   it('accepts color shorthand, mapping to material.diffuse', () => {
     const c = new MeshPrimitiveComponent({ color: [1, 0, 0] });
     expect(c.material?.diffuse).toEqual([1, 0, 0]);
@@ -302,6 +376,154 @@ describe('MeshPrimitiveSystem — adapter integration', () => {
     }).not.toThrow();
   });
 
+  it('SET_SCALE is accepted but a no-op (scale not yet in the adapter surface)', () => {
+    const entity = world.createEntity();
+    entity.add(new MeshPrimitiveComponent());
+    renderer.calls.length = 0;
+    expect(() =>
+      eventBus.emit(MeshPrimitiveInputEvents.SET_SCALE, {
+        entityId: entity.id, x: 2, y: 2, z: 2,
+      }),
+    ).not.toThrow();
+    // No adapter method exists for scale yet.
+    expect(renderer.calls.length).toBe(0);
+  });
+
+  it('CREATE event applies every dimensional param it carries', () => {
+    const entity = world.createEntity();
+    const comp = new MeshPrimitiveComponent({ primitive: 'box', autoCreate: false });
+    entity.add(comp);
+    renderer.calls.length = 0;
+    eventBus.emit(MeshPrimitiveInputEvents.CREATE, {
+      entityId: entity.id,
+      primitive: 'cylinder',
+      width: 4,
+      height: 5,
+      depth: 6,
+      diameter: 7,
+    });
+    expect(comp.primitive).toBe('cylinder');
+    expect(comp.width).toBe(4);
+    expect(comp.height).toBe(5);
+    expect(comp.depth).toBe(6);
+    expect(comp.diameter).toBe(7);
+    expect(renderer.calls.some((c) => c.method === 'createMesh')).toBe(true);
+  });
+
+  it('CREATE event for an unknown entity is a silent no-op', () => {
+    renderer.calls.length = 0;
+    expect(() =>
+      eventBus.emit(MeshPrimitiveInputEvents.CREATE, { entityId: 'ghost', primitive: 'sphere' }),
+    ).not.toThrow();
+    expect(renderer.calls.length).toBe(0);
+  });
+
+  it('SET_COLOR / SET_VISIBLE / DISPOSE for unknown entities are silent no-ops', () => {
+    renderer.calls.length = 0;
+    expect(() => {
+      eventBus.emit(MeshPrimitiveInputEvents.SET_COLOR, { entityId: 'ghost', r: 1, g: 0, b: 0 });
+      eventBus.emit(MeshPrimitiveInputEvents.SET_VISIBLE, { entityId: 'ghost', visible: false });
+      eventBus.emit(MeshPrimitiveInputEvents.DISPOSE, { entityId: 'ghost' });
+    }).not.toThrow();
+    expect(renderer.calls.length).toBe(0);
+  });
+
+  it('DISPOSE on an entity whose mesh was never created is a no-op (no event)', () => {
+    const entity = world.createEntity();
+    const comp = new MeshPrimitiveComponent({ autoCreate: false });
+    entity.add(comp);
+    const disposedSpy = vi.fn();
+    eventBus.on(MeshPrimitiveEvents.DISPOSED, disposedSpy);
+    renderer.calls.length = 0;
+    eventBus.emit(MeshPrimitiveInputEvents.DISPOSE, { entityId: entity.id });
+    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(false);
+    expect(disposedSpy).not.toHaveBeenCalled();
+  });
+
+  it('SET_COLOR merges into an existing material rather than dropping other keys', () => {
+    const entity = world.createEntity();
+    const comp = new MeshPrimitiveComponent({
+      material: { diffuseColor: [1, 1, 1], alpha: 0.5 },
+    });
+    entity.add(comp);
+    renderer.calls.length = 0;
+    eventBus.emit(MeshPrimitiveInputEvents.SET_COLOR, { entityId: entity.id, r: 0, g: 1, b: 0 });
+    expect(comp.material?.diffuse).toEqual([0, 1, 0]);
+    expect(comp.material?.alpha).toBe(0.5); // preserved
+  });
+
+  it('SET_COLOR creates a material when the component had none', () => {
+    const entity = world.createEntity();
+    const comp = new MeshPrimitiveComponent(); // no material
+    entity.add(comp);
+    expect(comp.material).toBeUndefined();
+    renderer.calls.length = 0;
+    eventBus.emit(MeshPrimitiveInputEvents.SET_COLOR, { entityId: entity.id, r: 0.2, g: 0.4, b: 0.6 });
+    expect(comp.material?.diffuse).toEqual([0.2, 0.4, 0.6]);
+    expect(renderer.calls.some((c) => c.method === 'setMeshColor')).toBe(true);
+  });
+
+  it('recreating via CREATE disposes the prior handle before making a new mesh', () => {
+    const entity = world.createEntity();
+    const comp = new MeshPrimitiveComponent({ primitive: 'box' }); // autoCreate → already made
+    entity.add(comp);
+    expect(comp.handle).toBeDefined();
+    renderer.calls.length = 0;
+    // Re-create over an existing handle exercises the dispose-then-create path.
+    eventBus.emit(MeshPrimitiveInputEvents.CREATE, { entityId: entity.id, primitive: 'sphere' });
+    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(true);
+    expect(renderer.calls.some((c) => c.method === 'createMesh')).toBe(true);
+    expect(comp.primitive).toBe('sphere');
+  });
+
+  it('CREATED carries the raw mesh object when the Babylon adapter exposes getMeshObject', () => {
+    // The Babylon adapter has a non-interface getMeshObject for back-compat
+    // consumers (ArcCamera/Shadow). Stub it here to exercise that branch.
+    const rawMesh = { name: 'rawBabylonMesh' };
+    (renderer as unknown as { getMeshObject: (h: unknown) => unknown }).getMeshObject = () => rawMesh;
+    const spy = vi.fn();
+    eventBus.on(MeshPrimitiveEvents.CREATED, spy);
+    const entity = world.createEntity();
+    entity.add(new MeshPrimitiveComponent({ primitive: 'box' }));
+    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ mesh: rawMesh }));
+  });
+
+  it('events targeting an existing entity that lacks a MeshPrimitiveComponent are no-ops', () => {
+    // The entity is real (world.getEntity finds it) but carries no component,
+    // so every handler short-circuits at its `if (!comp) return` guard.
+    const bare = world.createEntity();
+    renderer.calls.length = 0;
+    expect(() => {
+      eventBus.emit(MeshPrimitiveInputEvents.CREATE, { entityId: bare.id, primitive: 'sphere' });
+      eventBus.emit(MeshPrimitiveInputEvents.SET_POSITION, { entityId: bare.id, x: 1, y: 2, z: 3 });
+      eventBus.emit(MeshPrimitiveInputEvents.SET_COLOR, { entityId: bare.id, r: 1, g: 0, b: 0 });
+      eventBus.emit(MeshPrimitiveInputEvents.SET_VISIBLE, { entityId: bare.id, visible: false });
+      eventBus.emit(MeshPrimitiveInputEvents.DISPOSE, { entityId: bare.id });
+    }).not.toThrow();
+    expect(renderer.calls.length).toBe(0);
+  });
+
+  it('removing an entity whose mesh was never created disposes nothing', () => {
+    const entity = world.createEntity();
+    entity.add(new MeshPrimitiveComponent({ autoCreate: false }));
+    renderer.calls.length = 0;
+    world.removeEntity(entity); // active destroy, but rt.handle is undefined
+    expect(renderer.calls.some((c) => c.method === 'disposeMesh')).toBe(false);
+  });
+
+  it('createPrimitive defers when no renderer is attached', () => {
+    const eb = new EventBus();
+    const w = new World({ eventBus: eb }); // no renderer
+    const entity = w.createEntity();
+    const comp = new MeshPrimitiveComponent({ primitive: 'sphere' });
+    entity.add(comp);
+    w.addSystem(new MeshPrimitiveSystem(eb));
+    w.initialize();
+    // Creation is deferred without a renderer; the component is still inspectable.
+    expect(comp.isCreated).toBe(false);
+    expect(comp.handle).toBeUndefined();
+  });
+
   it('onUpdate is a no-op', () => {
     expect(() => world.update(16)).not.toThrow();
   });