@inventure71/paddockjs 1.0.0 → 2.0.1

package/src/simulation/replay/replayGhosts.js

@@ -0,0 +1,128 @@
+import { clamp, lerp, normalizeAngle } from '../simMath.js';
+
+const DEFAULT_GHOST_COLOR = '#00ff84';
+const DEFAULT_GHOST_OPACITY = 0.35;
+
+export function normalizeReplayGhosts(replayGhosts = []) {
+  if (!Array.isArray(replayGhosts)) return [];
+  return replayGhosts
+    .map((ghost, index) => normalizeReplayGhost(ghost, index))
+    .filter(Boolean);
+}
+
+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,
+    });
+  });
+}
+
+export function serializeReplayGhosts(replayGhosts = []) {
+  return replayGhosts.map((ghost) => ({
+    id: ghost.id,
+    label: ghost.label,
+    color: ghost.color,
+    opacity: ghost.opacity,
+    visible: ghost.visible,
+    previousX: ghost.previousX,
+    previousY: ghost.previousY,
+    x: ghost.x,
+    y: ghost.y,
+    previousHeading: ghost.previousHeading,
+    heading: ghost.heading,
+    speedKph: ghost.speedKph,
+    progressMeters: ghost.progressMeters,
+    timeSeconds: ghost.timeSeconds,
+    sensors: { ...ghost.sensors },
+  }));
+}
+
+function normalizeReplayGhost(ghost, index) {
+  if (!ghost || typeof ghost !== 'object') return null;
+  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);
+  return {
+    id,
+    label: String(ghost.label ?? id),
+    color: typeof ghost.color === 'string' && ghost.color ? ghost.color : DEFAULT_GHOST_COLOR,
+    opacity: clamp(Number(ghost.opacity ?? DEFAULT_GHOST_OPACITY), 0, 1),
+    visible: ghost.visible !== false,
+    trajectory,
+    sensors: {
+      detectableByRays: Boolean(ghost.sensors?.detectableByRays),
+      detectableAsNearby: Boolean(ghost.sensors?.detectableAsNearby),
+    },
+    previousX: initial.x,
+    previousY: initial.y,
+    x: initial.x,
+    y: initial.y,
+    previousHeading: initial.heading,
+    heading: initial.heading,
+    speedKph: initial.speedKph,
+    progressMeters: initial.progressMeters,
+    timeSeconds: 0,
+  };
+}
+
+function normalizeTrajectory(trajectory) {
+  if (!Array.isArray(trajectory)) return [];
+  return trajectory
+    .map((sample) => {
+      const timeSeconds = finiteNumber(sample?.timeSeconds);
+      const x = finiteNumber(sample?.x);
+      const y = finiteNumber(sample?.y);
+      const heading = finiteNumber(sample?.headingRadians ?? sample?.heading);
+      if (timeSeconds == null || x == null || y == null || heading == null) return null;
+      return {
+        timeSeconds,
+        x,
+        y,
+        heading,
+        speedKph: finiteNumber(sample?.speedKph) ?? 0,
+        progressMeters: finiteNumber(sample?.progressMeters) ?? 0,
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => a.timeSeconds - b.timeSeconds);
+}
+
+function interpolateTrajectory(trajectory, timeSeconds) {
+  if (trajectory.length === 1 || timeSeconds <= trajectory[0].timeSeconds) return { ...trajectory[0] };
+  const last = trajectory[trajectory.length - 1];
+  if (timeSeconds >= last.timeSeconds) return { ...last };
+  const nextIndex = trajectory.findIndex((sample) => sample.timeSeconds >= 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),
+  };
+}
+
+function finiteNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}

package/src/simulation/rules/moduleConfig.js

@@ -0,0 +1,72 @@
+import { metersToSimUnits } from '../units.js';
+import { DEFAULT_MODULES } from './ruleDefaults.js';
+import { isPlainObject, clamp01, mergeConfig, nonNegativeInteger, positiveInteger, positiveNumber } from './ruleConfigMerge.js';
+import { normalizePenaltyConfig } from './penaltyConfig.js';
+
+const MODULE_NAMES = Object.keys(DEFAULT_MODULES);
+
+export 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.stalledDnf.maxStoppedSeconds = positiveNumber(next.stalledDnf.maxStoppedSeconds, 12);
+  next.stalledDnf.speedThresholdKph = positiveNumber(next.stalledDnf.speedThresholdKph, 5);
+
+  next.penalties = normalizePenaltyConfig(next.penalties);
+  if (!explicitPitSpeed) {
+    next.penalties.pitLaneSpeeding.speedLimitKph = next.pitStops.pitLaneSpeedLimitKph;
+  }
+  return next;
+}

