@inventure71/paddockjs 4.2.0 → 4.3.1

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/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: [] })

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;
   }

package/src/simulation/timing/lapTelemetry.js

@@ -25,7 +25,7 @@ function writeLapTelemetryPosition(target, track, raceDistance, totalLaps = Infi
   const sectorIndex = Math.min(TELEMETRY_SECTOR_COUNT - 1, Math.floor(lapProgress / sectorLength));
   const sectorStart = sectorIndex * sectorLength;
 
-  target.completedLaps = Math.floor(positiveDistance / track.length);
+  target.completedLaps = Math.min(Math.floor(positiveDistance / track.length), totalLaps);
   target.currentLap = Math.max(1, lapIndex + 1);
   target.currentSector = sectorIndex + 1;
   target.currentSectorProgress = clamp((lapProgress - sectorStart) / sectorLength, 0, 1);
@@ -143,7 +143,10 @@ export function updateLapTelemetry(car, previousRaceDistance, currentTime, track
         telemetry.lastSectors = copySectorTimes(telemetry.lastSectors, telemetry.currentSectors);
         clearSectorTimes(telemetry.currentSectors);
         telemetry.currentLapStartedAt = crossingTime;
-        telemetry.completedLaps = Math.max(telemetry.completedLaps + 1, Math.min(Math.floor(boundaryDistance / track.length), totalLaps));
+        telemetry.completedLaps = Math.min(
+          totalLaps,
+          Math.max(telemetry.completedLaps + 1, Math.floor(boundaryDistance / track.length)),
+        );
       }
 
       telemetry.currentSectorStartedAt = crossingTime;
@@ -207,7 +210,7 @@ function syncInProgressLapTelemetry(telemetry, currentTime, currentRaceDistance,
   const sectorProgress = ensureSectorTimesArray(telemetry.sectorProgress);
   const liveSectors = ensureSectorTimesArray(telemetry.liveSectors);
 
-  telemetry.completedLaps = Math.floor(positiveDistance / track.length);
+  telemetry.completedLaps = Math.min(Math.floor(positiveDistance / track.length), totalLaps);
   telemetry.currentLap = Math.max(1, lapIndex + 1);
   telemetry.currentSector = activeIndex + 1;
   telemetry.currentSectorProgress = clamp((lapProgress - sectorStart) / sectorLength, 0, 1);
@@ -234,7 +237,7 @@ function syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, t
     preserveCompletedSectors,
   });
   telemetry.sectorProgress = sectorProgress;
-  telemetry.completedLaps = Math.max(telemetry.completedLaps, Math.min(telemetry.completedLaps, totalLaps));
+  telemetry.completedLaps = Math.min(telemetry.completedLaps, totalLaps);
   telemetry.currentLapTime = Math.max(0, currentTime - telemetry.currentLapStartedAt);
   telemetry.currentSectorElapsed = Math.max(0, currentTime - telemetry.currentSectorStartedAt);
   syncLiveSectorTelemetry(telemetry, { preserveCompletedSectors });

package/src/simulation/timing/sectorPerformance.js

@@ -1,3 +1,6 @@
+import { finiteOrNull } from '../simMath.js';
+export { finiteOrNull } from '../simMath.js';
+
 import { TELEMETRY_SECTOR_COUNT } from './timingConstants.js';
 
 const OVERALL_BEST_0 = '_sectorPerformanceOverallBest0';
@@ -108,9 +111,6 @@ export function updateSectorPerformance(cars, stats = null) {
   return true;
 }
 
