Made of little things.

import assert from 'node:assert/strict';
import { before, after, test } from 'node:test';
import { createServer } from 'vite';
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
let server, LocalMultiplayer, splitViewports, Input, App, DrivingManager;
before(async () => {
  server = await createServer({ logLevel: 'error', server: { middlewareMode: true }, appType: 'custom', optimizeDeps: { noDiscovery: true, entries: [] } });
  ({ LocalMultiplayer, splitViewports } = await server.ssrLoadModule('/src/game/localMultiplayer.ts'));
  ({ Input } = await server.ssrLoadModule('/src/game/input.ts'));
  ({ App } = await server.ssrLoadModule('/src/game/app.ts'));
  ({ DrivingManager } = await server.ssrLoadModule('/src/game/lingo/drivingManager.ts'));
  const { initPhysics } = await server.ssrLoadModule('/src/game/physics/havok.ts');
  // Exercise the optimized browser WASM too: source-only tests previously
  // missed removal helpers stripped by the production build.
  const { rapierKeepList, slimRapierWasm } = await server.ssrLoadModule('/tools/build/rapier-slim.ts');
  const raw = readFileSync('node_modules/@dimforge/rapier3d-compat/dist/rapier.mjs', 'utf8');
  const encoded = /[\w$]+\.toByteArray\("(AGFzbQ[A-Za-z0-9+/=]+)"\)/.exec(raw)?.[1];
  assert.ok(encoded, 'Rapier still embeds WASM in the expected format');
  const slim = slimRapierWasm(Buffer.from(encoded, 'base64'), rapierKeepList(resolve('.')));
  const instantiate = WebAssembly.instantiate;
  let optimized = false;
  WebAssembly.instantiate = (input, imports) => {
    optimized = true;
    return instantiate(slim, imports);
  };
  try { await initPhysics(); } finally { WebAssembly.instantiate = instantiate; }
  assert.ok(optimized, 'tests initialized the optimized WASM');
});
after(() => server?.close());
const identity = [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1];
function level() {
  return {
    markers: { raymesh_models: ['floor'], car_hull: { node_matrix: identity, positions: [[-10,-20,-5],[10,-20,-5],[-10,20,-5],[10,20,-5],[-10,-20,5],[10,-20,5],[-10,20,5],[10,20,5]] }, level: [{name:'ssrc_start',matrix:[...identity.slice(0,12),0,0,40,1]}], car: [] },
    collision: { gravity: [0,0,-386], scale: 1, bodies: [] },
    rayMesh: { positions: new Float32Array([-1000,-1000,0,1000,-1000,0,1000,1000,0,-1000,1000,0]), indices: new Uint32Array([0,1,2,0,2,3]), owner: new Uint16Array([0,0]) },
  };
}
const action = (value = 0, pressed = false) => ({value, down: Math.abs(value) >= .5, pressed, released:false});
const controller = (index, throttle = 0, steering = 0) => ({index,id:`pad${index}`,mapped:true,mapping:'standard',actions:{accelerate:action(throttle),stickX:action(steering),menu:action()},buttons:[],axes:[]});
const frame = (players, more = {}) => ({status:'ready',players,connected:[],disconnected:[],...more});

test('hot-plug adds/removes independent cars, preserves slots and caps at four', () => {
  const local = new LocalMultiplayer(level(), null);
  try {
    local.updateControllers(frame([controller(2,1,-.7),controller(6,0,.8)]));
    assert.deepEqual(local.players.map(p=>[p.slot,p.controllerIndex]),[[0,2],[1,6]]);
    assert.equal(local.players[0].input.keyPressed(126),true);
    assert.equal(local.players[1].input.keyPressed(126),false);
    assert.equal(local.players[0].input.steerAxis(),-.7);
    assert.equal(local.players[1].input.steerAxis(),.8);
    const survivor = local.players[1], position = survivor.driver.car.rb.position;
    local.step(25);
    assert.equal(local.dm.milliseconds,25); // shared clock advances once, not per car
    local.updateControllers(frame([controller(6)]));
    assert.equal(local.players[0],survivor);
    assert.equal(survivor.slot,1);
    assert.ok(survivor.driver.car.rb.position.distanceTo(position) < 5);
    assert.equal(local.dm.players.length,1);
    assert.equal(local.dm.havokManager.havok.rigidBody('car-p1'),undefined);
    local.updateControllers(frame([controller(6),controller(7),controller(8),controller(9),controller(10)]));
    assert.equal(local.players.length,4);
    assert.equal(local.dm.players.length,4);
    assert.equal(new Set(local.players.map(p=>p.driver.car.rb.name)).size,4);
    for (let i=0;i<4;i++) for(let j=i+1;j<4;j++) assert.ok(local.players[i].driver.car.rb.position.distanceTo(local.players[j].driver.car.rb.position)>85);
    local.updateControllers(frame([controller(10)]));
    assert.equal(local.players.length,1); // waiting extra pad joins when a place opens
    assert.equal(local.players[0].controllerIndex,10);
    local.updateControllers(frame([]));
    assert.equal(local.players.length,0);
    assert.equal(local.dm.players.length,0);
  } finally { local.destroy(); }
});

