@inventure71/paddockjs 4.0.0 → 4.2.0

package/src/simulation/driver/racingControls.js

@@ -1,7 +1,7 @@
 import { clamp, normalizeAngle } from '../simMath.js';
 import { kphToSimSpeed, metersToSimUnits, simUnitsToMeters } from '../units.js';
-import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
-import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { pointAtInto, sampleHeadingAt, sampleHeadingCurvatureAtInto } from '../track/trackModel.js';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
 import { BRAKING_LOOKAHEAD_MAX_DISTANCE, CURVATURE_LOOKAHEAD_SAMPLES, EDGE_RECOVERY_MIN_LOOKAHEAD, LOOKAHEAD_BASE_DISTANCE, LOOKAHEAD_MAX_DISTANCE, OVERTAKE_LATERAL_MIN, PREVIEW_CURVATURE_CAP, TRAFFIC_GAP_AHEAD, TRAFFIC_SIDE_GAP } from './driverControlConstants.js';
 import { createDriverInput } from './driverInput.js';
 import { angleToPoint } from './driverMath.js';
@@ -10,15 +10,14 @@ import { calculateActualOverlapPenalty, calculatePlannedTrafficPenalty, planRaci
 import { analyzeTrackEdgeMotion } from './recoveryDynamics.js';
 
 export function decideRacingControls(car, orderIndex, race) {
-  if (race.physicsMode === 'advanced') {
+  if (isSimulatorPhysicsMode(race.physicsMode)) {
     return decideSimulatorRacingControls(car, orderIndex, race);
   }
   return decideArcadeRacingControls(car, orderIndex, race);
 }
 
-export function decideArcadeRacingControls(car, orderIndex, race) {
-  return decideRacingControlsForMode(car, orderIndex, race, {
-    simulatorMode: false,
+const ARCADE_CONTROL_PROFILE = {
+  simulatorMode: false,
     baseLookaheadSpeedFactor: (aggression) => 1.62 - aggression * 0.12,
     previewLookaheadSpeedFactor: 3.15,
     edgeLookaheadPenaltyMeters: 18,
@@ -73,12 +72,14 @@ export function decideArcadeRacingControls(car, orderIndex, race) {
     recoveryHeadingThrottleStart: 0.38,
     throttleResponseKph: 16,
     throttleScale: () => 1,
-  });
+};
+
+export function decideArcadeRacingControls(car, orderIndex, race) {
+  return decideRacingControlsForMode(car, orderIndex, race, ARCADE_CONTROL_PROFILE);
 }
 
-export function decideSimulatorRacingControls(car, orderIndex, race) {
-  return decideRacingControlsForMode(car, orderIndex, race, {
-    simulatorMode: true,
+const SIMULATOR_CONTROL_PROFILE = {
+  simulatorMode: true,
     baseLookaheadSpeedFactor: (aggression) => 2.45 - aggression * 0.06,
     previewLookaheadSpeedFactor: 6.15,
     edgeLookaheadPenaltyMeters: 34,
@@ -141,7 +142,10 @@ export function decideSimulatorRacingControls(car, orderIndex, race) {
       0,
       1,
     ),
-  });
+};
+
+export function decideSimulatorRacingControls(car, orderIndex, race) {
+  return decideRacingControlsForMode(car, orderIndex, race, SIMULATOR_CONTROL_PROFILE);
 }
 
 function decideRacingControlsForMode(car, orderIndex, race, profile) {
@@ -170,7 +174,7 @@ function decideRacingControlsForMode(car, orderIndex, race, profile) {
     EDGE_RECOVERY_MIN_LOOKAHEAD,
     LOOKAHEAD_MAX_DISTANCE,
   );
-  const targetBase = pointAt(race.track, car.progress + lookahead);
+  const targetBase = pointAtInto(race.track, car.progress + lookahead, TARGET_BASE_SCRATCH);
   const curvature = Math.max(
     car.trackState.curvature,
     targetBase.curvature,
@@ -189,8 +193,9 @@ function decideRacingControlsForMode(car, orderIndex, race, profile) {
     -edgeGuard.recoveryOffset,
     edgeGuard.recoveryOffset,
   );
-  const target = offsetTrackPoint(targetBase, targetOffset);
-  const angleError = angleToPoint(car, target);
+  TARGET_POINT_SCRATCH.x = targetBase.x + targetBase.normalX * targetOffset;
+  TARGET_POINT_SCRATCH.y = targetBase.y + targetBase.normalY * targetOffset;
+  const angleError = angleToPoint(car, TARGET_POINT_SCRATCH);
   const headingError = normalizeAngle(targetBase.heading - car.heading);
   const lateralError = car.trackState?.signedOffset ?? 0;
   const outwardDriftAngle = simulatorMode &&
@@ -363,15 +368,20 @@ function decideRacingControlsForMode(car, orderIndex, race, profile) {
     .controls();
 }
 
+const LOOKAHEAD_SAMPLE_SCRATCH = { heading: 0, curvature: 0 };
+const TARGET_BASE_SCRATCH = { x: 0, y: 0, heading: 0, normalX: 0, normalY: 0, curvature: 0, distance: 0 };
+const TARGET_POINT_SCRATCH = { x: 0, y: 0 };
+
 export function maxLookaheadCurvature(track, progress, lookahead) {
   let maximum = 0;
-  let previous = pointAt(track, progress);
+  const sample = LOOKAHEAD_SAMPLE_SCRATCH;
+  let previousHeading = sampleHeadingCurvatureAtInto(track, progress, sample).heading;
+  const segmentDistance = Math.max(1, lookahead / CURVATURE_LOOKAHEAD_SAMPLES);
   for (let index = 1; index <= CURVATURE_LOOKAHEAD_SAMPLES; index += 1) {
-    const sample = pointAt(track, progress + lookahead * (index / CURVATURE_LOOKAHEAD_SAMPLES));
-    const segmentDistance = Math.max(1, lookahead / CURVATURE_LOOKAHEAD_SAMPLES);
-    const segmentCurvature = Math.abs(normalizeAngle(sample.heading - previous.heading)) / segmentDistance;
+    sampleHeadingCurvatureAtInto(track, progress + lookahead * (index / CURVATURE_LOOKAHEAD_SAMPLES), sample);
+    const segmentCurvature = Math.abs(normalizeAngle(sample.heading - previousHeading)) / segmentDistance;
     maximum = Math.max(maximum, Math.abs(sample.curvature ?? 0), Math.min(segmentCurvature, PREVIEW_CURVATURE_CAP));
-    previous = sample;
+    previousHeading = sample.heading;
   }
   return maximum;
 }
@@ -380,16 +390,16 @@ export function calculateRacingLineOffset(car, race, lookahead, curvature, edgeG
   const cornerStrength = clamp((curvature - 0.00012) / 0.00095, 0, 1);
   if (cornerStrength <= 0) return 0;
 
-  const entry = pointAt(race.track, car.progress - lookahead * 0.35);
-  const apex = pointAt(race.track, car.progress + lookahead * 0.55);
-  const exit = pointAt(race.track, car.progress + lookahead * 1.25);
-  const signedEntry = normalizeAngle(apex.heading - entry.heading);
-  const signedExit = normalizeAngle(exit.heading - apex.heading);
+  const entryHeading = sampleHeadingAt(race.track, car.progress - lookahead * 0.35);
+  const apexHeading = sampleHeadingAt(race.track, car.progress + lookahead * 0.55);
+  const exitHeading = sampleHeadingAt(race.track, car.progress + lookahead * 1.25);
+  const signedEntry = normalizeAngle(apexHeading - entryHeading);
+  const signedExit = normalizeAngle(exitHeading - apexHeading);
   const turnDirection = Math.sign(Math.abs(signedEntry) > Math.abs(signedExit) ? signedEntry : signedExit);
   if (turnDirection === 0) return 0;
 
   const aggression = car.aggression ?? car.personality?.baseAggression ?? 0.5;
-  const simulatorMode = race.physicsMode === 'advanced';
+  const simulatorMode = isSimulatorPhysicsMode(race.physicsMode);
   const safeEdge = race.track.width / 2 - VEHICLE_LIMITS.carWidth *
     (simulatorMode ? 2.05 - aggression * 0.08 : 1.15 - aggression * 0.12);
   const apexOffset = turnDirection * safeEdge *

package/src/simulation/driver/racingLinePlan.js

@@ -18,15 +18,16 @@ export function planRacingLine(car, orderIndex, race) {
   let bestOffset = currentOffset;
   let bestScore = -Infinity;
 
-  LANE_OFFSETS.forEach((rawOffset) => {
-    const offset = clamp(rawOffset, -trackLimit, trackLimit);
+  for (let laneIndex = 0; laneIndex < LANE_OFFSETS.length; laneIndex += 1) {
+    const offset = clamp(LANE_OFFSETS[laneIndex], -trackLimit, trackLimit);
     const edgeClearance = trackLimit - Math.abs(offset);
     let score = 80;
     score -= Math.abs(offset - preferred) * 0.18;
     score -= Math.abs(offset - currentOffset) * (0.09 - aggression * 0.025);
     score -= Math.max(0, LANE_EDGE_CLEARANCE_TARGET - edgeClearance) * (0.92 - aggression * 0.42);
 
-    traffic.forEach((entry) => {
+    for (let trafficIndex = 0; trafficIndex < traffic.length; trafficIndex += 1) {
+      const entry = traffic[trafficIndex];
       const lateral = Math.abs(entry.signedOffset - offset);
       if (entry.gap > 0 && entry.gap < TRAFFIC_GAP_AHEAD) {
         const overlapRisk = clamp(TRAFFIC_SIDE_OVERLAP - lateral, 0, TRAFFIC_SIDE_OVERLAP);
@@ -38,7 +39,7 @@ export function planRacingLine(car, orderIndex, race) {
         const sideOverlapRisk = clamp(TRAFFIC_SIDE_OVERLAP - lateral, 0, TRAFFIC_SIDE_OVERLAP);
         score -= sideOverlapRisk * (TRAFFIC_SIDE_OVERLAP + entry.gap) * 0.052 * (1 - riskTolerance * 0.22);
       }
-    });
+    }
 
     if (ahead && car.gapAhead < TRAFFIC_GAP_AHEAD) {
       const passSide = attackPlan?.targetOffset ?? clamp(
@@ -73,7 +74,7 @@ export function planRacingLine(car, orderIndex, race) {
       bestScore = score;
       bestOffset = offset;
     }
-  });
+  }
 
   const laneChangeRate = metersToSimUnits(0.95 + car.racecraft * 0.32 + aggression * 0.78);
   car.desiredOffset = currentOffset + clamp(bestOffset - currentOffset, -laneChangeRate, laneChangeRate);

package/src/simulation/driver/rejoinControls.js

@@ -4,11 +4,11 @@ import { offsetTrackPoint, pointAt } from '../track/trackModel.js';
 import { REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX } from './driverControlConstants.js';
 import { angleToPoint } from './driverMath.js';
 import { createDriverInput } from './driverInput.js';
-import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { VEHICLE_LIMITS, isSimulatorPhysicsMode } from '../vehicle/vehiclePhysics.js';
 import { analyzeTrackEdgeMotion } from './recoveryDynamics.js';
 
 export function decideRejoinControls(car, race) {
-  if (race.physicsMode === 'advanced') {
+  if (isSimulatorPhysicsMode(race.physicsMode)) {
     return decideSimulatorRejoinControls(car, race);
   }
   return decideArcadeRejoinControls(car, race);
@@ -103,7 +103,7 @@ export function decideSimulatorRejoinControls(car, race) {
 }
 
 function decideRejoinControlsForMode(car, race, profile) {
-  const simulatorMode = race.physicsMode === 'advanced';
+  const simulatorMode = isSimulatorPhysicsMode(race.physicsMode);
   const lookahead = clamp(car.speed * (profile.simulatorMode ? 0.58 : 0.72) + REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX);
   const edgeMotion = analyzeTrackEdgeMotion(car, race);
   const lowSpeedOffTrack = !car.trackState.onTrack && car.speed < kphToSimSpeed(24);

package/src/simulation/driver/trafficScan.js

@@ -2,25 +2,43 @@ import { metersToSimUnits } from '../units.js';
 import { DEFEND_REAR_GAP, TRAFFIC_GAP_AHEAD, TRAFFIC_SIDE_GAP, TRAFFIC_REAR_WINDOW } from './driverControlConstants.js';
 import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
 
+const TRAFFIC_REAR_SCAN_WINDOW = metersToSimUnits(39);
+const TRAFFIC_FORWARD_SCAN_WINDOW = metersToSimUnits(134);
+const TRAFFIC_BESIDE_WINDOW = metersToSimUnits(28);
+
+// Entries are reused across calls: drivers consume the scan synchronously
+// within a single control decision, so a module-level pool avoids re-allocating
+// the candidate list for every car on every step.
+const TRAFFIC_SCRATCH = [];
+const TRAFFIC_ENTRY_POOL = [];
+
 export function scanNearbyTraffic(car, race) {
-  return race.cars
-    .filter((other) => other !== car)
-    .map((other) => ({
-      car: other,
-      gap: other.raceDistance - car.raceDistance,
-      signedOffset: other.trackState?.signedOffset ?? 0,
-      speed: other.speed,
-    }))
-    .filter((entry) => entry.gap > -metersToSimUnits(39) && entry.gap < metersToSimUnits(134));
+  const traffic = TRAFFIC_SCRATCH;
+  traffic.length = 0;
+  const cars = race.cars;
+  for (let index = 0; index < cars.length; index += 1) {
+    const other = cars[index];
+    if (other === car) continue;
+    const gap = other.raceDistance - car.raceDistance;
+    if (gap <= -TRAFFIC_REAR_SCAN_WINDOW || gap >= TRAFFIC_FORWARD_SCAN_WINDOW) continue;
+    const entry = TRAFFIC_ENTRY_POOL[traffic.length] ??= { car: null, gap: 0, signedOffset: 0, speed: 0 };
+    entry.car = other;
+    entry.gap = gap;
+    entry.signedOffset = other.trackState?.signedOffset ?? 0;
+    entry.speed = other.speed;
+    traffic.push(entry);
+  }
+  return traffic;
 }
 
 export function findDefensiveThreat(traffic) {
   let closest = null;
 
-  traffic.forEach((entry) => {
-    if (entry.gap >= -VEHICLE_LIMITS.carLength * 1.1 || entry.gap < -DEFEND_REAR_GAP) return;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (entry.gap >= -VEHICLE_LIMITS.carLength * 1.1 || entry.gap < -DEFEND_REAR_GAP) continue;
     if (!closest || entry.gap > closest.gap) closest = entry;
-  });
+  }
 
   return closest;
 }
@@ -28,24 +46,32 @@ export function findDefensiveThreat(traffic) {
 export function findLaneTrafficAhead(traffic, offset, maxDistance) {
   let closest = null;
 
-  traffic.forEach((entry) => {
-    if (entry.gap <= 0 || entry.gap > maxDistance) return;
-    if (Math.abs(entry.signedOffset - offset) > TRAFFIC_SIDE_GAP) return;
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
+    if (entry.gap <= 0 || entry.gap > maxDistance) continue;
+    if (Math.abs(entry.signedOffset - offset) > TRAFFIC_SIDE_GAP) continue;
     if (!closest || entry.gap < closest.gap) closest = entry;
-  });
+  }
 
   return closest;
 }
 
 export function findLaneTrafficBeside(traffic, offset) {
   let closest = null;
+  let closestLateral = 0;
+  let closestRisk = -Infinity;
 
-  traffic.forEach((entry) => {
+  for (let index = 0; index < traffic.length; index += 1) {
+    const entry = traffic[index];
     const lateral = Math.abs(entry.signedOffset - offset);
-    if (Math.abs(entry.gap) > metersToSimUnits(28) || lateral > TRAFFIC_SIDE_GAP) return;
-    const risk = (metersToSimUnits(28) - Math.abs(entry.gap)) + (TRAFFIC_SIDE_GAP - lateral);
-    if (!closest || risk > closest.risk) closest = { ...entry, lateral, risk };
-  });
+    if (Math.abs(entry.gap) > TRAFFIC_BESIDE_WINDOW || lateral > TRAFFIC_SIDE_GAP) continue;
+    const risk = (TRAFFIC_BESIDE_WINDOW - Math.abs(entry.gap)) + (TRAFFIC_SIDE_GAP - lateral);
+    if (!closest || risk > closestRisk) {
+      closest = entry;
+      closestLateral = lateral;
+      closestRisk = risk;
+    }
+  }
 
-  return closest;
+  return closest ? { ...closest, lateral: closestLateral, risk: closestRisk } : null;
 }

package/src/simulation/participants/participantInteractions.js

@@ -41,14 +41,6 @@ export const PARTICIPANT_INTERACTION_PROFILES = Object.freeze({
   }),
 });
 
-const INTERACTION_FLAGS = Object.freeze([
-  'collidable',
-  'detectableByRays',
-  'detectableAsNearby',
-  'blocksPitLane',
-  'affectsRaceOrder',
-]);
-
 export function normalizeParticipantInteractions(options = {}) {
   const defaultProfile = resolveProfileName(options.defaultProfile);
   const defaultInteraction = { ...PARTICIPANT_INTERACTION_PROFILES[defaultProfile] };
@@ -73,11 +65,15 @@ export function attachParticipantInteractions(cars = [], options = {}) {
 
 export function resolveInteraction(override = {}, fallbackProfile = 'normal') {
   const profile = resolveProfileName(override?.profile ?? fallbackProfile);
-  const resolved = { ...PARTICIPANT_INTERACTION_PROFILES[profile] };
-  INTERACTION_FLAGS.forEach((flag) => {
-    if (override?.[flag] != null) resolved[flag] = Boolean(override[flag]);
-  });
-  return resolved;
+  const base = PARTICIPANT_INTERACTION_PROFILES[profile];
+  return {
+    profile,
+    collidable: override?.collidable != null ? Boolean(override.collidable) : base.collidable,
+    detectableByRays: override?.detectableByRays != null ? Boolean(override.detectableByRays) : base.detectableByRays,
+    detectableAsNearby: override?.detectableAsNearby != null ? Boolean(override.detectableAsNearby) : base.detectableAsNearby,
+    blocksPitLane: override?.blocksPitLane != null ? Boolean(override.blocksPitLane) : base.blocksPitLane,
+    affectsRaceOrder: override?.affectsRaceOrder != null ? Boolean(override.affectsRaceOrder) : base.affectsRaceOrder,
+  };
 }
 
 export function canCollide(first, second) {
@@ -110,8 +106,21 @@ export function affectsRaceOrder(car) {
 }
 
 export function serializeParticipantInteraction(interaction) {
-  const normalized = resolveInteraction(interaction ?? {}, interaction?.profile ?? 'normal');
-  return { ...normalized };
+  return resolveInteraction(interaction ?? {}, interaction?.profile ?? 'normal');
+}
+
+const SERIALIZED_INTERACTION_SOURCE = Symbol('serializedInteractionSource');
+const SERIALIZED_INTERACTION_VALUE = Symbol('serializedInteractionValue');
+
+// Render snapshots are pooled and rebuilt every frame; the interaction config
+// only changes when a new object is attached, so cache the serialized form per
+// car keyed on the interaction reference.
+export function serializeParticipantInteractionCached(car) {
+  if (car[SERIALIZED_INTERACTION_SOURCE] !== car.interaction || !car[SERIALIZED_INTERACTION_VALUE]) {
+    car[SERIALIZED_INTERACTION_SOURCE] = car.interaction;
+    car[SERIALIZED_INTERACTION_VALUE] = serializeParticipantInteraction(car.interaction);
+  }
+  return car[SERIALIZED_INTERACTION_VALUE];
 }
 
 function resolveProfileName(profile) {

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;