package/src/simulation/rules/penaltyConfig.js

@@ -0,0 +1,99 @@
+import { metersToSimUnits } from '../units.js';
+import { clamp01, nonNegativeInteger, positiveNumber } from './ruleConfigMerge.js';
+
+export const PENALTY_SUBSECTIONS = ['trackLimits', 'collision', 'tireRequirement', 'pitLaneSpeeding'];
+
+const CONSEQUENCE_TYPES = new Set([
+  'warning',
+  'time',
+  'driveThrough',
+  'stopGo',
+  'positionDrop',
+  'gridDrop',
+  'disqualification',
+]);
+
+export 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 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);
+}

package/src/simulation/rules/penaltyEvents.js

@@ -0,0 +1,18 @@
+export function createPenaltyServedEvent(entry, time) {
+  return {
+    type: 'penalty-served',
+    at: time,
+    penaltyId: entry.id,
+    driverId: entry.driverId,
+    serviceType: entry.serviceType,
+  };
+}
+
+export function createPenaltyCancelledEvent(entry, time) {
+  return {
+    type: 'penalty-cancelled',
+    at: time,
+    penaltyId: entry.id,
+    driverId: entry.driverId,
+  };
+}

package/src/simulation/rules/penaltyStats.js

@@ -0,0 +1,26 @@
+import { isPenaltyActive } from './penaltyLedger.js';
+
+export function createEmptyPenaltyStats() {
+  return {
+    seconds: 0,
+    positionDrop: 0,
+    disqualified: false,
+  };
+}
+
+export function getPenaltyStats(statsByDriver, driverId) {
+  return statsByDriver.get(driverId) ?? createEmptyPenaltyStats();
+}
+
+export function buildPenaltyStatsByDriver(penalties = []) {
+  const byDriver = new Map();
+  penalties.forEach((penalty) => {
+    if (!penalty?.driverId || !isPenaltyActive(penalty)) return;
+    const stats = byDriver.get(penalty.driverId) ?? createEmptyPenaltyStats();
+    stats.seconds += Number(penalty.penaltySeconds) || 0;
+    stats.positionDrop += Number(penalty.positionDrop) || 0;
+    stats.disqualified = stats.disqualified || Boolean(penalty.disqualified);
+    byDriver.set(penalty.driverId, stats);
+  });
+  return byDriver;
+}

package/src/simulation/rules/ruleConfigMerge.js

@@ -0,0 +1,41 @@
+export function isPlainObject(value) {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export 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)]));
+}
+
+export 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;
+}
+
+export function clamp01(value, fallback = 0) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(0, Math.min(1, numeric));
+}
+
+export function positiveNumber(value, fallback) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && numeric > 0 ? numeric : fallback;
+}
+
+export function nonNegativeInteger(value, fallback) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && numeric >= 0 ? Math.floor(numeric) : fallback;
+}
+
+export function positiveInteger(value, fallback) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && numeric > 0 ? Math.floor(numeric) : fallback;
+}

package/src/simulation/rules/ruleDefaults.js

@@ -0,0 +1,85 @@
+import { kphToSimSpeed, metersToSimUnits } from '../units.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,
+};
+
+export 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,
+  },
+  tireDegradation: {
+    enabled: true,
+  },
+  stalledDnf: {
+    enabled: false,
+    maxStoppedSeconds: 12,
+    speedThresholdKph: 5,
+  },
+  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,
+  },
+};

package/src/simulation/rules/rulesReview.js

