@inventure71/paddockjs 4.1.0 → 4.2.0

package/src/simulation/race/raceStep.js

@@ -1,7 +1,7 @@
 import { decideDriverControls } from '../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/safetyCar.js

@@ -1,6 +1,7 @@
 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);
@@ -82,7 +83,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/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

@@ -129,7 +129,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 +148,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/timing/sectorPerformance.js

@@ -5,7 +5,7 @@ const OVERALL_BEST_1 = '_sectorPerformanceOverallBest1';
 const OVERALL_BEST_2 = '_sectorPerformanceOverallBest2';
 
 export function createEmptySectorTimes() {
-  return Array.from({ length: TELEMETRY_SECTOR_COUNT }, () => null);
+  return new Array(TELEMETRY_SECTOR_COUNT).fill(null);
 }
 
 export function createEmptySectorPerformance() {
@@ -17,11 +17,19 @@ export function createEmptySectorPerformance() {
 }
 
 export function serializeSectorTimes(values) {
-  return createEmptySectorTimes().map((_, index) => finiteOrNull(values?.[index]));
+  const result = new Array(TELEMETRY_SECTOR_COUNT);
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    result[index] = finiteOrNull(values?.[index]);
+  }
+  return result;
 }
 
 export function serializeSectorPerformance(values) {
-  return createEmptySectorTimes().map((_, index) => values?.[index] ?? null);
+  const result = new Array(TELEMETRY_SECTOR_COUNT);
+  for (let index = 0; index < TELEMETRY_SECTOR_COUNT; index += 1) {
+    result[index] = values?.[index] ?? null;
+  }
+  return result;
 }
 
 export function updateSectorPerformance(cars, stats = null) {

package/src/simulation/track/spatialQueries.js

@@ -6,27 +6,59 @@ import { queryNearestTrackProjection, queryNearestTrackProjectionInto } from './
 import { recordStat } from './trackQueryStats.js';
 
 export function pointAt(track, distanceAlong) {
+  return pointAtInto(track, distanceAlong, {});
+}
+
+export function pointAtInto(track, distanceAlong, target) {
   const wrapped = wrapDistance(distanceAlong, track.length);
-  const low = sampleIndexAtDistance(track, wrapped);
+  const low = sampleIndexAtDistanceUnwrapped(track, wrapped);
 
   const next = track.samples[low] ?? track.samples[0];
   const previous = track.samples[Math.max(0, low - 1)] ?? next;
   const span = Math.max(1, next.distance - previous.distance);
   const amount = clamp((wrapped - previous.distance) / span, 0, 1);
 
-  return {
-    x: previous.x + (next.x - previous.x) * amount,
-    y: previous.y + (next.y - previous.y) * amount,
-    heading: previous.heading + normalizeAngle(next.heading - previous.heading) * amount,
-    normalX: previous.normalX + (next.normalX - previous.normalX) * amount,
-    normalY: previous.normalY + (next.normalY - previous.normalY) * amount,
-    curvature: previous.curvature + (next.curvature - previous.curvature) * amount,
-    distance: wrapped,
-  };
+  target.x = previous.x + (next.x - previous.x) * amount;
+  target.y = previous.y + (next.y - previous.y) * amount;
+  target.heading = previous.heading + normalizeAngle(next.heading - previous.heading) * amount;
+  target.normalX = previous.normalX + (next.normalX - previous.normalX) * amount;
+  target.normalY = previous.normalY + (next.normalY - previous.normalY) * amount;
+  target.curvature = previous.curvature + (next.curvature - previous.curvature) * amount;
+  target.distance = wrapped;
+  return target;
 }
 
-export function sampleIndexAtDistance(track, distanceAlong) {
+export function sampleHeadingCurvatureAtInto(track, distanceAlong, target) {
   const wrapped = wrapDistance(distanceAlong, track.length);
+  const low = sampleIndexAtDistanceUnwrapped(track, wrapped);
+
+  const next = track.samples[low] ?? track.samples[0];
+  const previous = track.samples[Math.max(0, low - 1)] ?? next;
+  const span = Math.max(1, next.distance - previous.distance);
+  const amount = clamp((wrapped - previous.distance) / span, 0, 1);
+
+  target.heading = previous.heading + normalizeAngle(next.heading - previous.heading) * amount;
+  target.curvature = previous.curvature + (next.curvature - previous.curvature) * amount;
+  return target;
+}
+
+export function sampleHeadingAt(track, distanceAlong) {
+  const wrapped = wrapDistance(distanceAlong, track.length);
+  const low = sampleIndexAtDistanceUnwrapped(track, wrapped);
+
+  const next = track.samples[low] ?? track.samples[0];
+  const previous = track.samples[Math.max(0, low - 1)] ?? next;
+  const span = Math.max(1, next.distance - previous.distance);
+  const amount = clamp((wrapped - previous.distance) / span, 0, 1);
+
+  return previous.heading + normalizeAngle(next.heading - previous.heading) * amount;
+}
+
+export function sampleIndexAtDistance(track, distanceAlong) {
+  return binarySampleIndexAtDistance(track, wrapDistance(distanceAlong, track.length));
+}
+
+function binarySampleIndexAtDistance(track, wrapped) {
   let low = 0;
   let high = track.samples.length - 1;
 
@@ -39,6 +71,43 @@ export function sampleIndexAtDistance(track, distanceAlong) {
   return low;
 }
 
+// Uniform-bin index over sample distances: table[bin] holds the smallest
+// sample index whose distance reaches the bin start, so a lookup plus a short
+// forward walk returns exactly what the binary search would, in O(1). Built
+// eagerly when the track query index is attached; lookups on sample arrays
+// without a prepared table fall back to the binary search.
+const SAMPLE_INDEX_LUTS = new WeakMap();
+
+export function prepareSampleIndexLut(track) {
+  const samples = track?.samples;
+  if (!Array.isArray(samples) || samples.length < 2 || !Number.isFinite(track.length) || track.length <= 0) return;
+  if (SAMPLE_INDEX_LUTS.has(samples)) return;
+  const lastIndex = samples.length - 1;
+  const bins = Math.max(1, lastIndex * 2);
+  const table = new Int32Array(bins);
+  const binSize = track.length / bins;
+  let index = 0;
+  for (let bin = 0; bin < bins; bin += 1) {
+    const start = bin * binSize;
+    while (index < lastIndex && samples[index].distance < start) index += 1;
+    table[bin] = index;
+  }
+  SAMPLE_INDEX_LUTS.set(samples, { bins, binSize, table });
+}
+
+function sampleIndexAtDistanceUnwrapped(track, wrapped) {
+  const samples = track.samples;
+  const lut = Number.isFinite(wrapped) ? SAMPLE_INDEX_LUTS.get(samples) : null;
+  if (!lut) return binarySampleIndexAtDistance(track, wrapped);
+  const lastIndex = samples.length - 1;
+  let bin = Math.floor(wrapped / lut.binSize);
+  if (bin < 0) bin = 0;
+  else if (bin >= lut.bins) bin = lut.bins - 1;
+  let index = lut.table[bin];
+  while (index < lastIndex && samples[index].distance < wrapped) index += 1;
+  return index;
+}
+
 export function nearestSampleInRange(track, position, startIndex, endIndex) {
   const sampleCount = track.samples.length - 1;
   let best = null;

package/src/simulation/track/trackModel.js

@@ -6,6 +6,7 @@ import { generateCenterlineControls, generateFallbackCenterlineControls, generat
 import { isValidProceduralTrackModel } from './trackValidation.js';
 import { recalculateSampleGeometry } from './sampleGeometry.js';
 import { rotateSamplesToStandingStart, straightenStandingStartSamples } from './startStraight.js';
+import { prepareSampleIndexLut } from './spatialQueries.js';
 import { createTrackSectors } from './trackSectors.js';
 import { deriveDrsZones, normalizeDrsZone } from './drsZones.js';
 import { createPitLaneModel } from './pitLaneLayout.js';
@@ -15,7 +16,14 @@ import { attachTrackSnapshotJsonSerializer } from './trackSnapshotJson.js';
 
 export { WORLD, TRACK } from './trackConstants.js';
 export { isInDrsZone } from './drsZones.js';
-export { nearestTrackState, offsetTrackPoint, pointAt } from './spatialQueries.js';
+export {
+  nearestTrackState,
+  offsetTrackPoint,
+  pointAt,
+  pointAtInto,
+  sampleHeadingAt,
+  sampleHeadingCurvatureAtInto,
+} from './spatialQueries.js';
 
 const PROCEDURAL_TRACK_CACHE = new Map();
 const TRACK_MODEL_CACHE = new WeakMap();
@@ -57,6 +65,7 @@ export function buildTrackModel(track = TRACK) {
     ? null
     : createPitLaneModel(model);
   attachTrackQueryIndex(model, createTrackQueryIndex(model));
+  prepareSampleIndexLut(model);
   attachTrackSnapshotJsonSerializer(model);
   if (canReuseCachedModel) {
     TRACK_MODEL_CACHE.set(track, freezeTrackModel(model));

package/src/simulation/vehicle/contactResolution.js

@@ -6,7 +6,7 @@ import {
 } from '../collisionGeometry.js';
 import { canCollide, isCollidable } from '../participants/participantInteractions.js';
 import { clamp, normalizeAngle } from '../simMath.js';
-import { VEHICLE_LIMITS } from './vehiclePhysics.js';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode } from './vehiclePhysics.js';
 import { shiftPreviousRenderPose } from '../pit/pitRouting.js';
 
 const MAX_COLLISION_CORRECTION = 4.5;
@@ -114,8 +114,8 @@ export function resolveCollisionsForSimulation(sim) {
       }
 
       if (oneCarFixed) {
-        if (!firstPitControlled) dampPitContactVelocity(first, 0.985, sim.physicsMode === 'advanced');
-        if (!secondPitControlled) dampPitContactVelocity(second, 0.985, sim.physicsMode === 'advanced');
+        if (!firstPitControlled) dampPitContactVelocity(first, 0.985, isSimulatorPhysicsMode(sim.physicsMode));
+        if (!secondPitControlled) dampPitContactVelocity(second, 0.985, isSimulatorPhysicsMode(sim.physicsMode));
       } else {
         applyContactVelocityResponse(sim, first, second, collision.axis);
       }
@@ -167,7 +167,7 @@ export function resolveCollisionsForSimulation(sim) {
 export function applyContactVelocityResponse(sim, first, second, axis, options = {}) {
   recordContactVelocityResponse(options.stats);
   if (
-    sim.physicsMode === 'advanced' ||
+    isSimulatorPhysicsMode(sim.physicsMode) ||
     Number.isFinite(first.velocityX) ||
     Number.isFinite(second.velocityX)
   ) {

package/src/simulation/vehicle/vehicleGeometry.js

@@ -274,33 +274,22 @@ function sweptPoseSignature(pose) {
   ].join(':');
 }
 
-function geometryPose(car) {
-  const { x, y, heading } = currentPoseState(car);
-  return {
-    x,
-    y,
-    heading,
-    previousX: finiteOr(car.previousX, x),
-    previousY: finiteOr(car.previousY, y),
-    previousHeading: normalizeAngle(finiteOr(car.previousHeading, heading)),
-  };
-}
-
 function currentGeometryStateMatches(car, state) {
   const pose = state?.pose;
   if (!pose) return false;
-  const currentPose = currentPoseState(car);
   return (
-    pose.x === currentPose.x &&
-    pose.y === currentPose.y &&
-    pose.heading === currentPose.heading
+    pose.x === finiteOr(car.x, 0) &&
+    pose.y === finiteOr(car.y, 0) &&
+    pose.heading === normalizeAngle(finiteOr(car.heading, 0))
   );
 }
 
 function geometryStateMatches(car, state) {
   const pose = state?.pose;
   if (!pose) return false;
-  const { x, y, heading } = currentPoseState(car);
+  const x = finiteOr(car.x, 0);
+  const y = finiteOr(car.y, 0);
+  const heading = normalizeAngle(finiteOr(car.heading, 0));
   return (
     pose.x === x &&
     pose.y === y &&
@@ -312,6 +301,10 @@ function geometryStateMatches(car, state) {
 }
 
 export function createVehicleShapeAabb(shape) {
+  return writeVehicleShapeAabb({}, shape);
+}
+
+function writeVehicleShapeAabb(target, shape) {
   let minX = Infinity;
   let maxX = -Infinity;
   let minY = Infinity;
@@ -323,12 +316,11 @@ export function createVehicleShapeAabb(shape) {
     if (corner.y < minY) minY = corner.y;
     if (corner.y > maxY) maxY = corner.y;
   }
-  return {
-    minX,
-    maxX,
-    minY,
-    maxY,
-  };
+  target.minX = minX;
+  target.maxX = maxX;
+  target.minY = minY;
+  target.maxY = maxY;
+  return target;
 }
 
 export function mergeAabbs(aabbs) {
@@ -346,32 +338,73 @@ export function mergeAabbs(aabbs) {
   return { minX, maxX, minY, maxY };
 }
 
-export function createVehicleGeometryState(car) {
-  const pose = geometryPose(car);
-  const current = writeVehicleGeometry(null, pose);
-  const previous = writeVehicleGeometry(null, {
-    x: pose.previousX,
-    y: pose.previousY,
-    heading: pose.previousHeading,
-  });
-  const bodyAabb = createVehicleShapeAabb(current.body);
-  const previousBodyAabb = createVehicleShapeAabb(previous.body);
-  const sweptBodyAabb = mergeAabbs([previousBodyAabb, bodyAabb]);
+function writeGeometryPose(target, car) {
+  const pose = target ?? {};
+  const x = finiteOr(car.x, 0);
+  const y = finiteOr(car.y, 0);
+  const heading = normalizeAngle(finiteOr(car.heading, 0));
+  pose.x = x;
+  pose.y = y;
+  pose.heading = heading;
+  pose.previousX = finiteOr(car.previousX, x);
+  pose.previousY = finiteOr(car.previousY, y);
+  pose.previousHeading = normalizeAngle(finiteOr(car.previousHeading, heading));
+  return pose;
+}
 
-  return {
-    pose,
-    currentSignature: currentPoseSignature(pose),
-    sweptSignature: sweptPoseSignature(pose),
-    signature: sweptPoseSignature(pose),
-    current,
-    previous,
-    body: current.body,
-    wheels: current.wheels,
-    contactPatches: current.contactPatches,
-    bodyAabb,
-    previousBodyAabb,
-    sweptBodyAabb,
+function createGeometryStateShell() {
+  const state = {
+    pose: null,
+    current: null,
+    previous: null,
+    body: null,
+    wheels: null,
+    contactPatches: null,
+    bodyAabb: {},
+    previousBodyAabb: {},
+    sweptBodyAabb: {},
   };
+  // Signatures are derived lazily from the pose: nothing on the hot path reads
+  // them, so the per-step string formatting cost must not be paid eagerly.
+  Object.defineProperties(state, {
+    currentSignature: {
+      get() { return currentPoseSignature(this.pose); },
+      enumerable: true,
+    },
+    sweptSignature: {
+      get() { return sweptPoseSignature(this.pose); },
+      enumerable: true,
+    },
+    signature: {
+      get() { return sweptPoseSignature(this.pose); },
+      enumerable: true,
+    },
+  });
+  return state;
+}
+
+const PREVIOUS_GEOMETRY_POSE_SCRATCH = { x: 0, y: 0, heading: 0 };
+
+export function createVehicleGeometryState(car, target = null) {
+  const state = target ?? createGeometryStateShell();
+  const pose = state.pose = writeGeometryPose(state.pose, car);
+  const current = state.current = writeVehicleGeometry(state.current, pose);
+  PREVIOUS_GEOMETRY_POSE_SCRATCH.x = pose.previousX;
+  PREVIOUS_GEOMETRY_POSE_SCRATCH.y = pose.previousY;
+  PREVIOUS_GEOMETRY_POSE_SCRATCH.heading = pose.previousHeading;
+  const previous = state.previous = writeVehicleGeometry(state.previous, PREVIOUS_GEOMETRY_POSE_SCRATCH);
+  const bodyAabb = writeVehicleShapeAabb(state.bodyAabb, current.body);
+  const previousBodyAabb = writeVehicleShapeAabb(state.previousBodyAabb, previous.body);
+  const sweptBodyAabb = state.sweptBodyAabb;
+  sweptBodyAabb.minX = Math.min(bodyAabb.minX, previousBodyAabb.minX);
+  sweptBodyAabb.maxX = Math.max(bodyAabb.maxX, previousBodyAabb.maxX);
+  sweptBodyAabb.minY = Math.min(bodyAabb.minY, previousBodyAabb.minY);
+  sweptBodyAabb.maxY = Math.max(bodyAabb.maxY, previousBodyAabb.maxY);
+
+  state.body = current.body;
+  state.wheels = current.wheels;
+  state.contactPatches = current.contactPatches;
+  return state;
 }
 
 export function createCurrentVehicleGeometryState(car, target = null) {
@@ -388,8 +421,13 @@ export function createCurrentVehicleGeometryState(car, target = null) {
 
 export function getVehicleGeometryState(car) {
   if (geometryStateMatches(car, car.geometryState)) return car.geometryState;
-  car.geometryState = createVehicleGeometryState(car);
-  return car.geometryState;
+  // Double-buffer pooled states: consumers may still hold the state returned
+  // for the previous pose within a step, so alternate between two reusable
+  // shells instead of allocating a fresh geometry tree on every pose change.
+  const next = createVehicleGeometryState(car, car._geometryStateSpare ?? null);
+  car._geometryStateSpare = car.geometryState ?? null;
+  car.geometryState = next;
+  return next;
 }
 
 export function getCurrentVehicleGeometryState(car) {

package/src/simulation/vehicle/vehiclePhysics.js

@@ -50,7 +50,11 @@ const SIMULATOR_SURFACE_MODEL = {
 };
 
 export function normalizePhysicsMode(value) {
-  return value === 'advanced' ? 'advanced' : DEFAULT_PHYSICS_MODE;
+  return PHYSICS_MODES.includes(value) ? value : DEFAULT_PHYSICS_MODE;
+}
+
+export function isSimulatorPhysicsMode(value) {
+  return value === 'advanced';
 }
 
 function accelerationLimit(speed, surfaceGrip) {
@@ -120,7 +124,8 @@ function setPhysicsTelemetry(car, {
 }
 
 export function integrateVehiclePhysics(car, controls, dt, options = {}) {
-  if (normalizePhysicsMode(options.physicsMode) === 'advanced') {
+  const mode = normalizePhysicsMode(options.physicsMode);
+  if (mode === 'advanced') {
     return integrateSimulatorVehiclePhysics(car, controls, dt, options);
   }
   return integrateArcadeVehiclePhysics(car, controls, dt, options);

package/src/simulation/vehicle/vehicleSnapshots.js

@@ -1,4 +1,7 @@
-import { serializeParticipantInteraction } from '../participants/participantInteractions.js';
+import {
+  serializeParticipantInteraction,
+  serializeParticipantInteractionCached,
+} from '../participants/participantInteractions.js';
 
 export function finiteOrNull(value) {
   return Number.isFinite(value) ? value : null;
@@ -185,7 +188,7 @@ export function serializeRenderCarInto(target, car, dependencies) {
   target.dnfOrder = car.dnfOrder ?? null;
   target.outOfRace = Boolean(car.outOfRace || car.destroyed);
   target.pitStop = serializeRenderPitStop(car.pitStop);
-  target.interaction = serializeParticipantInteraction(car.interaction);
+  target.interaction = serializeParticipantInteractionCached(car);
   return target;
 }
 

package/src/simulation/vehicle/vehicleState.js

@@ -2,7 +2,7 @@ import { buildDriverPersonality } from '../driverController.js';
 import { clamp, normalizeAngle, seededRange } from '../simMath.js';
 import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
 import { kphToSimSpeed, metersToSimUnits } from '../units.js';
-import { VEHICLE_LIMITS } from './vehiclePhysics.js';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode } from './vehiclePhysics.js';
 import { applyWheelSurfaceState } from './wheelSurface.js';
 import { nearestTrackStateForCar } from '../track/trackStatePolicy.js';
 import { clearCarDnf } from '../race/retirements.js';
@@ -73,6 +73,7 @@ export function createCar(driver, index, random, track, { standingStart = false,
     downforceCoefficient: vehicle.downforceCoefficient ?? 6.1 + seededRange(random, -0.18, 0.18),
     tireGrip: vehicle.tireGrip ?? 2.22 + racecraft * 0.28 + seededRange(random, -0.03, 0.03),
     tireCare: vehicle.tireCare ?? 1,
+    driverModel: driver.driverModel ?? vehicle.driverModel ?? null,
     pace,
     racecraft,
     personality,
@@ -170,7 +171,7 @@ export function applyExternalCarState(car, partial, context) {
   }
   car.speed = clamp(Number.isFinite(car.speed) ? car.speed : 0, 0, VEHICLE_LIMITS.maxSpeed);
   car.heading = normalizeAngle(Number.isFinite(car.heading) ? car.heading : 0);
-  syncExternalVelocityState(car, nextPartial, physicsMode === 'advanced');
+  syncExternalVelocityState(car, nextPartial, isSimulatorPhysicsMode(physicsMode));
   const centerState = nearestTrackStateForCar(track, car, car, car.progress ?? car.raceDistance);
   applyWheelSurfaceState(car, track, { centerState });
   if (

package/src/ui/raceCanvasTemplate.js

@@ -39,8 +39,9 @@ export function createRaceCanvasMarkup({
   }
   const timingPanelId = includeTimingTower ? createTimingPanelId() : '';
   const showPhysicsModeIndicator = debug.physicsModeIndicator === true;
-  const physicsModeLabel = physicsMode === 'advanced' ? 'Advanced physics mode' : 'Arcade physics mode';
-  const physicsModeClass = physicsMode === 'advanced' ? 'advanced' : 'arcade';
+  const simulatorPhysics = physicsMode === 'advanced';
+  const physicsModeLabel = `${simulatorPhysics ? 'Advanced' : 'Arcade'} physics mode`;
+  const physicsModeClass = simulatorPhysics ? 'advanced' : 'arcade';
 
   const body = `
       <div class="track-canvas" data-track-canvas></div>