-export function finiteOrNull(value) {
-  return Number.isFinite(value) ? value : null;
-}
 
 function classifySectorPerformance(value, personalBest, overallBest) {
   if (!Number.isFinite(value)) return null;

package/src/simulation/timing/timingLines.js

@@ -76,7 +76,13 @@ export function createTimingLines(track) {
 export function getTimingLineNumber(track, raceDistance) {
   const spacing = track.timingLines?.spacing;
   if (!Number.isFinite(spacing) || spacing <= 0 || !Number.isFinite(raceDistance)) return null;
-  return Math.floor(Math.max(0, raceDistance) / spacing);
+  const distance = Math.max(0, raceDistance);
+  let lineNumber = Math.floor(distance / spacing);
+  // Division can round onto a line whose stored product is still ahead of
+  // the car. Use the same representable boundary for lookup and recording.
+  if (lineNumber > 0 && lineNumber * spacing > distance) lineNumber -= 1;
+  else if ((lineNumber + 1) * spacing <= distance) lineNumber += 1;
+  return lineNumber;
 }
 
 export function resetTimingLineCrossings(car, currentTime) {
@@ -105,7 +111,7 @@ export function recordTimingLineCrossings(car, previousRaceDistance, currentTime
     ? latestLine - (track.timingLines.count * TIMING_LINE_HISTORY_LAPS)
     : null;
 
-  if (Math.abs(travelled) <= 1e-6) {
+  if (travelled === 0) {
     car.timingLineLastUpdatedAt = currentTime;
     if (!Number.isFinite(cutoff) || cutoff <= 0 || cutoff === car.timingLinePruneCutoff) return;
     pruneTimingLineCrossings(car, cutoff);
@@ -113,12 +119,12 @@ export function recordTimingLineCrossings(car, previousRaceDistance, currentTime
     return;
   }
 
-  if (travelled > 1e-6 && travelled < track.length / 2) {
-    const firstLine = Math.floor(Math.max(0, previousDistance) / spacing) + 1;
-    const lastLine = Math.floor(Math.max(0, currentDistance) / spacing);
+  if (travelled > 0 && travelled < track.length / 2) {
+    const firstLine = getTimingLineNumber(track, previousDistance) + 1;
+    const lastLine = getTimingLineNumber(track, currentDistance);
     for (let lineNumber = firstLine; lineNumber <= lastLine; lineNumber += 1) {
       const lineDistance = lineNumber * spacing;
-      if (lineDistance <= previousDistance + 1e-6 || lineDistance > currentDistance + 1e-6) continue;
+      if (lineDistance <= previousDistance || lineDistance > currentDistance) continue;
       const ratio = clamp((lineDistance - previousDistance) / travelled, 0, 1);
       setTimingLineCrossing(car, lineNumber, previousTime + ratio * elapsed);
     }

package/src/simulation/track/pitLaneAccess.js

@@ -1,5 +1,5 @@
-import { clamp, wrapDistance } from '../simMath.js';
-import { PIT_ACCESS_MAX_LENGTH, PIT_ACCESS_SAMPLE_STEPS, PIT_ACCESS_SEARCH_STEP, PIT_ACCESS_TRACK_OVERLAP, PIT_LANE_WIDTH } from './trackConstants.js';
+import { wrapDistance } from '../simMath.js';
+import { PIT_ACCESS_SAMPLE_STEPS, PIT_ACCESS_SEARCH_STEP, PIT_ACCESS_TRACK_OVERLAP } from './trackConstants.js';
 import { angleBetweenVectors, headingVector, normalizeVector, sampleCubicBezier, signedLateralOffsetToPoint } from './trackMath.js';
 import { offsetTrackPoint, pointAt } from './spatialQueries.js';
 

package/src/simulation/track/pitLaneLayout.js

@@ -1,9 +1,12 @@
 import { clamp } from '../simMath.js';
 import { metersToSimUnits } from '../units.js';
-import { WORLD, PIT_BOX_COUNT, PIT_BOX_DEPTH, PIT_BOX_LENGTH, PIT_BOX_PAIR_GAP, PIT_BOX_TO_LANE_GAP, PIT_ENTRY_SEARCH_AFTER, PIT_ENTRY_SEARCH_BEFORE, PIT_EXIT_SEARCH_AFTER, PIT_EXIT_SEARCH_BEFORE, PIT_LANE_EDGE_GAP, PIT_LANE_ENTRY_BUFFER, PIT_LANE_EXIT_BUFFER, PIT_LANE_FINISH_RATIO, PIT_LANE_OFFSET_SEARCH_STEP, PIT_LANE_WIDTH, PIT_SERVICE_AREA_DEPTH, PIT_SERVICE_AREA_LENGTH, PIT_SERVICE_QUEUE_GAP, PIT_TEAM_COUNT, PIT_TEAM_GAP, PIT_BOXES_PER_TEAM, PIT_WORKING_LANE_GAP, PIT_WORKING_LANE_WIDTH, PIT_ACCESS_MAX_LENGTH, PIT_ACCESS_MIN_LENGTH, PIT_ACCESS_TANGENT_RATIO, PIT_TRACK_CLEARANCE_MARGIN } from './trackConstants.js';
+import { WORLD, PIT_BOX_COUNT, PIT_BOX_DEPTH, PIT_BOX_TO_LANE_GAP, PIT_ENTRY_SEARCH_AFTER, PIT_ENTRY_SEARCH_BEFORE, PIT_EXIT_SEARCH_AFTER, PIT_EXIT_SEARCH_BEFORE, PIT_LANE_EDGE_GAP, PIT_LANE_ENTRY_BUFFER, PIT_LANE_EXIT_BUFFER, PIT_LANE_FINISH_RATIO, PIT_LANE_OFFSET_SEARCH_STEP, PIT_LANE_WIDTH, PIT_SERVICE_AREA_DEPTH, PIT_TEAM_COUNT, PIT_BOXES_PER_TEAM, PIT_WORKING_LANE_GAP, PIT_WORKING_LANE_WIDTH, PIT_ACCESS_MAX_LENGTH, PIT_ACCESS_MIN_LENGTH, PIT_ACCESS_TANGENT_RATIO, PIT_TRACK_CLEARANCE_MARGIN } from './trackConstants.js';
 import { clonePoint, distance, headingVector, interpolatePitPoint, nearestPointOnPolyline, normalizeVector, pointWorldClearance, projectPitPoint, createPointBounds } from './trackMath.js';
 import { findPitAccessConnection, createPitAccessRoadCenterline } from './pitLaneAccess.js';
 import { pointAt } from './spatialQueries.js';
+import { createPitBoxes, getPitBoxRunLength } from './pitServiceLayout.js';
+
+export { getPitBoxRunLength, createPitBoxCorners, createPitRectangleCorners, createPitBoxes } from './pitServiceLayout.js';
 
 export function createStartStraightBasis(track) {
   const finish = pointAt(track, 0);
@@ -20,20 +23,6 @@ export function createStartStraightBasis(track) {
   };
 }
 
-export function getPitBoxRunLength({
-  teamCount = PIT_TEAM_COUNT,
-  boxesPerTeam = PIT_BOXES_PER_TEAM,
-  boxLength = PIT_BOX_LENGTH,
-  pairGap = PIT_BOX_PAIR_GAP,
-  teamGap = PIT_TEAM_GAP,
-} = {}) {
-  const boxCount = teamCount * boxesPerTeam;
-  return (
-    boxCount * boxLength +
-    teamCount * Math.max(0, boxesPerTeam - 1) * pairGap +
-    Math.max(0, teamCount - 1) * teamGap
-  );
-}
 
 export function createPitLaneLayout() {
   const runLength = getPitBoxRunLength();
@@ -130,128 +119,8 @@ export function choosePitLanePlacement(track, baseLaneOffset, layout) {
   return candidates.sort((left, right) => right.score - left.score)[0];
 }
 
-export function createPitBoxCorners(center, forward, serviceNormal) {
-  const halfLength = PIT_BOX_LENGTH / 2;
-  const halfDepth = PIT_BOX_DEPTH / 2;
-  return [
-    {
-      x: center.x + forward.x * halfLength + serviceNormal.x * halfDepth,
-      y: center.y + forward.y * halfLength + serviceNormal.y * halfDepth,
-    },
-    {
-      x: center.x - forward.x * halfLength + serviceNormal.x * halfDepth,
-      y: center.y - forward.y * halfLength + serviceNormal.y * halfDepth,
-    },
-    {
-      x: center.x - forward.x * halfLength - serviceNormal.x * halfDepth,
-      y: center.y - forward.y * halfLength - serviceNormal.y * halfDepth,
-    },
-    {
-      x: center.x + forward.x * halfLength - serviceNormal.x * halfDepth,
-      y: center.y + forward.y * halfLength - serviceNormal.y * halfDepth,
-    },
-  ];
-}
 
-export function createPitRectangleCorners(center, forward, serviceNormal, length, depth) {
-  const halfLength = length / 2;
-  const halfDepth = depth / 2;
-  return [
-    {
-      x: center.x + forward.x * halfLength + serviceNormal.x * halfDepth,
-      y: center.y + forward.y * halfLength + serviceNormal.y * halfDepth,
-    },
-    {
-      x: center.x - forward.x * halfLength + serviceNormal.x * halfDepth,
-      y: center.y - forward.y * halfLength + serviceNormal.y * halfDepth,
-    },
-    {
-      x: center.x - forward.x * halfLength - serviceNormal.x * halfDepth,
-      y: center.y - forward.y * halfLength - serviceNormal.y * halfDepth,
-    },
-    {
-      x: center.x + forward.x * halfLength - serviceNormal.x * halfDepth,
-      y: center.y + forward.y * halfLength - serviceNormal.y * halfDepth,
-    },
-  ];
-}
-
-export function createPitBoxes({ laneStart, laneForward, laneLength, serviceNormal }) {
-  const runLength = getPitBoxRunLength();
-  let cursor = Math.max(PIT_SERVICE_QUEUE_GAP + PIT_BOX_LENGTH / 2, (laneLength - runLength) / 2);
-  const workingLaneOffset = PIT_LANE_WIDTH / 2 + PIT_WORKING_LANE_GAP + PIT_WORKING_LANE_WIDTH / 2;
-  const boxLateral = workingLaneOffset + PIT_WORKING_LANE_WIDTH / 2 + PIT_BOX_TO_LANE_GAP + PIT_BOX_DEPTH / 2;
-  const boxes = [];
-  const serviceAreas = [];
-
-  for (let index = 0; index < PIT_BOX_COUNT; index += 1) {
-    const distanceAlongLane = cursor + PIT_BOX_LENGTH / 2;
-    const laneTarget = interpolatePitPoint(laneStart, laneForward, distanceAlongLane);
-    const center = {
-      x: laneTarget.x + serviceNormal.x * boxLateral,
-      y: laneTarget.y + serviceNormal.y * boxLateral,
-    };
-    const teamIndex = Math.floor(index / PIT_BOXES_PER_TEAM);
-    const teamBoxIndex = index % PIT_BOXES_PER_TEAM;
 
-    boxes.push({
-      id: `team-${teamIndex + 1}-box-${teamBoxIndex + 1}`,
-      index,
-      teamIndex,
-      teamBoxIndex,
-      distanceAlongLane,
-      laneTarget,
-      center,
-      length: PIT_BOX_LENGTH,
-      depth: PIT_BOX_DEPTH,
-      corners: createPitBoxCorners(center, laneForward, serviceNormal),
-    });
-
-    if (teamBoxIndex === PIT_BOXES_PER_TEAM - 1) {
-      const firstTeamBox = boxes[index - (PIT_BOXES_PER_TEAM - 1)];
-      const serviceDistance = (firstTeamBox.distanceAlongLane + distanceAlongLane) / 2;
-      const queueDistance = Math.max(PIT_SERVICE_QUEUE_GAP / 2, serviceDistance - PIT_SERVICE_QUEUE_GAP);
-      const serviceCenter = projectPitPoint(
-        laneStart,
-        laneForward,
-        serviceNormal,
-        serviceDistance,
-        workingLaneOffset,
-      );
-      const queuePoint = projectPitPoint(
-        laneStart,
-        laneForward,
-        serviceNormal,
-        queueDistance,
-        workingLaneOffset,
-      );
-
-      serviceAreas.push({
-        id: `team-${teamIndex + 1}-service`,
-        index: teamIndex,
-        teamIndex,
-        distanceAlongLane: serviceDistance,
-        queueDistanceAlongLane: queueDistance,
-        laneTarget: serviceCenter,
-        center: serviceCenter,
-        queuePoint,
-        length: PIT_SERVICE_AREA_LENGTH,
-        depth: PIT_SERVICE_AREA_DEPTH,
-        corners: createPitRectangleCorners(serviceCenter, laneForward, serviceNormal, PIT_SERVICE_AREA_LENGTH, PIT_SERVICE_AREA_DEPTH),
-        queueCorners: createPitRectangleCorners(queuePoint, laneForward, serviceNormal, PIT_SERVICE_AREA_LENGTH * 0.72, PIT_SERVICE_AREA_DEPTH),
-        garageBoxIds: boxes
-          .slice(index - (PIT_BOXES_PER_TEAM - 1), index + 1)
-          .map((box) => box.id),
-      });
-    }
-
-    cursor += PIT_BOX_LENGTH;
-    if (teamBoxIndex === 0) cursor += PIT_BOX_PAIR_GAP;
-    else if (teamIndex < PIT_TEAM_COUNT - 1) cursor += PIT_TEAM_GAP;
-  }
-
-  return { boxes, serviceAreas, workingLaneOffset };
-}
 
 export function createPitLaneBounds(pitLane) {
   const points = [