test('focus loss clears input and pauses; replacement removes the old car; unavailable API preserves roster', () => {
  const local = new LocalMultiplayer(level(), null);
  try {
    local.updateControllers(frame([controller(0,1)]));
    const old = local.players[0];
    local.updateControllers(frame([controller(0)], {status:'inactive'}));
    assert.equal(local.paused,true);
    assert.equal(old.input.keyPressed(126),false);
    local.step(25);
    assert.equal(local.dm.milliseconds,0);
    local.updateControllers(frame([], {status:'blocked'}));
    assert.equal(local.players[0],old);
    local.updateControllers(frame([controller(0)], {disconnected:[0],connected:[0]}));
    assert.notEqual(local.players[0],old);
    const pad=controller(0); pad.actions.menu=action(1,true);
    local.updateControllers(frame([pad]));
    assert.equal(local.paused,false);
  } finally {local.destroy();}
});

test('all viewport layouts fit odd-sized frames without overlap', () => {
  for (const [w,h] of [[200,160],[320,560],[900,600],[1921,1081]]) for(let count=1;count<=4;count++) {
    const rects=splitViewports(count,w,h);
    assert.equal(rects.length,count);
    for (const a of rects) {assert.ok(a.width>0 && a.height>0);assert.ok(a.x+a.width<=w && a.y+a.height<=h);}
    for(let i=0;i<count;i++) for(let j=i+1;j<count;j++) {
      const a=rects[i],b=rects[j];
      assert.ok(a.x+a.width<=b.x || b.x+b.width<=a.x || a.y+a.height<=b.y || b.y+b.height<=a.y);
    }
  }
  assert.deepEqual(splitViewports(0,900,600),[]);
  assert.deepEqual(splitViewports(2,900,600),[
    {x:0,y:0,width:900,height:300},{x:0,y:300,width:900,height:300},
  ]);
  assert.deepEqual(splitViewports(3,900,600),[
    {x:0,y:0,width:450,height:300},{x:450,y:0,width:450,height:300},
    {x:0,y:300,width:450,height:300},
  ]);
  assert.deepEqual(splitViewports(4,900,600),[
    {x:0,y:0,width:450,height:300},{x:450,y:0,width:450,height:300},
    {x:0,y:300,width:450,height:300},{x:450,y:300,width:450,height:300},
  ]);
});

test('native polling hot-plugs 1 → 2 → 3 → 4 controllers with separate cars and cameras', () => {
  const saved = ['navigator','window'].map(key => [key,Object.getOwnPropertyDescriptor(globalThis,key)]);
  let samples = [];
  Object.defineProperty(globalThis,'navigator',{configurable:true,value:{getGamepads:()=>samples}});
  Object.defineProperty(globalThis,'window',{configurable:true,value:{addEventListener(){},removeEventListener(){},document:{hidden:false,hasFocus:()=>true,addEventListener(){},removeEventListener(){}}}});
  const input = new Input(), local = new LocalMultiplayer(level(),null);
  const pad = index => ({index,id:'Xbox controller',connected:true,mapping:'standard',axes:[index ? .8 : -.8,0,0,0],buttons:Array.from({length:17},(_,i)=>({value:i===0 && index===0 ? 1 : 0}))});
  try {
    for (let count=1;count<=4;count++) {
      // Browsers return sparse slots; multiple identical IDs must stay distinct.
      samples = Array.from({length:7},(_,i)=>i%2===0 && i/2<count ? pad(i) : null);
      const {frame}=input.pollGamepad(false,0,true);
      assert.equal(frame.status,'ready');
      local.updateControllers(frame);
      assert.equal(local.players.length,count);
      assert.equal(new Set(local.players.map(p=>p.driver.car)).size,count);
      assert.equal(new Set(local.players.map(p=>p.driver.camera)).size,count);
      assert.equal(local.players[0].input.keyPressed(126),true);
      for (const p of local.players.slice(1)) assert.equal(p.input.keyPressed(126),false);
      assert.equal(input.keyPressed(126),false,'session input must not merge player controls');
    }
    samples=[pad(0)];
    local.updateControllers(input.pollGamepad(false,0,true).frame);
    assert.equal(local.players.length,1);
  } finally {
    local.destroy();
    for (const [key,descriptor] of saved) {
      if (descriptor) Object.defineProperty(globalThis,key,descriptor);
      else delete globalThis[key];
    }
  }
});

