@inventure71/paddockjs 3.0.0 → 4.1.0

package/src/app/readouts/timingTowerRenderer.js

@@ -125,6 +125,195 @@ export function syncTimingGapModeControls({ readouts, buttons, timingGapMode })
   });
 }
 
+function timingGapForCar(car, raceMode, timingGapMode) {
+  if (isDnfCar(car)) return 'DNF';
+  if (isWavedFlagCar(car) && raceMode !== 'finished') return 'WAVED';
+  if (raceMode === 'finished') return car.rank === 1 ? 'Winner' : 'FIN';
+  if (raceMode === 'safety-car' && car.rank > 1) return 'SC';
+  if (raceMode === 'pre-start') return car.rank === 1 ? 'Pole' : 'Grid';
+  if (car.rank > 1) return formatRaceGap(car, timingGapMode);
+  return 'Leader';
+}
+
+function timingRowModel({ car, driver, raceMode, selectedId, timingGapMode, penalty }) {
+  const dnf = isDnfCar(car);
+  const tire = car.tire ?? driver?.tire ?? 'M';
+  const timingCode = car.timingCode ?? driver?.timingCode ?? car.code;
+  const team = car.team ?? driver?.team ?? null;
+  const icon = team?.icon ?? car.icon ?? driver?.icon ?? timingCode;
+  const driverColor = formatCssColor(car.color);
+  const iconColor = formatCssColor(team?.color ?? car.color, driverColor);
+  const penaltyLabel = penalty ? formatPenaltyBadgeLabel(penalty) : '';
+
+  return {
+    id: car.id,
+    rank: car.rank,
+    name: car.name,
+    selected: car.id === selectedId,
+    dnf,
+    gap: timingGapForCar(car, raceMode, timingGapMode),
+    tire,
+    tireClass: getTireClass(tire),
+    timingCode,
+    icon,
+    driverColor,
+    iconColor,
+    penaltyLabel,
+  };
+}
+
+function timingRowKey(row) {
+  return [
+    row.id,
+    row.rank,
+    row.name,
+    row.selected ? 1 : 0,
+    row.dnf ? 1 : 0,
+    row.gap,
+    row.tire,
+    row.tireClass,
+    row.timingCode,
+    row.icon,
+    row.driverColor,
+    row.iconColor,
+    row.penaltyLabel,
+  ].join('\u001f');
+}
+
+function timingRowsKey(rows) {
+  return rows.map(timingRowKey).join('\u001e');
+}
+
+function renderTimingRowMarkup(row) {
+  const penaltyBadge = row.penaltyLabel
+    ? `<span class="timing-penalty-badge" aria-label="${escapeHtml(row.penaltyLabel)}" title="${escapeHtml(row.penaltyLabel)}">!</span>`
+    : '';
+
+  return `
+        <li>
+          <button class="timing-row ${row.selected ? 'is-selected' : ''} ${row.dnf ? 'is-dnf' : ''}" type="button"
+            data-driver-id="${escapeHtml(row.id)}" aria-label="Select ${escapeHtml(row.name)}"
+            style="--driver-color: ${escapeHtml(row.driverColor)}">
+            <span class="timing-position">${row.rank}</span>
+            <span class="timing-icon timing-team-icon" aria-hidden="true" style="--team-color: ${escapeHtml(row.iconColor)}">${escapeHtml(row.icon)}</span>
+            <span class="timing-name" title="${escapeHtml(row.name)}"><span>${escapeHtml(row.timingCode)}</span>${penaltyBadge}</span>
+            <span class="timing-gap">${escapeHtml(row.gap)}</span>
+            <span class="timing-tire timing-tire--${row.tireClass}">${escapeHtml(row.tire)}</span>
+          </button>
+        </li>
+      `;
+}
+
+function canPatchTimingRows(timingList) {
+  return Boolean(
+    timingList?.ownerDocument?.createElement &&
+    typeof timingList.appendChild === 'function' &&
+    timingList.children,
+  );
+}
+
+function createTimingRowView(document) {
+  const item = document.createElement('li');
+  const button = document.createElement('button');
+  const position = document.createElement('span');
+  const icon = document.createElement('span');
+  const name = document.createElement('span');
+  const code = document.createElement('span');
+  const gap = document.createElement('span');
+  const tire = document.createElement('span');
+
+  item.appendChild(button);
+  button.appendChild(position);
+  button.appendChild(icon);
+  button.appendChild(name);
+  name.appendChild(code);
+  button.appendChild(gap);
+  button.appendChild(tire);
+
+  return {
+    item,
+    button,
+    position,
+    icon,
+    name,
+    code,
+    gap,
+    tire,
+    penaltyBadge: null,
+  };
+}
+
+function setStyleProperty(element, name, value) {
+  if (typeof element.style?.setProperty === 'function') {
+    element.style.setProperty(name, value);
+  } else {
+    element.setAttribute?.('style', `${name}: ${value}`);
+  }
+}
+
+function updateTimingRowView(view, row) {
+  view.button.className = `timing-row ${row.selected ? 'is-selected' : ''} ${row.dnf ? 'is-dnf' : ''}`;
+  view.button.setAttribute('type', 'button');
+  view.button.setAttribute('data-driver-id', row.id);
+  view.button.setAttribute('aria-label', `Select ${row.name}`);
+  setStyleProperty(view.button, '--driver-color', row.driverColor);
+
+  view.position.className = 'timing-position';
+  view.position.textContent = String(row.rank);
+
+  view.icon.className = 'timing-icon timing-team-icon';
+  view.icon.setAttribute('aria-hidden', 'true');
+  setStyleProperty(view.icon, '--team-color', row.iconColor);
+  view.icon.textContent = String(row.icon ?? '');
+
+  view.name.className = 'timing-name';
+  view.name.setAttribute('title', row.name);
+  view.code.textContent = String(row.timingCode ?? '');
+
+  if (row.penaltyLabel) {
+    if (!view.penaltyBadge) {
+      view.penaltyBadge = view.name.ownerDocument.createElement('span');
+      view.name.appendChild(view.penaltyBadge);
+    }
+    view.penaltyBadge.className = 'timing-penalty-badge';
+    view.penaltyBadge.setAttribute('aria-label', row.penaltyLabel);
+    view.penaltyBadge.setAttribute('title', row.penaltyLabel);
+    view.penaltyBadge.textContent = '!';
+  } else if (view.penaltyBadge) {
+    view.penaltyBadge.remove();
+    view.penaltyBadge = null;
+  }
+
+  view.gap.className = 'timing-gap';
+  view.gap.textContent = String(row.gap);
+
+  view.tire.className = `timing-tire timing-tire--${row.tireClass}`;
+  view.tire.textContent = String(row.tire ?? '');
+}
+
+function patchTimingRows(timingList, rows) {
+  const rowViews = timingList.__paddockTimingRowViews ?? new Map();
+  timingList.__paddockTimingRowViews = rowViews;
+  const seen = new Set();
+
+  rows.forEach((row) => {
+    let view = rowViews.get(row.id);
+    if (!view) {
+      view = createTimingRowView(timingList.ownerDocument);
+      rowViews.set(row.id, view);
+    }
+    seen.add(row.id);
+    updateTimingRowView(view, row);
+    timingList.appendChild(view.item);
+  });
+
+  rowViews.forEach((view, id) => {
+    if (seen.has(id)) return;
+    view.item.remove();
+    rowViews.delete(id);
+  });
+}
+
 export function renderTimingTower({
   timingList,
   cars,
@@ -138,48 +327,20 @@ export function renderTimingTower({
 }) {
   if (!timingList) return lastTimingMarkup;
   const penaltyByDriver = timingPenaltyBadgesEnabled ? getPenaltyByDriver(penalties) : new Map();
-  const timingMarkup = cars.map((car) => {
-    const driver = driverById.get(car.id);
-    const dnf = isDnfCar(car);
-    let gap = 'Leader';
-    if (dnf) {
-      gap = 'DNF';
-    } else if (isWavedFlagCar(car) && raceMode !== 'finished') {
-      gap = 'WAVED';
-    } else if (raceMode === 'finished') {
-      gap = car.rank === 1 ? 'Winner' : 'FIN';
-    } else if (raceMode === 'safety-car' && car.rank > 1) {
-      gap = 'SC';
-    } else if (raceMode === 'pre-start') {
-      gap = car.rank === 1 ? 'Pole' : 'Grid';
-    } else if (car.rank > 1) {
-      gap = formatRaceGap(car, timingGapMode);
-    }
-    const tire = car.tire ?? driver?.tire ?? 'M';
-    const timingCode = car.timingCode ?? driver?.timingCode ?? car.code;
-    const team = car.team ?? driver?.team ?? null;
-    const icon = team?.icon ?? car.icon ?? driver?.icon ?? timingCode;
-    const driverColor = formatCssColor(car.color);
-    const iconColor = formatCssColor(team?.color ?? car.color, driverColor);
-    const penalty = penaltyByDriver.get(car.id);
-    const penaltyBadge = penalty
-      ? `<span class="timing-penalty-badge" aria-label="${escapeHtml(formatPenaltyBadgeLabel(penalty))}" title="${escapeHtml(formatPenaltyBadgeLabel(penalty))}">!</span>`
-      : '';
-
-    return `
-        <li>
-          <button class="timing-row ${car.id === selectedId ? 'is-selected' : ''} ${dnf ? 'is-dnf' : ''}" type="button"
-            data-driver-id="${escapeHtml(car.id)}" aria-label="Select ${escapeHtml(car.name)}"
-            style="--driver-color: ${escapeHtml(driverColor)}">
-            <span class="timing-position">${car.rank}</span>
-            <span class="timing-icon timing-team-icon" aria-hidden="true" style="--team-color: ${escapeHtml(iconColor)}">${escapeHtml(icon)}</span>
-            <span class="timing-name" title="${escapeHtml(car.name)}"><span>${escapeHtml(timingCode)}</span>${penaltyBadge}</span>
-            <span class="timing-gap">${escapeHtml(gap)}</span>
-            <span class="timing-tire timing-tire--${getTireClass(tire)}">${escapeHtml(tire)}</span>
-          </button>
-        </li>
-      `;
-  }).join('');
+  const rows = cars.map((car) => timingRowModel({
+    car,
+    driver: driverById.get(car.id),
+    raceMode,
+    selectedId,
+    timingGapMode,
+    penalty: penaltyByDriver.get(car.id),
+  }));
+  if (canPatchTimingRows(timingList)) {
+    patchTimingRows(timingList, rows);
+    return timingRowsKey(rows);
+  }
+
+  const timingMarkup = rows.map(renderTimingRowMarkup).join('');
   if (timingMarkup !== lastTimingMarkup || timingList.innerHTML !== timingMarkup) {
     timingList.innerHTML = timingMarkup;
     return timingMarkup;

package/src/app/runtime/frameLoop.js

@@ -48,7 +48,11 @@ export function runFrameLoopTick(app) {
   const shouldUpdateDom = now - app.lastDomUpdateTime >= domUpdateIntervalForSpeed(app.simulationSpeed);
   const fullSnapshot = stepEvents.length > 0 || shouldUpdateDom ? app.sim.snapshot() : null;
   if (stepEvents.length > 0) app.emitRaceEvents(stepEvents, fullSnapshot);
-  const renderSource = fullSnapshot ?? app.sim.snapshotRender?.() ?? app.sim.snapshot();
+  const renderSource = fullSnapshot ??
+    app.sim.snapshotRenderInto?.(app.renderSourceSnapshotBuffer ?? {}) ??
+    app.sim.snapshotRender?.() ??
+    app.sim.snapshot();
+  if (!fullSnapshot && app.sim.snapshotRenderInto) app.renderSourceSnapshotBuffer = renderSource;
   const renderSnapshot = interpolateRenderSnapshotInto(
     app.renderSnapshotBuffer ?? {},
     renderSource,

package/src/config/defaultOptions.js

@@ -119,7 +119,14 @@ export const PADDOCK_SIMULATOR_PRESETS = {
   },
 };
 
-export { PADDOCK_THEME_CSS_VARIABLES, applyPaddockThemeCssVariables } from './themeOptions.js';
+export {
+  DEFAULT_PADDOCK_THEME,
+  PADDOCK_THEME_CSS_VARIABLES,
+  PADDOCK_THEME_TOKEN_KEYS,
+  applyPaddockTheme,
+  applyPaddockThemeCssVariables,
+  resolvePaddockTheme,
+} from './themeOptions.js';
 
 const SUPPORTED_CAMERA_MODES = new Set(['overview', 'leader', 'selected', 'driver', 'show-all', 'pit']);
 

package/src/config/themeOptions.js

@@ -34,6 +34,7 @@ export const THEME_SIZE_TOKEN_KEYS = [
 ];
 
 const THEME_TOKEN_KEYS = [...THEME_COLOR_TOKEN_KEYS, ...THEME_SIZE_TOKEN_KEYS];
+export const PADDOCK_THEME_TOKEN_KEYS = THEME_TOKEN_KEYS;
 const THEME_TOKEN_SET = new Set(THEME_TOKEN_KEYS);
 const COLOR_TOKEN_SET = new Set(THEME_COLOR_TOKEN_KEYS);
 const SIZE_TOKEN_SET = new Set(THEME_SIZE_TOKEN_KEYS);
@@ -248,6 +249,7 @@ export const DEFAULT_PADDOCK_THEME_INPUT = {
   mode: 'dark',
   use: 'default',
 };
+export const DEFAULT_PADDOCK_THEME = DEFAULT_PADDOCK_THEME_INPUT;
 
 const DEFAULT_THEME_PACKAGE = {
   tokens: {
@@ -346,6 +348,9 @@ export function applyPaddockThemeCssVariables(root, theme = DEFAULT_PADDOCK_THEM
   });
 }
 
+export const resolvePaddockTheme = normalizePaddockTheme;
+export const applyPaddockTheme = applyPaddockThemeCssVariables;
+
 export function normalizeCssColorToken(value, fallback = null) {
   if (typeof value !== 'string') return fallback;
   const candidate = value.trim();

package/src/data/index.d.ts

@@ -0,0 +1,212 @@
+export type TireCompound = 'S' | 'M' | 'H';
+export type PaddockProceduralTrackProfile = 'race' | 'training-short' | 'training-medium' | 'training-technical';
+
+export interface PaddockProceduralTrackOptions {
+  profile?: PaddockProceduralTrackProfile;
+  minLengthMeters?: number;
+  maxLengthMeters?: number;
+  startStraightMeters?: number;
+  includePitLane?: boolean;
+  length?: {
+    minMeters?: number;
+    maxMeters?: number;
+  };
+  startStraight?: {
+    gridMeters?: number;
+    exitMeters?: number;
+    blendMeters?: number;
+    lockExtraMeters?: number;
+  };
+  pitLane?: {
+    enabled?: boolean;
+  };
+  shape?: {
+    scale?: number;
+    cornerDensity?: number;
+    variation?: number;
+  };
+  validation?: {
+    minClearanceMultiplier?: number;
+    minShapeVariation?: number;
+    minNonAdjacentArcMeters?: number;
+    maxLocalTurnRadians?: number;
+    maxSampleHeadingDeltaRadians?: number;
+  };
+  attempts?: {
+    primary?: number;
+    fallback?: number;
+  };
+}
+
+export interface CustomField {
+  label: string;
+  value: string;
+}
+
+export type CustomFieldInput = CustomField[] | Record<string, string>;
+export type PaddockThemeSelector = 'default' | 'active' | 'selectedTeam' | 'team' | `team:${string}` | string;
+
+export interface PaddockPitCrewStats {
+  speed?: number;
+  consistency?: number;
+  reliability?: number;
+}
+
+export interface TeamData {
+  id?: string;
+  name?: string;
+  color?: string;
+  icon?: string;
+  theme?: PaddockThemeSelector;
+  pitCrew?: PaddockPitCrewStats;
+  pitCrewStats?: PaddockPitCrewStats;
+}
+
+export interface SimulatorDriver {
+  id: string;
+  name: string;
+  color: string;
+  link?: string;
+  icon?: string;
+  code?: string;
+  timingName?: string;
+  tire?: TireCompound;
+  raceData?: string[];
+  customFields?: CustomFieldInput;
+  team?: TeamData | null;
+  driverNumber?: number;
+}
+
+export interface DriverRatings {
+  pace: number;
+  racecraft: number;
+  aggression: number;
+  riskTolerance: number;
+  patience: number;
+  consistency: number;
+}
+
+export interface VehicleRatings {
+  power: number;
+  braking: number;
+  aero: number;
+  dragEfficiency: number;
+  mechanicalGrip: number;
+  weightControl: number;
+  tireCare: number;
+}
+
+export interface DriverBlueprint extends Partial<DriverRatings> {
+  customFields?: CustomFieldInput;
+}
+
+export interface VehicleBlueprint extends Partial<VehicleRatings> {
+  id?: string | null;
+  name?: string | null;
+  customFields?: CustomFieldInput;
+}
+
+export interface DriverConstructorArgs {
+  ratings: DriverRatings;
+  customFields: CustomField[];
+  pace: number;
+  racecraft: number;
+  consistency: number;
+  personality: {
+    aggression: number;
+    riskTolerance: number;
+    patience: number;
+  };
+}
+
+export interface VehicleConstructorArgs {
+  id: string | null;
+  name: string | null;
+  ratings: VehicleRatings;
+  customFields: CustomField[];
+  powerNewtons: number;
+  brakeNewtons: number;
+  downforceCoefficient: number;
+  dragCoefficient: number;
+  tireGrip: number;
+  mass: number;
+  tireCare: number;
+}
+
+export class DriverData {
+  constructor(input?: DriverBlueprint);
+  readonly pace: number;
+  readonly racecraft: number;
+  readonly aggression: number;
+  readonly riskTolerance: number;
+  readonly patience: number;
+  readonly consistency: number;
+  readonly customFields: CustomField[];
+  ratings(): DriverRatings;
+  toConstructorArgs(): DriverConstructorArgs;
+}
+
+export class VehicleData {
+  constructor(input?: VehicleBlueprint);
+  readonly id: string | null;
+  readonly name: string | null;
+  readonly power: number;
+  readonly braking: number;
+  readonly aero: number;
+  readonly dragEfficiency: number;
+  readonly mechanicalGrip: number;
+  readonly weightControl: number;
+  readonly tireCare: number;
+  readonly customFields: CustomField[];
+  ratings(): VehicleRatings;
+  toConstructorArgs(): VehicleConstructorArgs;
+}
+
+export interface ChampionshipEntryBlueprint {
+  driverId: string;
+  driverNumber?: number;
+  timingName?: string;
+  driver?: DriverData | DriverBlueprint;
+  vehicle?: VehicleData | VehicleBlueprint;
+  team?: TeamData;
+}
+
+export interface NormalizedSimulatorDriver extends SimulatorDriver {
+  code: string;
+  timingCode: string;
+  raceName: string;
+  driverNumber: number;
+  team: TeamData | null;
+  pace: number;
+  racecraft: number;
+  consistency: number;
+  personality: DriverConstructorArgs['personality'];
+  vehicle: VehicleConstructorArgs;
+  constructorArgs: {
+    driver: DriverConstructorArgs;
+    vehicle: VehicleConstructorArgs;
+  };
+  championship: {
+    id: string;
+    name: string;
+    season: number;
+    entryIndex: number;
+    vehicleId: string | null;
+  };
+}
+
+export const CHAMPIONSHIP_ENTRY_BLUEPRINTS: ChampionshipEntryBlueprint[];
+export const DEMO_PROJECT_DRIVERS: SimulatorDriver[];
+
+export function buildChampionshipDriverGrid(
+  drivers?: SimulatorDriver[],
+  entries?: ChampionshipEntryBlueprint[],
+): NormalizedSimulatorDriver[];
+export function formatDriverNumber(driverNumber: number | string | null | undefined): string;
+export function normalizeSimulatorDrivers(
+  drivers: SimulatorDriver[],
+  options?: { entries?: ChampionshipEntryBlueprint[]; caller?: string },
+): NormalizedSimulatorDriver[];
+export function createProceduralTrack(seed?: number | string, options?: PaddockProceduralTrackOptions): unknown;
+export function kphToSimSpeed(kph: number): number;
+export function simSpeedToKph(simSpeed: number): number;

package/src/data/index.js

@@ -0,0 +1,14 @@
+export {
+  CHAMPIONSHIP_ENTRY_BLUEPRINTS,
+  DriverData,
+  VehicleData,
+  buildChampionshipDriverGrid,
+  formatDriverNumber,
+} from './championship.js';
+export { DEMO_PROJECT_DRIVERS } from './demoDrivers.js';
+export { normalizeSimulatorDrivers } from './normalizeDrivers.js';
+export { createProceduralTrack } from '../simulation/track/trackModel.js';
+export {
+  kphToSimSpeed,
+  simSpeedToKph,
+} from '../simulation/units.js';

package/src/environment/episode.js

@@ -2,6 +2,9 @@ export function createEpisodeState() {
   return {
     step: 0,
     drivers: new Map(),
+    observationScratch: {},
+    metricScratch: {},
+    destroyedCarsById: new Map(),
     previousSnapshot: null,
     lastResult: null,
   };
@@ -30,7 +33,14 @@ export function resetDriverEpisodes(episodeState, driverIds = []) {
 }
 
 export function markDestroyedDriverEpisodes(episodeState, driverIds = [], snapshot = null) {
-  const carsById = new Map((snapshot?.cars ?? []).map((car) => [car.id, car]));
+  const carsById = episodeState.destroyedCarsById ?? new Map();
+  episodeState.destroyedCarsById = carsById;
+  carsById.clear();
+  const cars = snapshot?.cars ?? [];
+  for (let index = 0; index < cars.length; index += 1) {
+    const car = cars[index];
+    carsById.set(car.id, car);
+  }
   driverIds.forEach((driverId) => {
     const car = carsById.get(driverId);
     if (!car?.destroyed && !car?.dnf && !car?.outOfRace) return;

package/src/environment/metrics.js

@@ -5,6 +5,21 @@ import { simUnitsToMeters } from '../simulation/units.js';
 const LEGAL_SURFACES = new Set(['track', 'kerb', 'pit-entry', 'pit-lane', 'pit-exit', 'pit-box']);
 const ILLEGAL_SURFACES = new Set(['grass', 'gravel', 'runoff', 'barrier']);
 const UNSTABLE_STATES = new Set(['spun', 'backwards', 'spin-risk', 'understeer', 'oversteer', 'destroyed']);
+export const ENVIRONMENT_METRIC_FIELDS = Object.freeze([
+  'progressDeltaMeters',
+  'legalProgressDeltaMeters',
+  'offTrack',
+  'kerb',
+  'fullyOutsideWhiteLine',
+  'severeCut',
+  'destroyed',
+  'destroyReason',
+  'under30kph',
+  'spinOrBackwards',
+  'completedLap',
+  'lapTimeSeconds',
+  'contactCount',
+]);
 
 export function isEnvironmentCarOffTrack(car) {
   if (!car) return false;
@@ -15,19 +30,32 @@ export function isEnvironmentContactEvent(event) {
   return ['collision', 'contact', 'car-contact'].includes(event?.type);
 }
 
-export function buildDriverMetrics({ snapshot, previousSnapshot = null, options, events = [] }) {
-  const previousById = new Map((previousSnapshot?.cars ?? []).map((car) => [car.id, car]));
-  const currentById = new Map(snapshot.cars.map((car) => [car.id, car]));
-  const contactCounts = contactCountsByDriver(events);
+export function buildDriverMetrics({ snapshot, previousSnapshot = null, options, events = [], scratch = null }) {
+  const previousById = carsByIdForMetrics(previousSnapshot, scratch, 'previousCarsById');
+  const currentById = carsByIdForMetrics(snapshot, scratch, 'currentCarsById');
+  const contactCounts = contactCountsByDriver(events, scratch);
   const metrics = {};
   options.controlledDrivers.forEach((driverId) => {
     const car = currentById.get(driverId);
     const previous = previousById.get(driverId);
-    metrics[driverId] = car ? buildMetricForDriver(car, previous, snapshot, contactCounts.get(driverId) ?? 0) : emptyMetrics();
+    metrics[driverId] = car ? buildMetricForDriver(car, previous, snapshot, contactCounts?.get(driverId) ?? 0) : emptyMetrics();
   });
   return metrics;
 }
 
+function carsByIdForMetrics(snapshot, scratch, key) {
+  if (!scratch) return new Map((snapshot?.cars ?? []).map((car) => [car.id, car]));
+  const carsById = scratch[key] ?? new Map();
+  scratch[key] = carsById;
+  carsById.clear();
+  const cars = snapshot?.cars ?? [];
+  for (let index = 0; index < cars.length; index += 1) {
+    const car = cars[index];
+    carsById.set(car.id, car);
+  }
+  return carsById;
+}
+
 function buildMetricForDriver(car, previous, snapshot, contactCount) {
   const progressDeltaMeters = progressDelta(car, previous);
   const wheelState = classifyWheels(car);
@@ -140,20 +168,35 @@ function lastLapTimeSeconds(car) {
   return car.lapTelemetry?.lastLapTime ?? car.lapTelemetry?.bestLapTime ?? null;
 }
 
-function contactCountsByDriver(events) {
-  const counts = new Map();
-  if (!events.length) return counts;
+function contactCountsByDriver(events, scratch = null) {
+  if (!events.length) return null;
+  const counts = scratch ? (scratch.contactCounts ?? new Map()) : new Map();
+  const eventDriverIds = scratch ? (scratch.eventDriverIds ?? []) : [];
+  if (scratch) {
+    scratch.contactCounts = counts;
+    scratch.eventDriverIds = eventDriverIds;
+  }
+  counts.clear();
   events.forEach((event) => {
     if (!isEnvironmentContactEvent(event)) return;
-    const eventDriverIds = new Set([
-      event.driverId,
-      event.carId,
-      event.otherCarId,
-      ...(event.driverIds ?? []),
-    ].filter(Boolean));
-    eventDriverIds.forEach((driverId) => {
+    eventDriverIds.length = 0;
+    pushEventDriverId(eventDriverIds, event.driverId);
+    pushEventDriverId(eventDriverIds, event.carId);
+    pushEventDriverId(eventDriverIds, event.otherCarId);
+    const extraDriverIds = event.driverIds ?? [];
+    for (let index = 0; index < extraDriverIds.length; index += 1) {
+      pushEventDriverId(eventDriverIds, extraDriverIds[index]);
+    }
+    for (let index = 0; index < eventDriverIds.length; index += 1) {
+      const driverId = eventDriverIds[index];
       counts.set(driverId, (counts.get(driverId) ?? 0) + 1);
-    });
+    }
   });
+  eventDriverIds.length = 0;
   return counts;
 }
+
+function pushEventDriverId(target, driverId) {
+  if (!driverId || target.includes(driverId)) return;
+  target.push(driverId);
+}