@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/simulation/race/raceProgress.js

@@ -1,3 +1,4 @@
+import { clearCurrentDrsState } from '../timing/drsState.js';
 import { pointAt } from '../track/trackModel.js';
 import { applyWheelSurfaceState } from '../vehicle/wheelSurface.js';
 import {
@@ -30,10 +31,7 @@ export function refreshLocalRaceStateForSimulation(sim) {
         stabilityState: car.destroyed ? 'destroyed' : car.stabilityState,
       });
       car.canAttack = false;
-      car.drsEligible = false;
-      car.drsActive = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
       return;
     }
     const centerState = takeValidRunoffCenterState(car);
@@ -98,10 +96,7 @@ export function recalculateRaceStateForSimulation(sim, { updateDrs = true, refre
         stabilityState: car.destroyed ? 'destroyed' : car.stabilityState,
       });
       car.canAttack = false;
-      car.drsEligible = false;
-      car.drsActive = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
       recordTimingStateForCar(car, sim.time, sim.track, previousRaceDistanceForTiming, sim.runtimeBenchmarkStats);
       return;
     }
@@ -149,10 +144,7 @@ export function recalculateRaceStateForSimulation(sim, { updateDrs = true, refre
       car.gapAheadSeconds = Infinity;
       car.intervalAheadSeconds = Infinity;
       car.leaderGapSeconds = Infinity;
-      car.drsEligible = false;
-      car.drsActive = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
       car.canAttack = false;
     });
   } else if (sim?.runtimeBenchmarkStats) {
@@ -175,10 +167,7 @@ export function recalculateRaceStateForSimulation(sim, { updateDrs = true, refre
       car.gapAheadSeconds = Infinity;
       car.intervalAheadSeconds = Infinity;
       car.leaderGapSeconds = Infinity;
-      car.drsEligible = false;
-      car.drsActive = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
       car.canAttack = false;
       return;
     }
@@ -210,10 +199,7 @@ export function recalculateRaceStateForSimulation(sim, { updateDrs = true, refre
     car.canAttack = !sim.safetyCar.deployed && !car.finished && !activePitStop;
     car.aggression = sim.computeAggression(car, index, aggressionFieldDepth);
     if (activePitStop) {
-      car.drsEligible = false;
-      car.drsActive = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
     } else if (updateDrs) sim.updateDrsLatch(car, drsReference, Boolean(drsReference));
   });
   sim.evaluateRaceFinish(ordered);

package/src/simulation/race/raceSetup.js

@@ -13,7 +13,7 @@ import {
 } from '../timing/raceTiming.js';
 import { normalizePitIntent, PIT_INTENT_NONE } from '../pit/pitIntent.js';
 import { assignPitLaneTeams, initializePitStops } from '../pit/pitState.js';
-import { clonePitLaneModel } from '../pit/pitRouting.js';
+import { clonePitLaneModel } from '../track/pitLaneModel.js';
 import { createRaceControlState, createSafetyCarState } from './raceControlState.js';
 import { normalizeTotalLaps } from './raceDistance.js';
 import { normalizeRaceRules } from '../rulesConfig.js';

package/src/simulation/race/raceStep.js

@@ -1,7 +1,7 @@
-import { decideDriverControls } from '../driverController.js';
+import { decideDriverControls } from '../driver/driverController.js';
 import { clamp } from '../simMath.js';
 import { updateReplayGhosts } from '../replay/replayGhosts.js';
-import { integrateVehiclePhysics } from '../vehicle/vehiclePhysics.js';
+import { integrateVehiclePhysics, isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
 import { applyWheelSurfaceState } from '../vehicle/wheelSurface.js';
 import { applyRedFlagHoldForSimulation } from './redFlag.js';
 import { freezeRetiredCar, updateStalledDnfForSimulation } from './stalledDnf.js';
@@ -38,19 +38,28 @@ export function runRaceStep(simulation, dt) {
 
   const orderedCars = simulation.orderedCars();
   const raceContext = simulation.driverRaceContext(orderedCars);
-  const orderedIndexById = new Map(orderedCars.map((car, index) => [car.id, index]));
-  const driveCars = orderedCars.length === simulation.cars.length
-    ? orderedCars
-    : [
-      ...orderedCars,
-      ...simulation.cars.filter((car) => !orderedIndexById.has(car.id)),
-    ];
+  for (let index = 0; index < simulation.cars.length; index += 1) {
+    simulation.cars[index]._driveOrderIndex = -1;
+  }
+  for (let index = 0; index < orderedCars.length; index += 1) {
+    orderedCars[index]._driveOrderIndex = index;
+  }
+  let driveCars = orderedCars;
+  if (orderedCars.length !== simulation.cars.length) {
+    driveCars = simulation._driveCarsScratch ??= [];
+    driveCars.length = 0;
+    driveCars.push(...orderedCars);
+    for (let index = 0; index < simulation.cars.length; index += 1) {
+      const car = simulation.cars[index];
+      if (car._driveOrderIndex === -1) driveCars.push(car);
+    }
+  }
   driveCars.forEach((car) => {
     if (car.destroyed || car.outOfRace) {
       freezeRetiredCar(car, { physicsMode: simulation.physicsMode });
       return;
     }
-    const orderIndex = orderedIndexById.get(car.id);
+    const orderIndex = car._driveOrderIndex >= 0 ? car._driveOrderIndex : undefined;
     car.previousX = car.x;
     car.previousY = car.y;
     car.previousHeading = car.heading;
@@ -66,7 +75,7 @@ export function runRaceStep(simulation, dt) {
       throttle: controls.throttle ?? 0,
       brake: controls.brake ?? 0,
     };
-    if (simulation.physicsMode === 'advanced') {
+    if (isSimulatorPhysicsMode(simulation.physicsMode)) {
       measureRuntimePhase(simulation, 'prePhysicsWheelSurface', () => {
         applyWheelSurfaceState(car, simulation.track);
       });

package/src/simulation/race/redFlag.js

@@ -1,3 +1,4 @@
+import { clearCurrentDrsState } from '../timing/drsState.js';
 import { freezeVehicleMotion } from '../vehicle/vehicleKinematics.js';
 
 export function applyRedFlagHoldForSimulation(sim) {
@@ -6,10 +7,7 @@ export function applyRedFlagHoldForSimulation(sim) {
     car.previousY = car.y;
     car.previousHeading = car.heading;
     freezeVehicleMotion(car, { physicsMode: sim.physicsMode });
-    car.drsActive = false;
-    car.drsEligible = false;
-    car.drsZoneId = null;
-    car.drsZoneEnabled = false;
+    clearCurrentDrsState(car);
     car.canAttack = false;
   });
 }

package/src/simulation/race/safetyCar.js

@@ -1,6 +1,8 @@
+import { clearCurrentDrsState } from '../timing/drsState.js';
 import { pointAt } from '../track/trackModel.js';
 import { kphToSimSpeed } from '../units.js';
 import { freezeVehicleMotion, syncVehicleVelocityToHeading } from '../vehicle/vehicleKinematics.js';
+import { isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
 
 export function setSafetyCarState(sim, deployed) {
   const next = Boolean(deployed);
@@ -20,10 +22,7 @@ export function setSafetyCarState(sim, deployed) {
     }
     sim.cars.forEach((car) => {
       car.desiredOffset = 0;
-      car.drsActive = false;
-      car.drsEligible = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
     });
   }
   sim.events.unshift({ type: next ? 'safety-car' : 'green-flag', at: sim.time });
@@ -62,10 +61,7 @@ export function setRedFlagState(sim, deployed) {
     sim.raceControl.frozenOrder = sim.orderedCars().map((car) => car.id);
     sim.cars.forEach((car) => {
       freezeVehicleMotion(car, { physicsMode: sim.physicsMode });
-      car.drsActive = false;
-      car.drsEligible = false;
-      car.drsZoneId = null;
-      car.drsZoneEnabled = false;
+      clearCurrentDrsState(car);
       car.canAttack = false;
     });
   } else {
@@ -82,7 +78,7 @@ export function setRedFlagState(sim, deployed) {
         });
       } else if (!car.finished) {
         car.speed = Math.max(car.speed, kphToSimSpeed(60));
-        if (sim.physicsMode === 'advanced') syncVehicleVelocityToHeading(car);
+        if (isSimulatorPhysicsMode(sim.physicsMode)) syncVehicleVelocityToHeading(car);
         car.brake = 0;
         car.throttle = Math.max(car.throttle ?? 0, 0.35);
       }

package/src/simulation/race/stalledDnf.js

@@ -1,3 +1,4 @@
+import { clearCurrentDrsState } from '../timing/drsState.js';
 import { markCarDnf } from './retirements.js';
 import { simSpeedToKph } from '../units.js';
 import { freezeVehicleMotion } from '../vehicle/vehicleKinematics.js';
@@ -66,10 +67,7 @@ export function freezeRetiredCar(car, { physicsMode = 'arcade' } = {}) {
     stabilityState: 'destroyed',
   });
   car.canAttack = false;
-  car.drsActive = false;
-  car.drsEligible = false;
-  car.drsZoneId = null;
-  car.drsZoneEnabled = false;
+  clearCurrentDrsState(car);
 }
 
 function resetStallTimer(car) {

package/src/simulation/raceSimulation.js

@@ -1,11 +1,7 @@
 import {
   applyUnservedServicePenalty,
-  cancelPenaltyRecord,
-  createPenaltyEvent,
-  createPenaltyRecord,
-  servePenaltyRecord,
 } from './rules/penaltyLedger.js';
-import { createPenaltyCancelledEvent, createPenaltyServedEvent } from './rules/penaltyEvents.js';
+import { recordPenaltyForSimulation, servePenaltyForSimulation, cancelPenaltyForSimulation } from './rules/penaltyActions.js';
 import { buildPenaltyStatsByDriver, getPenaltyStats } from './rules/penaltyStats.js';
 import {
   reviewCollisionForSimulation,
@@ -93,7 +89,6 @@ import { applyGridDropForSimulation } from './race/gridPenalties.js';
 import { initializeRaceSimulation, normalizePitIntentForRace } from './race/raceSetup.js';
 import { runRaceStep } from './race/raceStep.js';
 import {
-  createVehicleSnapshotDependencies,
   getRaceWinnerSnapshot as getRaceWinnerSnapshotForSimulation,
   snapshotRace,
   snapshotRaceObservation,
@@ -209,7 +204,7 @@ export class F1RaceSimulation {
   }
 
   isCarInActivePitStop(car) {
-    return isCarInActivePitStopForSimulation(this, car);
+    return isCarInActivePitStopForSimulation(car);
   }
 
   schedulePitStopAtNextEntry(car, stop) {
@@ -249,7 +244,7 @@ export class F1RaceSimulation {
   }
 
   isPitServiceAreaOccupied(candidate, box) {
-    return isPitServiceAreaOccupiedForSimulation(this, candidate, box);
+    return isPitServiceAreaOccupiedForSimulation(candidate, box);
   }
 
   isPitServiceQueueOccupied(car, box) {
@@ -317,38 +312,15 @@ export class F1RaceSimulation {
   }
 
   recordPenalty(penalty) {
-    const car = this.cars.find((item) => item.id === penalty.driverId);
-    const entry = createPenaltyRecord({
-      sequence: this.nextPenaltyId,
-      time: this.time,
-      lap: this.computeLap(car?.raceDistance ?? 0),
-      penalty,
-    });
-    this.nextPenaltyId += 1;
-    this.penalties.push(entry);
-    if (entry.gridDrop > 0 && this.raceControl.mode === 'pre-start') {
-      this.applyGridDrop(entry.driverId, entry.gridDrop);
-    }
-    this.events.unshift(createPenaltyEvent(entry));
-    return entry;
+    return recordPenaltyForSimulation(this, penalty);
   }
 
   servePenalty(penaltyId) {
-    const penalty = this.penalties.find((entry) => entry.id === penaltyId);
-    const result = servePenaltyRecord(penalty, this.time);
-    if (result) {
-      this.events.unshift(createPenaltyServedEvent(result, this.time));
-    }
-    return result;
+    return servePenaltyForSimulation(this, penaltyId);
   }
 
   cancelPenalty(penaltyId) {
-    const penalty = this.penalties.find((entry) => entry.id === penaltyId);
-    const result = cancelPenaltyRecord(penalty, this.time);
-    if (result) {
-      this.events.unshift(createPenaltyCancelledEvent(result, this.time));
-    }
-    return result;
+    return cancelPenaltyForSimulation(this, penaltyId);
   }
 
   getDriverPenaltySeconds(driverId) {
@@ -389,10 +361,6 @@ export class F1RaceSimulation {
     reviewPitLaneSpeedingForSimulation(this);
   }
 
-  vehicleSnapshotDependencies() {
-    return createVehicleSnapshotDependencies(this);
-  }
-
   snapshot() {
     return snapshotRace(this);
   }

package/src/simulation/replay/replayGhosts.js

@@ -11,25 +11,17 @@ export function normalizeReplayGhosts(replayGhosts = []) {
 }
 
 export function updateReplayGhosts(replayGhosts = [], timeSeconds = 0) {
-  replayGhosts.forEach((ghost) => {
-    const previous = {
-      x: ghost.x,
-      y: ghost.y,
-      heading: ghost.heading,
-    };
-    const sample = interpolateTrajectory(ghost.trajectory, timeSeconds);
-    Object.assign(ghost, {
-      previousX: Number.isFinite(previous.x) ? previous.x : sample.x,
-      previousY: Number.isFinite(previous.y) ? previous.y : sample.y,
-      previousHeading: Number.isFinite(previous.heading) ? previous.heading : sample.heading,
-      x: sample.x,
-      y: sample.y,
-      heading: sample.heading,
-      speedKph: sample.speedKph,
-      progressMeters: sample.progressMeters,
-      timeSeconds,
-    });
-  });
+  for (let index = 0; index < replayGhosts.length; index += 1) {
+    const ghost = replayGhosts[index];
+    const previousX = ghost.x;
+    const previousY = ghost.y;
+    const previousHeading = ghost.heading;
+    interpolateTrajectoryInto(ghost, ghost.trajectory, timeSeconds);
+    ghost.previousX = Number.isFinite(previousX) ? previousX : ghost.x;
+    ghost.previousY = Number.isFinite(previousY) ? previousY : ghost.y;
+    ghost.previousHeading = Number.isFinite(previousHeading) ? previousHeading : ghost.heading;
+    ghost.timeSeconds = timeSeconds;
+  }
 }
 
 export function serializeReplayGhosts(replayGhosts = []) {
@@ -57,7 +49,7 @@ function normalizeReplayGhost(ghost, index) {
   const trajectory = normalizeTrajectory(ghost.trajectory);
   if (trajectory.length === 0) return null;
   const id = String(ghost.id ?? `replay-ghost-${index + 1}`);
-  const initial = interpolateTrajectory(trajectory, 0);
+  const initial = interpolateTrajectoryInto({}, trajectory, 0);
   return {
     id,
     label: String(ghost.label ?? id),
@@ -103,23 +95,43 @@ function normalizeTrajectory(trajectory) {
     .sort((a, b) => a.timeSeconds - b.timeSeconds);
 }
 
-function interpolateTrajectory(trajectory, timeSeconds) {
-  if (trajectory.length === 1 || timeSeconds <= trajectory[0].timeSeconds) return { ...trajectory[0] };
+function interpolateTrajectoryInto(target, trajectory, timeSeconds) {
+  if (trajectory.length === 1 || timeSeconds <= trajectory[0].timeSeconds) {
+    return writeTrajectorySample(target, trajectory[0]);
+  }
   const last = trajectory[trajectory.length - 1];
-  if (timeSeconds >= last.timeSeconds) return { ...last };
-  const nextIndex = trajectory.findIndex((sample) => sample.timeSeconds >= timeSeconds);
+  if (timeSeconds >= last.timeSeconds) return writeTrajectorySample(target, last);
+  const nextIndex = lowerBoundTrajectoryTime(trajectory, timeSeconds);
   const previous = trajectory[Math.max(0, nextIndex - 1)];
   const next = trajectory[nextIndex];
   const span = next.timeSeconds - previous.timeSeconds || 1;
   const amount = clamp((timeSeconds - previous.timeSeconds) / span, 0, 1);
-  return {
-    timeSeconds,
-    x: lerp(previous.x, next.x, amount),
-    y: lerp(previous.y, next.y, amount),
-    heading: previous.heading + normalizeAngle(next.heading - previous.heading) * amount,
-    speedKph: lerp(previous.speedKph, next.speedKph, amount),
-    progressMeters: lerp(previous.progressMeters, next.progressMeters, amount),
-  };
+  target.x = lerp(previous.x, next.x, amount);
+  target.y = lerp(previous.y, next.y, amount);
+  target.heading = previous.heading + normalizeAngle(next.heading - previous.heading) * amount;
+  target.speedKph = lerp(previous.speedKph, next.speedKph, amount);
+  target.progressMeters = lerp(previous.progressMeters, next.progressMeters, amount);
+  return target;
+}
+
+function lowerBoundTrajectoryTime(trajectory, timeSeconds) {
+  let low = 0;
+  let high = trajectory.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (trajectory[middle].timeSeconds < timeSeconds) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+
+function writeTrajectorySample(target, sample) {
+  target.x = sample.x;
+  target.y = sample.y;
+  target.heading = sample.heading;
+  target.speedKph = sample.speedKph;
+  target.progressMeters = sample.progressMeters;
+  return target;
 }
 
 function finiteNumber(value) {

package/src/simulation/rules/collisionSteward.js

@@ -1,19 +1,5 @@
 import { simSpeedToKph } from '../units.js';
 
-export function calculateCollisionPenalties({ first, second, collision = null, rule }) {
-  const penalties = [];
-  emitCollisionPenalties({
-    first,
-    second,
-    collision,
-    rule,
-    emit: (penalty) => {
-      penalties.push(penalty);
-    },
-  });
-  return penalties;
-}
-
 export function emitCollisionPenalties({ first, second, collision = null, rule, emit, emitContext = null }) {
   if (!rule || typeof emit !== 'function') return 0;
   const severity = collision?.depth ?? 0;

package/src/simulation/rules/penaltyActions.js

@@ -0,0 +1,37 @@
+import { cancelPenaltyRecord, createPenaltyEvent, createPenaltyRecord, servePenaltyRecord } from './penaltyLedger.js';
+import { createPenaltyCancelledEvent, createPenaltyServedEvent } from './penaltyEvents.js';
+
+export function recordPenaltyForSimulation(sim, penalty) {
+  const car = sim.cars.find((item) => item.id === penalty.driverId);
+  const entry = createPenaltyRecord({
+    sequence: sim.nextPenaltyId,
+    time: sim.time,
+    lap: sim.computeLap(car?.raceDistance ?? 0),
+    penalty,
+  });
+  sim.nextPenaltyId += 1;
+  sim.penalties.push(entry);
+  if (entry.gridDrop > 0 && sim.raceControl.mode === 'pre-start') {
+    sim.applyGridDrop(entry.driverId, entry.gridDrop);
+  }
+  sim.events.unshift(createPenaltyEvent(entry));
+  return entry;
+}
+
+export function servePenaltyForSimulation(sim, penaltyId) {
+  const penalty = sim.penalties.find((entry) => entry.id === penaltyId);
+  const result = servePenaltyRecord(penalty, sim.time);
+  if (result) {
+    sim.events.unshift(createPenaltyServedEvent(result, sim.time));
+  }
+  return result;
+}
+
+export function cancelPenaltyForSimulation(sim, penaltyId) {
+  const penalty = sim.penalties.find((entry) => entry.id === penaltyId);
+  const result = cancelPenaltyRecord(penalty, sim.time);
+  if (result) {
+    sim.events.unshift(createPenaltyCancelledEvent(result, sim.time));
+  }
+  return result;
+}

package/src/simulation/rules/penaltyLedger.js

@@ -48,7 +48,14 @@ export function createPenaltyEvent(entry) {
 }
 
 export function serializePenalty(penalty) {
-  return { ...penalty };
+  return {
+    ...penalty,
+    ...(Array.isArray(penalty.consequences) ? {
+      consequences: penalty.consequences.map((consequence) => ({ ...consequence })),
+    } : {}),
+    ...(Array.isArray(penalty.usedCompounds) ? { usedCompounds: [...penalty.usedCompounds] } : {}),
+    ...(Array.isArray(penalty.wheelOffsets) ? { wheelOffsets: [...penalty.wheelOffsets] } : {}),
+  };
 }
 
 export function servePenaltyRecord(penalty, time) {

package/src/simulation/rules/pitLaneSpeedingSteward.js

@@ -20,7 +20,7 @@ export function calculatePitLaneSpeedingReview({ car, rule, stewardState }) {
 
   if (!isViolation) {
     return {
-      nextState: { ...current, active: false },
+      nextState: current.active === false ? current : { ...current, active: false },
       event: null,
       penalty: null,
     };

package/src/simulation/rules/rulesReview.js

@@ -5,6 +5,7 @@ import { calculatePitLaneSpeedingReview } from './pitLaneSpeedingSteward.js';
 import { getPenaltyRule } from '../rulesConfig.js';
 import { simSpeedToKph } from '../units.js';
 import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { progressDelta } from '../race/raceDistance.js';
 
 function velocityComponentX(car) {
   return Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)
@@ -18,13 +19,6 @@ function velocityComponentY(car) {
     : Math.sin(car.heading) * car.speed;
 }
 
-function progressDelta(a, b, trackLength) {
-  let delta = a - b;
-  if (delta < -trackLength / 2) delta += trackLength;
-  if (delta > trackLength / 2) delta -= trackLength;
-  return delta;
-}
-
 function prepareCollisionStewardContext(scratch = null) {
   const target = scratch
     ? (scratch.collisionStewardContext ??= { sharedFaultDriverIds: [] })
@@ -129,7 +123,9 @@ export function reviewTrackLimitsForSimulation(sim) {
   sim.cars.forEach((car) => {
     if (isLegallyInsidePitLaneForTrackLimits(car)) {
       const current = sim.stewardState.trackLimits[car.id];
-      sim.stewardState.trackLimits[car.id] = { ...(current ?? { violations: 0 }), active: false };
+      if (!current || current.active !== false) {
+        sim.stewardState.trackLimits[car.id] = { ...(current ?? { violations: 0 }), active: false };
+      }
       return;
     }
 
@@ -146,18 +142,26 @@ export function reviewTrackLimitsForSimulation(sim) {
   });
 }
 
+const PIT_SPEED_REVIEW_SCRATCH = {
+  car: { id: null, speedKph: 0, trackState: null, pitLanePart: null },
+  rule: null,
+  stewardState: null,
+};
+
 export function reviewPitLaneSpeedingForSimulation(sim) {
   const rule = getPenaltyRule(sim.rules, 'pitLaneSpeeding');
   sim.cars.forEach((car) => {
     const currentState = sim.stewardState.pitLaneSpeeding[car.id];
-    const review = calculatePitLaneSpeedingReview({
-      car: {
-        ...car,
-        speedKph: simSpeedToKph(car.speed),
-      },
-      rule,
-      stewardState: currentState,
-    });
+    // The steward only reads the speed and pit-lane location, so feed it a
+    // pooled view instead of spreading the whole car every step.
+    const reviewCar = PIT_SPEED_REVIEW_SCRATCH.car;
+    reviewCar.id = car.id;
+    reviewCar.speedKph = simSpeedToKph(car.speed);
+    reviewCar.trackState = car.trackState;
+    reviewCar.pitLanePart = car.pitLanePart;
+    PIT_SPEED_REVIEW_SCRATCH.rule = rule;
+    PIT_SPEED_REVIEW_SCRATCH.stewardState = currentState;
+    const review = calculatePitLaneSpeedingReview(PIT_SPEED_REVIEW_SCRATCH);
     sim.stewardState.pitLaneSpeeding[car.id] = review.nextState;
     if (review.event) sim.events.unshift({ ...review.event, at: sim.time });
     if (review.penalty) sim.recordPenalty(review.penalty);

package/src/simulation/rules/trackLimitsSteward.js

@@ -22,7 +22,7 @@ export function calculateTrackLimitReview({ car, rule, track, stewardState }) {
   const wheelStates = wheelSurfaceState.wheels;
   if (wheelStates.some((wheelState) => wheelState.inPitLane)) {
     return {
-      nextState: { ...current, active: false },
+      nextState: current.active === false ? current : { ...current, active: false },
       event: null,
       penalty: null,
     };
@@ -34,7 +34,7 @@ export function calculateTrackLimitReview({ car, rule, track, stewardState }) {
 
   if (!isViolation) {
     return {
-      nextState: { ...current, active: false },
+      nextState: current.active === false ? current : { ...current, active: false },
       event: null,
       penalty: null,
     };

package/src/simulation/simMath.js

@@ -32,3 +32,7 @@ export function seededRange(random, min, max) {
 export function wrapDistance(value, length) {
   return ((value % length) + length) % length;
 }
+
+export function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}

package/src/simulation/snapshots/raceSnapshots.js

@@ -38,12 +38,8 @@ export function createVehicleSnapshotDependencies(sim) {
     normalizePitIntent,
     PIT_INTENT_NONE,
     serializeLapTelemetry,
-    serializeObservationPitStop: (pitStop) => serializeObservationPitStop(
-      pitStop,
-      normalizePitIntent,
-      PIT_INTENT_NONE,
-    ),
-    serializePitStop: (pitStop) => serializePitStop(pitStop, normalizePitIntent, PIT_INTENT_NONE),
+    serializeObservationPitStop,
+    serializePitStop,
     serializeRenderPitStop,
     simSpeedToKph,
     simUnitsToMeters,
@@ -220,11 +216,34 @@ function carsForSnapshot(sim, ordered) {
   return [...ranked, ...unranked];
 }
 
+const RENDER_CAR_ORDER_SCRATCH = new WeakMap();
+
 function renderCarsForSnapshotInto(targetCars, sim, ordered, dependencies) {
-  const entries = carsForSnapshot(sim, ordered);
-  targetCars.length = entries.length;
-  entries.forEach(({ car }, index) => {
-    targetCars[index] = serializeRenderCarInto(targetCars[index] ?? {}, car, dependencies);
-  });
+  let scratch = RENDER_CAR_ORDER_SCRATCH.get(targetCars);
+  if (!scratch) {
+    scratch = { orderedIds: new Set(), unranked: [] };
+    RENDER_CAR_ORDER_SCRATCH.set(targetCars, scratch);
+  }
+  const { orderedIds, unranked } = scratch;
+  orderedIds.clear();
+  unranked.length = 0;
+  let count = 0;
+  for (const car of ordered) {
+    orderedIds.add(car.id);
+    targetCars[count] = serializeRenderCarInto(targetCars[count] ?? {}, car, dependencies);
+    count += 1;
+  }
+  for (const car of sim.cars) {
+    if (!orderedIds.has(car.id)) unranked.push(car);
+  }
+  unranked.sort((a, b) => a.index - b.index);
+  for (const car of unranked) {
+    targetCars[count] = serializeRenderCarInto(targetCars[count] ?? {}, car, dependencies);
+    count += 1;
+  }
+  targetCars.length = count;
+  // Scratch owns ordering only; do not retain live participants between frames.
+  orderedIds.clear();
+  unranked.length = 0;
   return targetCars;
 }

package/src/simulation/timing/drsState.js

@@ -0,0 +1,8 @@
+// Suppress the current latch without erasing passage history or next-zone hints.
+// External placement uses the separate full reset in vehicleState.js.
+export function clearCurrentDrsState(car) {
+  car.drsActive = false;
+  car.drsEligible = false;
+  car.drsZoneId = null;
+  car.drsZoneEnabled = false;
+}

package/src/simulation/timing/drsTiming.js

@@ -1,3 +1,4 @@
+import { clearCurrentDrsState } from './drsState.js';
 import { wrapDistance } from '../simMath.js';
 
 function wrapProgress(value, length) {
@@ -106,10 +107,7 @@ function updateDrsLatchCore(
   runtimeBenchmarkStats = null,
 ) {
   if (safetyCarDeployed || car.finished) {
-    car.drsEligible = false;
-    car.drsActive = false;
-    car.drsZoneId = null;
-    car.drsZoneEnabled = false;
+    clearCurrentDrsState(car);
     car._drsZoneRef = null;
     return;
   }