test('player input ignores session Menu and clears held driving controls',()=>{
  const input=new Input(); const pad=controller(4,1,.6); pad.actions.menu=action(1,true);
  input.applyController(pad);
  assert.equal(input.keyPressed(53),false);
  input.clear();
  assert.equal(input.keyPressed(126),false);
  assert.equal(input.steerAxis(),0);
});

test('online driving uses only the first mapped controller and never starts split screen',()=>{
  const saved=['navigator','window'].map(key=>[key,Object.getOwnPropertyDescriptor(globalThis,key)]);
  const pad=(index,throttle,steer)=>({index,id:'Xbox',connected:true,mapping:'standard',axes:[steer,0,0,0],buttons:Array.from({length:17},(_,i)=>({value:i===0?throttle:0}))});
  Object.defineProperty(globalThis,'navigator',{configurable:true,value:{getGamepads:()=>[pad(0,0,-.5),null,pad(2,1,.9)]}});
  Object.defineProperty(globalThis,'window',{configurable:true,value:{addEventListener(){},removeEventListener(){},document:{hidden:false,hasFocus:()=>true,addEventListener(){},removeEventListener(){}}}});
  try {
    const input=new Input();input.pollGamepad(true,0,false,true);
    assert.equal(input.keyPressed(126),false,'second controller cannot accelerate the online car');
    assert.ok(input.steerAxis()<0,'first controller owns steering');
    const app=Object.create(App.prototype);
    const race={name:'free_driving',driving:true};
    app.race=race;app.online={};app.local=null;app.input=input;app.onStatus=()=>{};
    app.pollGamepad(1);
    assert.equal(app.race,race);assert.equal(app.local,null);
  } finally {
    for(const [key,value] of saved) if(value)Object.defineProperty(globalThis,key,value);else delete globalThis[key];
  }
});

test('Free Driving automatically switches from merged input to separate cars on the second pad',()=>{
  const app=Object.create(App.prototype);
  const dm=new DrivingManager(level(),new Input());
  const position=dm.car.rb.position;
  app.race={name:'free_driving',dm,driving:true,sound:null};
  app.local=null;
  let current=frame([controller(0,1)]);
  app.input={pollGamepad:()=>({intents:[],waiting:false,frame:current})};
  app.screens={hideRace(){},navigate(){}};
  app.onStatus=()=>{};
  app.localStart=()=>{app.local=new LocalMultiplayer(level(),null);};
  try {
    app.pollGamepad(0);
    assert.equal(app.race.dm,dm,'one controller retains keyboard/touch Free Driving');
    current=frame([controller(0,1),controller(3,0,.8)]);
    app.pollGamepad(1);
    assert.equal(app.race,null);
    assert.equal(app.local.players.length,2);
    assert.ok(app.local.players[0].driver.car.rb.position.distanceTo(position)<.001);
    assert.notEqual(app.local.players[0].driver.camera,app.local.players[1].driver.camera);
    assert.equal(app.local.players[0].input.keyPressed(126),true);
    assert.equal(app.local.players[1].input.keyPressed(126),false);
    app.input.keyPressed=()=>false;
    for (let count=3;count<=4;count++) {
      current=frame(Array.from({length:count},(_,i)=>controller(i===0?0:i+2)));
      app.pollGamepad(count);
      assert.equal(app.local.players.length,count);
    }
  } finally {if(app.local) app.local.destroy();else dm.destroy();}
});

test('unmapped controllers are reported even when none can join',()=>{
  const local=new LocalMultiplayer(level(),null);
  try {
    const pad=controller(2);pad.mapped=false;pad.mapping='';
    local.updateControllers(frame([pad]));
    assert.equal(local.players.length,0);
    assert.match(local.status,/Controller 3 detected without a supported mapping/);
  } finally {local.destroy();}
});


