@inventure71/paddockjs 1.0.0 → 2.0.1

package/src/simulation/rulesConfig.js

@@ -1,327 +1,9 @@
-import { kphToSimSpeed, metersToSimUnits } from './units.js';
+import { DEFAULT_RULES } from './rules/ruleDefaults.js';
+import { normalizeModules } from './rules/moduleConfig.js';
+import { clamp01, mergeConfig } from './rules/ruleConfigMerge.js';
+import { RULESET_MODULES } from './rules/rulesetPresets.js';
 
-export const DEFAULT_RULES = {
-  drsDetectionSeconds: 1,
-  safetyCarSpeed: kphToSimSpeed(166),
-  safetyCarLeadDistance: metersToSimUnits(55),
-  safetyCarGap: metersToSimUnits(22),
-  collisionRestitution: 0.18,
-  standingStart: true,
-  startLightCount: 5,
-  startLightInterval: 0.72,
-  startLightsOutHold: 0.78,
-};
-
-const DEFAULT_MODULES = {
-  pitStops: {
-    enabled: false,
-    pitLaneSpeedLimitKph: 80,
-    defaultStopSeconds: 2.8,
-    variability: {
-      enabled: false,
-      perfect: false,
-      speedImpactSeconds: 1.2,
-      consistencyJitterSeconds: 1.4,
-      issueChance: 0.12,
-      issueMaxDelaySeconds: 4,
-    },
-    maxConcurrentPitLaneCars: 3,
-    minimumPitLaneGapMeters: 20,
-    doubleStacking: false,
-    tirePitRequestThresholdPercent: 50,
-    tirePitCommitThresholdPercent: 30,
-  },
-  tireStrategy: {
-    enabled: false,
-    compounds: ['S', 'M', 'H'],
-    mandatoryDistinctDryCompounds: null,
-  },
-  penalties: {
-    enabled: false,
-    stewardStrictness: 1,
-    trackLimits: {
-      strictness: 0,
-      warningsBeforePenalty: 3,
-      timePenaltySeconds: 5,
-      relaxedMarginMeters: 3,
-    },
-    collision: {
-      strictness: 0,
-      timePenaltySeconds: 5,
-      minimumSeverity: 2,
-      relaxedSeverityMargin: 6,
-      minimumImpactSpeedKph: 20,
-      relaxedImpactSpeedKph: 20,
-    },
-    tireRequirement: {
-      strictness: 0,
-      timePenaltySeconds: 10,
-    },
-    pitLaneSpeeding: {
-      strictness: 0,
-      speedLimitKph: 80,
-      marginKph: 0.5,
-      relaxedMarginKph: 5,
-      timePenaltySeconds: 5,
-    },
-  },
-  weather: {
-    enabled: false,
-  },
-  reliability: {
-    enabled: false,
-  },
-  fuelLoad: {
-    enabled: false,
-  },
-};
-
-const RULESET_MODULES = {
-  paddock: DEFAULT_MODULES,
-  custom: DEFAULT_MODULES,
-  grandPrix2025: {
-    ...DEFAULT_MODULES,
-    pitStops: {
-      ...DEFAULT_MODULES.pitStops,
-      enabled: true,
-      pitLaneSpeedLimitKph: 80,
-    },
-    tireStrategy: {
-      ...DEFAULT_MODULES.tireStrategy,
-      enabled: true,
-      mandatoryDistinctDryCompounds: 2,
-    },
-    penalties: {
-      ...DEFAULT_MODULES.penalties,
-      enabled: true,
-      stewardStrictness: 0.85,
-      trackLimits: {
-        ...DEFAULT_MODULES.penalties.trackLimits,
-        strictness: 0.85,
-      },
-      collision: {
-        ...DEFAULT_MODULES.penalties.collision,
-        strictness: 0.65,
-      },
-      tireRequirement: {
-        ...DEFAULT_MODULES.penalties.tireRequirement,
-        strictness: 1,
-      },
-      pitLaneSpeeding: {
-        ...DEFAULT_MODULES.penalties.pitLaneSpeeding,
-        strictness: 1,
-        speedLimitKph: 80,
-      },
-    },
-    fuelLoad: {
-      enabled: true,
-    },
-  },
-};
-
-RULESET_MODULES.fia2025 = RULESET_MODULES.grandPrix2025;
-
-const MODULE_NAMES = Object.keys(DEFAULT_MODULES);
-const PENALTY_SUBSECTIONS = ['trackLimits', 'collision', 'tireRequirement', 'pitLaneSpeeding'];
-const CONSEQUENCE_TYPES = new Set([
-  'warning',
-  'time',
-  'driveThrough',
-  'stopGo',
-  'positionDrop',
-  'gridDrop',
-  'disqualification',
-]);
-
-function isPlainObject(value) {
-  return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-
-function clone(value) {
-  if (Array.isArray(value)) return value.map((item) => clone(item));
-  if (!isPlainObject(value)) return value;
-  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
-}
-
-function mergeConfig(base, override) {
-  if (!isPlainObject(override)) return clone(base);
-  const next = clone(base);
-  Object.entries(override).forEach(([key, value]) => {
-    next[key] = isPlainObject(value) && isPlainObject(next[key])
-      ? mergeConfig(next[key], value)
-      : clone(value);
-  });
-  return next;
-}
-
-function clamp01(value, fallback = 0) {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric)) return fallback;
-  return Math.max(0, Math.min(1, numeric));
-}
-
-function positiveNumber(value, fallback) {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) && numeric > 0 ? numeric : fallback;
-}
-
-function nonNegativeInteger(value, fallback) {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) && numeric >= 0 ? Math.floor(numeric) : fallback;
-}
-
-function positiveInteger(value, fallback) {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) && numeric > 0 ? Math.floor(numeric) : fallback;
-}
-
-function normalizeConsequences(value, fallbackSeconds) {
-  const source = Array.isArray(value) && value.length
-    ? value
-    : [{ type: 'time', seconds: fallbackSeconds }];
-  const normalized = source
-    .map((consequence) => {
-      const type = CONSEQUENCE_TYPES.has(consequence?.type) ? consequence.type : null;
-      if (!type) return null;
-      if (type === 'time') {
-        return {
-          type,
-          seconds: positiveNumber(consequence.seconds, fallbackSeconds),
-        };
-      }
-      if (type === 'driveThrough') {
-        return {
-          type,
-          conversionSeconds: positiveNumber(consequence.conversionSeconds, 20),
-        };
-      }
-      if (type === 'stopGo') {
-        return {
-          type,
-          seconds: positiveNumber(consequence.seconds, 10),
-          conversionSeconds: positiveNumber(consequence.conversionSeconds, 30),
-        };
-      }
-      if (type === 'positionDrop' || type === 'gridDrop') {
-        return {
-          type,
-          positions: nonNegativeInteger(consequence.positions, 1),
-        };
-      }
-      return { type };
-    })
-    .filter(Boolean);
-  return normalized.length ? normalized : [{ type: 'time', seconds: fallbackSeconds }];
-}
-
-function sumTimeConsequences(consequences) {
-  return consequences.reduce((total, consequence) => (
-    consequence.type === 'time' ? total + consequence.seconds : total
-  ), 0);
-}
-
-function normalizePenaltyConfig(penalties) {
-  const next = {
-    ...penalties,
-    enabled: Boolean(penalties.enabled),
-    stewardStrictness: clamp01(penalties.stewardStrictness, 1),
-  };
-
-  PENALTY_SUBSECTIONS.forEach((name) => {
-    next[name] = {
-      ...penalties[name],
-      strictness: clamp01(penalties[name]?.strictness, 0),
-    };
-  });
-
-  next.trackLimits.warningsBeforePenalty = nonNegativeInteger(next.trackLimits.warningsBeforePenalty, 3);
-  next.trackLimits.consequences = normalizeConsequences(next.trackLimits.consequences, positiveNumber(next.trackLimits.timePenaltySeconds, 5));
-  next.trackLimits.timePenaltySeconds = sumTimeConsequences(next.trackLimits.consequences);
-  next.trackLimits.relaxedMarginMeters = Math.max(0, Number(next.trackLimits.relaxedMarginMeters) || 0);
-  next.trackLimits.relaxedMargin = metersToSimUnits(next.trackLimits.relaxedMarginMeters);
-
-  next.collision.consequences = normalizeConsequences(next.collision.consequences, positiveNumber(next.collision.timePenaltySeconds, 5));
-  next.collision.timePenaltySeconds = sumTimeConsequences(next.collision.consequences);
-  next.collision.minimumSeverity = Math.max(0, Number(next.collision.minimumSeverity) || 0);
-  next.collision.relaxedSeverityMargin = Math.max(0, Number(next.collision.relaxedSeverityMargin) || 0);
-  next.collision.minimumImpactSpeedKph = Math.max(0, Number(next.collision.minimumImpactSpeedKph) || 0);
-  next.collision.relaxedImpactSpeedKph = Math.max(0, Number(next.collision.relaxedImpactSpeedKph) || 0);
-  next.collision.minimumImpactSpeed = metersToSimUnits(next.collision.minimumImpactSpeedKph / 3.6);
-  next.collision.relaxedImpactSpeed = metersToSimUnits(next.collision.relaxedImpactSpeedKph / 3.6);
-  next.tireRequirement.consequences = normalizeConsequences(next.tireRequirement.consequences, positiveNumber(next.tireRequirement.timePenaltySeconds, 10));
-  next.tireRequirement.timePenaltySeconds = sumTimeConsequences(next.tireRequirement.consequences);
-  next.pitLaneSpeeding.speedLimitKph = positiveNumber(next.pitLaneSpeeding.speedLimitKph, 80);
-  next.pitLaneSpeeding.marginKph = Math.max(0, Number(next.pitLaneSpeeding.marginKph) || 0);
-  next.pitLaneSpeeding.relaxedMarginKph = Math.max(0, Number(next.pitLaneSpeeding.relaxedMarginKph) || 0);
-  next.pitLaneSpeeding.consequences = normalizeConsequences(next.pitLaneSpeeding.consequences, positiveNumber(next.pitLaneSpeeding.timePenaltySeconds, 5));
-  next.pitLaneSpeeding.timePenaltySeconds = sumTimeConsequences(next.pitLaneSpeeding.consequences);
-
-  next.enabled = next.enabled || PENALTY_SUBSECTIONS.some((name) => next[name].strictness > 0);
-  return next;
-}
-
-function normalizeModules(modules, explicitModules = {}) {
-  const next = mergeConfig(DEFAULT_MODULES, modules);
-  const explicitPitSpeed = isPlainObject(explicitModules?.penalties?.pitLaneSpeeding) &&
-    Object.hasOwn(explicitModules.penalties.pitLaneSpeeding, 'speedLimitKph');
-
-  MODULE_NAMES.forEach((name) => {
-    next[name] = {
-      ...next[name],
-      enabled: Boolean(next[name].enabled),
-    };
-  });
-
-  next.pitStops.pitLaneSpeedLimitKph = positiveNumber(next.pitStops.pitLaneSpeedLimitKph, 80);
-  next.pitStops.defaultStopSeconds = positiveNumber(next.pitStops.defaultStopSeconds, 2.8);
-  next.pitStops.variability = {
-    ...DEFAULT_MODULES.pitStops.variability,
-    ...(isPlainObject(next.pitStops.variability) ? next.pitStops.variability : {}),
-  };
-  next.pitStops.variability.enabled = Boolean(next.pitStops.variability.enabled);
-  next.pitStops.variability.perfect = Boolean(next.pitStops.variability.perfect);
-  next.pitStops.variability.speedImpactSeconds = Math.max(
-    0,
-    Number(next.pitStops.variability.speedImpactSeconds) || DEFAULT_MODULES.pitStops.variability.speedImpactSeconds,
-  );
-  next.pitStops.variability.consistencyJitterSeconds = Math.max(
-    0,
-    Number(next.pitStops.variability.consistencyJitterSeconds) || DEFAULT_MODULES.pitStops.variability.consistencyJitterSeconds,
-  );
-  next.pitStops.variability.issueChance = clamp01(
-    next.pitStops.variability.issueChance,
-    DEFAULT_MODULES.pitStops.variability.issueChance,
-  );
-  next.pitStops.variability.issueMaxDelaySeconds = Math.max(
-    0,
-    Number(next.pitStops.variability.issueMaxDelaySeconds) || DEFAULT_MODULES.pitStops.variability.issueMaxDelaySeconds,
-  );
-  next.pitStops.maxConcurrentPitLaneCars = positiveInteger(next.pitStops.maxConcurrentPitLaneCars, 3);
-  next.pitStops.minimumPitLaneGapMeters = positiveNumber(next.pitStops.minimumPitLaneGapMeters, 20);
-  next.pitStops.minimumPitLaneGap = metersToSimUnits(next.pitStops.minimumPitLaneGapMeters);
-  next.pitStops.doubleStacking = Boolean(next.pitStops.doubleStacking);
-  next.pitStops.tirePitRequestThresholdPercent = clamp01(
-    Number(next.pitStops.tirePitRequestThresholdPercent) / 100,
-    0.5,
-  ) * 100;
-  next.pitStops.tirePitCommitThresholdPercent = Math.min(
-    next.pitStops.tirePitRequestThresholdPercent,
-    clamp01(Number(next.pitStops.tirePitCommitThresholdPercent) / 100, 0.3) * 100,
-  );
-
-  next.tireStrategy.compounds = Array.isArray(next.tireStrategy.compounds) && next.tireStrategy.compounds.length
-    ? [...next.tireStrategy.compounds]
-    : ['S', 'M', 'H'];
-  next.tireStrategy.mandatoryDistinctDryCompounds = next.tireStrategy.mandatoryDistinctDryCompounds == null
-    ? null
-    : nonNegativeInteger(next.tireStrategy.mandatoryDistinctDryCompounds, 0);
-
-  next.penalties = normalizePenaltyConfig(next.penalties);
-  if (!explicitPitSpeed) {
-    next.penalties.pitLaneSpeeding.speedLimitKph = next.pitStops.pitLaneSpeedLimitKph;
-  }
-  return next;
-}
+export { DEFAULT_RULES } from './rules/ruleDefaults.js';
 
 export function normalizeRaceRules(rules = {}) {
   const requestedRuleset = rules?.ruleset ?? rules?.profile ?? 'paddock';

package/src/simulation/snapshots/raceSnapshots.js

@@ -0,0 +1,193 @@
+import { WORLD } from '../track/trackModel.js';
+import { simSpeedToKph, simUnitsToMeters } from '../units.js';
+import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+import { serializePenalty } from '../rules/penaltyLedger.js';
+import { normalizePitIntent, PIT_INTENT_NONE } from '../pit/pitIntent.js';
+import {
+  pitLaneStatusSnapshot,
+  serializeObservationPitStop,
+  serializePitStop,
+  serializeRenderPitStop,
+} from '../pit/pitSnapshots.js';
+import {
+  serializeCar,
+  serializeObservationCar,
+  serializeRenderCar,
+  serializeTrainingCar,
+} from '../vehicle/vehicleSnapshots.js';
+import { createLapTelemetry, serializeLapTelemetry } from '../timing/raceTiming.js';
+import { affectsRaceOrder } from '../participants/participantInteractions.js';
+import { serializeReplayGhosts } from '../replay/replayGhosts.js';
+
+function visibleStartState(sim) {
+  return {
+    ...sim.raceControl.start,
+    visible: sim.raceControl.mode === 'pre-start' ||
+      (sim.raceControl.start.releasedAt != null && sim.time - sim.raceControl.start.releasedAt < 1.45),
+  };
+}
+
+function penaltySecondsFor(statsByDriver, driverId) {
+  return statsByDriver.get(driverId)?.seconds ?? 0;
+}
+
+export function createVehicleSnapshotDependencies(sim) {
+  return {
+    createLapTelemetry,
+    normalizePitIntent,
+    PIT_INTENT_NONE,
+    serializeLapTelemetry,
+    serializeObservationPitStop: (pitStop) => serializeObservationPitStop(
+      pitStop,
+      normalizePitIntent,
+      PIT_INTENT_NONE,
+    ),
+    serializePitStop: (pitStop) => serializePitStop(pitStop, normalizePitIntent, PIT_INTENT_NONE),
+    serializeRenderPitStop,
+    simSpeedToKph,
+    simUnitsToMeters,
+    VEHICLE_LIMITS,
+    physicsMode: sim.physicsMode,
+  };
+}
+
+export function snapshotRace(sim) {
+  const ordered = sim.orderedCars();
+  const snapshotCars = carsForSnapshot(sim, ordered);
+  const pitLaneStatus = pitLaneStatusSnapshot(sim.raceControl, sim.track.pitLane, sim.rules.modules?.pitStops);
+  const penaltyStats = sim.getPenaltyStatsByDriver();
+  const vehicleSnapshotDependencies = createVehicleSnapshotDependencies(sim);
+  return {
+    time: sim.time,
+    world: WORLD,
+    physicsMode: sim.physicsMode,
+    track: sim.track,
+    totalLaps: sim.totalLaps,
+    raceControl: {
+      mode: sim.raceControl.mode,
+      redFlag: Boolean(sim.raceControl.redFlag),
+      pitLaneOpen: pitLaneStatus.open,
+      pitLaneStatus,
+      finished: sim.raceControl.finished,
+      finishedAt: sim.raceControl.finishedAt,
+      winner: getRaceWinnerSnapshot(sim),
+      classification: sim.raceControl.classification.map((entry) => ({ ...entry })),
+      start: visibleStartState(sim),
+    },
+    pitLaneStatus,
+    safetyCar: { ...sim.safetyCar },
+    rules: sim.rules,
+    events: [...sim.events],
+    penalties: sim.penalties.map(serializePenalty),
+    cars: snapshotCars.map(({ car, rank }) => serializeCar(
+      car,
+      rank,
+      penaltySecondsFor(penaltyStats, car.id),
+      vehicleSnapshotDependencies,
+    )),
+    replayGhosts: serializeReplayGhosts(sim.replayGhosts),
+  };
+}
+
+export function snapshotRaceRender(sim) {
+  const pitLaneStatus = pitLaneStatusSnapshot(sim.raceControl, sim.track.pitLane, sim.rules.modules?.pitStops);
+  const vehicleSnapshotDependencies = createVehicleSnapshotDependencies(sim);
+  return {
+    time: sim.time,
+    world: WORLD,
+    physicsMode: sim.physicsMode,
+    track: sim.track,
+    totalLaps: sim.totalLaps,
+    raceControl: {
+      mode: sim.raceControl.mode,
+      redFlag: Boolean(sim.raceControl.redFlag),
+      pitLaneOpen: pitLaneStatus.open,
+      pitLaneStatus,
+      finished: sim.raceControl.finished,
+      start: visibleStartState(sim),
+    },
+    pitLaneStatus,
+    safetyCar: { ...sim.safetyCar },
+    cars: carsForSnapshot(sim, sim.orderedCars()).map(({ car }) => serializeRenderCar(car, vehicleSnapshotDependencies)),
+    replayGhosts: serializeReplayGhosts(sim.replayGhosts),
+  };
+}
+
+export function snapshotRaceObservation(sim) {
+  const pitLaneStatus = pitLaneStatusSnapshot(sim.raceControl, sim.track.pitLane, sim.rules.modules?.pitStops);
+  const vehicleSnapshotDependencies = createVehicleSnapshotDependencies(sim);
+  return {
+    time: sim.time,
+    world: WORLD,
+    physicsMode: sim.physicsMode,
+    track: sim.track,
+    totalLaps: sim.totalLaps,
+    raceControl: {
+      mode: sim.raceControl.mode,
+      redFlag: Boolean(sim.raceControl.redFlag),
+      pitLaneOpen: pitLaneStatus.open,
+      pitLaneStatus,
+      finished: sim.raceControl.finished,
+    },
+    pitLaneStatus,
+    safetyCar: { ...sim.safetyCar },
+    events: [...sim.events],
+    cars: carsForSnapshot(sim, sim.orderedCars()).map(({ car, rank }) => serializeObservationCar(
+      car,
+      rank,
+      vehicleSnapshotDependencies,
+    )),
+    replayGhosts: serializeReplayGhosts(sim.replayGhosts),
+  };
+}
+
+export function snapshotRaceTraining(sim) {
+  const pitLaneStatus = pitLaneStatusSnapshot(sim.raceControl, sim.track.pitLane, sim.rules.modules?.pitStops);
+  const vehicleSnapshotDependencies = createVehicleSnapshotDependencies(sim);
+  return {
+    time: sim.time,
+    world: WORLD,
+    physicsMode: sim.physicsMode,
+    track: sim.track,
+    totalLaps: sim.totalLaps,
+    raceControl: {
+      mode: sim.raceControl.mode,
+      redFlag: Boolean(sim.raceControl.redFlag),
+      pitLaneOpen: pitLaneStatus.open,
+      pitLaneStatus,
+      finished: sim.raceControl.finished,
+    },
+    pitLaneStatus,
+    safetyCar: { ...sim.safetyCar },
+    events: [...sim.events],
+    cars: carsForSnapshot(sim, sim.orderedCars()).map(({ car, rank }) => serializeTrainingCar(
+      car,
+      rank,
+      vehicleSnapshotDependencies,
+    )),
+    replayGhosts: serializeReplayGhosts(sim.replayGhosts),
+  };
+}
+
+export function getRaceWinnerSnapshot(sim) {
+  if (!sim.raceControl.winnerId) return null;
+  const car = sim.cars.find((item) => item.id === sim.raceControl.winnerId);
+  if (!car) return null;
+  const rank = car.classifiedRank ?? car.rank ?? 1;
+  return serializeCar(
+    car,
+    rank,
+    penaltySecondsFor(sim.getPenaltyStatsByDriver(), car.id),
+    createVehicleSnapshotDependencies(sim),
+  );
+}
+
+function carsForSnapshot(sim, ordered) {
+  const orderedIds = new Set(ordered.map((car) => car.id));
+  const ranked = ordered.map((car, index) => ({ car, rank: index + 1 }));
+  const unranked = sim.cars
+    .filter((car) => !orderedIds.has(car.id))
+    .sort((a, b) => a.index - b.index)
+    .map((car) => ({ car, rank: affectsRaceOrder(car) ? (car.rank ?? null) : null }));
+  return [...ranked, ...unranked];
+}

package/src/simulation/timing/drsTiming.js

@@ -0,0 +1,87 @@
+import { wrapDistance } from '../simMath.js';
+
+function wrapProgress(value, length) {
+  return wrapDistance(value, length);
+}
+
+function distanceForward(from, to, length) {
+  return wrapProgress(to - from, length);
+}
+
+function crossesDistance(previous, current, target, length) {
+  const travelled = distanceForward(previous, current, length);
+  if (travelled <= 0 || travelled > length / 2) return false;
+  const targetOffset = distanceForward(previous, target, length);
+  return targetOffset > 0 && targetOffset <= travelled + 0.001;
+}
+
+function isProgressInZone(track, progress, zone) {
+  const wrapped = wrapProgress(progress, track.length);
+  const start = wrapProgress(zone.start, track.length);
+  const end = wrapProgress(zone.end, track.length);
+  if (zone.end - zone.start >= track.length) return true;
+  return end >= start
+    ? wrapped >= start && wrapped <= end
+    : wrapped >= start || wrapped <= end;
+}
+
+export function recordDrsDetection(car, zoneId, currentTime) {
+  const previous = car.drsDetection?.[zoneId] ?? { passage: 0, time: -Infinity };
+  const next = { passage: previous.passage + 1, time: currentTime };
+  car.drsDetection = {
+    ...(car.drsDetection ?? {}),
+    [zoneId]: next,
+  };
+  return next;
+}
+
+export function updateDrsLatch(car, ahead, {
+  hasReference = Boolean(ahead),
+  safetyCarDeployed = false,
+  time,
+  track,
+  rules,
+} = {}) {
+  if (safetyCarDeployed || car.finished) {
+    car.drsEligible = false;
+    car.drsActive = false;
+    car.drsZoneId = null;
+    car.drsZoneEnabled = false;
+    return;
+  }
+
+  const previousProgress = car.previousProgress ?? car.progress;
+  const currentZone = car.drsZoneId
+    ? track.drsZones.find((zone) => zone.id === car.drsZoneId)
+    : null;
+
+  if (currentZone && !isProgressInZone(track, car.progress, currentZone)) {
+    car.drsZoneId = null;
+    car.drsZoneEnabled = false;
+  }
+
+  if (!car.drsZoneId) {
+    const crossedZone = track.drsZones.find((zone) => (
+      crossesDistance(previousProgress, car.progress, zone.start, track.length)
+    ));
+    if (crossedZone) {
+      car.drsZoneId = crossedZone.id;
+      const crossing = recordDrsDetection(car, crossedZone.id, time);
+      const aheadCrossing = ahead?.drsDetection?.[crossedZone.id];
+      car.drsZoneEnabled = Boolean(
+        hasReference &&
+        aheadCrossing &&
+        aheadCrossing.passage === crossing.passage &&
+        crossing.time >= aheadCrossing.time &&
+        crossing.time - aheadCrossing.time <= rules.drsDetectionSeconds + 1e-6
+      );
+    }
+  }
+
+  const activeZone = car.drsZoneId
+    ? track.drsZones.find((zone) => zone.id === car.drsZoneId)
+    : null;
+  const inLatchedZone = activeZone ? isProgressInZone(track, car.progress, activeZone) : false;
+  car.drsEligible = Boolean(car.drsZoneEnabled && inLatchedZone);
+  car.drsActive = car.drsEligible;
+}

package/src/simulation/timing/gapEstimation.js

@@ -0,0 +1,38 @@
+import { interpolateTimeAtDistance } from './timingHistory.js';
+import { getTimingLineCrossingTime, getTimingLineNumber } from './timingLines.js';
+
+export function estimateGapAheadSeconds(ahead, car, currentTime, track) {
+  if (!ahead) return Infinity;
+  const timingLineGap = estimateTimingLineGapSeconds(ahead, car, currentTime, track);
+  if (Number.isFinite(timingLineGap)) return timingLineGap;
+
+  const crossingTime = interpolateTimeAtDistance(ahead.timingHistory, car.raceDistance);
+  if (Number.isFinite(crossingTime)) {
+    return Math.max(0, currentTime - crossingTime);
+  }
+  const speedReference = Math.max((ahead.speed + car.speed) * 0.5, 1);
+  return Math.max(0, (ahead.raceDistance - car.raceDistance) / speedReference);
+}
+
+export function wholeLapGap(aheadDistance, carDistance, trackLength) {
+  if (!Number.isFinite(aheadDistance) || !Number.isFinite(carDistance)) return 0;
+  if (!Number.isFinite(trackLength) || trackLength <= 0) return 0;
+  return Math.max(0, Math.floor((aheadDistance - carDistance + 1e-6) / trackLength));
+}
+
+export function estimateTimingLineGapSeconds(ahead, car, currentTime, track) {
+  if (!ahead || !car) return Infinity;
+  const currentLine = getTimingLineNumber(track, Math.min(ahead.raceDistance ?? 0, car.raceDistance ?? 0));
+  if (currentLine == null) return null;
+  const oldestLine = Math.max(0, currentLine - (track.timingLines?.count ?? 0));
+
+  for (let lineNumber = currentLine; lineNumber >= oldestLine; lineNumber -= 1) {
+    const aheadTime = getTimingLineCrossingTime(ahead, lineNumber);
+    const carTime = getTimingLineCrossingTime(car, lineNumber);
+    if (Number.isFinite(aheadTime) && Number.isFinite(carTime)) {
+      return Math.max(0, carTime - aheadTime);
+    }
+  }
+
+  return null;
+}