@@ -0,0 +1,144 @@
+import { calculateCollisionPenalties } from './collisionSteward.js';
+import { calculateTireRequirementPenalty } from './tireRequirementSteward.js';
+import { calculateTrackLimitReview } from './trackLimitsSteward.js';
+import { calculatePitLaneSpeedingReview } from './pitLaneSpeedingSteward.js';
+import { getPenaltyRule } from '../rulesConfig.js';
+import { simSpeedToKph } from '../units.js';
+import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
+
+function forwardVector(car) {
+  return { x: Math.cos(car.heading), y: Math.sin(car.heading) };
+}
+
+function velocityVector(car) {
+  if (Number.isFinite(car.velocityX) && Number.isFinite(car.velocityY)) {
+    return { x: car.velocityX, y: car.velocityY };
+  }
+  const forward = forwardVector(car);
+  return { x: forward.x * car.speed, y: forward.y * car.speed };
+}
+
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y;
+}
+
+function normalizeVector(vector) {
+  const length = Math.hypot(vector.x, vector.y) || 1;
+  return { x: vector.x / length, y: vector.y / length };
+}
+
+function progressDelta(a, b, trackLength) {
+  let delta = a - b;
+  if (delta < -trackLength / 2) delta += trackLength;
+  if (delta > trackLength / 2) delta -= trackLength;
+  return delta;
+}
+
+function createCollisionStewardContext(first, second, collision) {
+  const distanceDelta = collision.trackLength
+    ? progressDelta(second.progress ?? second.raceDistance ?? 0, first.progress ?? first.raceDistance ?? 0, collision.trackLength)
+    : (second.raceDistance ?? 0) - (first.raceDistance ?? 0);
+  const sideBySideTolerance = VEHICLE_LIMITS.carLength * 0.18;
+  if (Math.abs(distanceDelta) <= sideBySideTolerance) {
+    const firstVelocity = velocityVector(first);
+    const secondVelocity = velocityVector(second);
+    const relativeVelocity = {
+      x: firstVelocity.x - secondVelocity.x,
+      y: firstVelocity.y - secondVelocity.y,
+    };
+    return {
+      ...collision,
+      impactSpeed: Math.hypot(relativeVelocity.x, relativeVelocity.y),
+      aheadDriverId: null,
+      atFaultDriverId: null,
+      sharedFault: true,
+      sharedFaultDriverIds: [first.id, second.id],
+    };
+  }
+
+  const firstBehind = distanceDelta > 0;
+  const behind = firstBehind ? first : second;
+  const ahead = firstBehind ? second : first;
+  const directionBehindToAhead = normalizeVector({
+    x: ahead.x - behind.x,
+    y: ahead.y - behind.y,
+  });
+  const behindVelocity = velocityVector(behind);
+  const aheadVelocity = velocityVector(ahead);
+  const relativeVelocity = {
+    x: behindVelocity.x - aheadVelocity.x,
+    y: behindVelocity.y - aheadVelocity.y,
+  };
+
+  return {
+    ...collision,
+    impactSpeed: Math.max(0, dot(relativeVelocity, directionBehindToAhead)),
+    aheadDriverId: ahead.id,
+    atFaultDriverId: behind.id,
+  };
+}
+
+function isLegallyInsidePitLaneForTrackLimits(car) {
+  if (!car.trackState?.inPitLane) return false;
+  const wheels = car.wheelStates ?? [];
+  return wheels.length > 0 && wheels.some((wheel) => wheel.inPitLane);
+}
+
+export function reviewCollisionForSimulation(sim, first, second, collision) {
+  const rule = getPenaltyRule(sim.rules, 'collision');
+  calculateCollisionPenalties({
+    first,
+    second,
+    collision: createCollisionStewardContext(first, second, collision),
+    rule,
+  }).forEach((penalty) => sim.recordPenalty(penalty));
+}
+
+export function reviewTireRequirementForSimulation(sim, car) {
+  const penalty = calculateTireRequirementPenalty({
+    car,
+    tireStrategy: sim.rules.modules?.tireStrategy,
+    rule: getPenaltyRule(sim.rules, 'tireRequirement'),
+  });
+  if (penalty) sim.recordPenalty(penalty);
+}
+
+export function reviewTrackLimitsForSimulation(sim) {
+  const rule = getPenaltyRule(sim.rules, 'trackLimits');
+  sim.cars.forEach((car) => {
+    if (isLegallyInsidePitLaneForTrackLimits(car)) {
+      const current = sim.stewardState.trackLimits[car.id];
+      sim.stewardState.trackLimits[car.id] = { ...(current ?? { violations: 0 }), active: false };
+      return;
+    }
+
+    const currentState = sim.stewardState.trackLimits[car.id];
+    const review = calculateTrackLimitReview({
+      car,
+      rule,
+      track: sim.track,
+      stewardState: currentState,
+    });
+    sim.stewardState.trackLimits[car.id] = review.nextState;
+    if (review.event) sim.events.unshift({ ...review.event, at: sim.time });
+    if (review.penalty) sim.recordPenalty(review.penalty);
+  });
+}
+
+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,
+    });
+    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/rulesetPresets.js

@@ -0,0 +1,47 @@
+import { DEFAULT_MODULES } from './ruleDefaults.js';
+
+export 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: false,
+      reserved: true,
+    },
+  },
+};
+
+RULESET_MODULES.fia2025 = RULESET_MODULES.grandPrix2025;

package/src/simulation/rules/trackLimitsSteward.js

@@ -1,4 +1,4 @@
-import { calculateWheelSurfaceState, isWholeCarOutsideTrackLimits } from '../wheelSurface.js';
+import { calculateWheelSurfaceState, isWholeCarOutsideTrackLimits } from '../vehicle/wheelSurface.js';
 import { metersToSimUnits } from '../units.js';
 
 const STEWARD_TRACK_LIMIT_EPSILON = metersToSimUnits(0.2);