test('controller code presses are observed during single-player and split-screen driving',()=>{
  for (const local of [null, {}]) {
    const app=Object.create(App.prototype);
    const calls=[];
    const pad=controller(0);
    pad.actions.up=action(1,true);
    pad.actions.accelerate=action(1,true);
    app.race=local ? null : {driving:true};
    app.local=local;
    app.input={pollGamepad:()=>({intents:[],waiting:false,frame:frame([pad])})};
    app.menuIntentFilter=intent=>{calls.push(intent);return intent==='select';};
    app.pollGamepad(0);
    assert.deepEqual(calls,['up','select']);
  }
});

test('asset restart releases all active players and clears input and overlays',()=>{
  const app=Object.create(App.prototype);
  const calls=[];
  app.race={sound:{destroy:()=>calls.push('sound')},dm:{destroy:()=>calls.push('world')}};
  app.local={destroy:()=>calls.push('players')};
  app.view={clearPlayers:()=>calls.push('markers'),setMode:()=>calls.push('mode')};
  app.screens={hideRace:()=>calls.push('hud'),hideLocal:()=>calls.push('split')};
  app.input={clear:()=>calls.push('input')};
  app.idleWaiters=[()=>calls.push('idle')];
  app.localMenuHeld=true;
  app.stopSession();
  assert.deepEqual(calls,['sound','world','players','markers','mode','hud','split','input','idle']);
  assert.equal(app.racing,false);
  assert.equal(app.localMenuHeld,false);
});

test('Free Driving starts with no checkpoint dependency or challenge countdown',async()=>{
  const {FreeDriving}=await server.ssrLoadModule('/src/game/lingo/gameplay.ts');
  const dm=new DrivingManager(level(),new Input());
  try {
    let exited=false;
    const mode=new FreeDriving({dm,input:new Input(),markers:level().markers,mixer:null,ms:()=>0,exit:()=>{exited=true;}});
    mode.realStart();
    for(let i=0;i<10;i++) mode.stepFrame();
    assert.equal(mode.checkpoints.length,0);
    assert.equal(mode.arrow.visible,false);
    assert.equal(mode.timer.label.dead,true);
    assert.equal(exited,false);
  } finally {dm.destroy();}
});

test('Escape during a jump ends the session without reading freed physics', async () => {
  const { FreeDriving } = await server.ssrLoadModule('/src/game/lingo/gameplay.ts');
  const input = new Input();
  const dm = new DrivingManager(level(), input);
  let exited = false;
  const mode = new FreeDriving({ dm, input, markers: level().markers, mixer: null, ms: () => 0,
    exit: () => { exited = true; dm.destroy(); } });
  try {
    mode.realStart();
    dm.stepFrame(25); // Establish an airborne stunt before quitting.
    assert.ok(dm.car.wheels.every(w => !w.pOnGround));
    input.setVirtual(53, true);
    assert.doesNotThrow(() => dm.stepFrame(25));
    assert.equal(exited, true);
    assert.doesNotThrow(() => dm.stepFrame(25));
  } finally { if (!exited) dm.destroy(); }
});

test('fall recovery returns each off-track car to its own spawn with no momentum', () => {
  const local = new LocalMultiplayer(level(), null);
  try {
    local.updateControllers(frame([controller(0), controller(1)]));
    for (const player of local.players) {
      const rb = player.driver.car.rb;
      const spawn = rb.position, orientation = rb.quaternion;
      rb.position = spawn.clone().set(2000, 2000, -20);
      rb.linearVelocity = spawn.clone().set(10, 20, -300);
      rb.angularVelocity = spawn.clone().set(1, 2, 3);
      player.recovery.stepFrame();
      assert.ok(rb.position.distanceTo(spawn) < .001);
      assert.ok(rb.quaternion.angleTo(orientation) < .001);
      assert.equal(rb.linearVelocity.length(), 0);
      assert.equal(rb.angularVelocity.length(), 0);
      // When ground exists below, recover over that ground instead.
      rb.position = spawn.clone().set(200, 100, -20);
      player.recovery.stepFrame();
      assert.ok(rb.position.distanceTo(spawn.clone().set(200, 100, 30)) < .001);
    }
  } finally { local.destroy(); }
});