@inventure71/paddockjs 0.1.0 → 0.3.0

package/src/index.d.ts

@@ -1,5 +1,9 @@
+import type { PaddockActionSpec, PaddockObservationSpec } from './environment/index.js';
+
+export type { PaddockActionSpec, PaddockObservationSpec } from './environment/index.js';
+
 export type TireCompound = 'S' | 'M' | 'H';
-export type CameraMode = 'overview' | 'leader' | 'selected';
+export type CameraMode = 'overview' | 'leader' | 'selected' | 'show-all';
 export type RaceBannerMode = 'project' | 'radio' | 'hidden';
 export type RaceBannerEnabledMode = 'project' | 'radio';
 export type RaceDataBannerSize = 'auto' | 'custom';
@@ -7,6 +11,8 @@ export type TimingTowerVerticalFit = 'expand-race-view' | 'scroll';
 export type LayoutPreset = 'standard' | 'left-tower-overlay';
 export type CameraControlsMode = 'embedded' | 'external' | false;
 export type PaddockPresetName = 'dashboard' | 'timing-overlay' | 'compact-race' | 'full-dashboard';
+export type TelemetryModuleName = 'core' | 'sectors' | 'lapTimes' | 'sectorTimes';
+export type SectorPerformanceStatus = 'overall-best' | 'personal-best' | 'slower';
 
 export interface CustomField {
   label: string;
@@ -170,12 +176,14 @@ export interface F1SimulatorUiOptions {
   showTimingTower?: boolean;
   showTelemetry?: boolean;
   telemetryIncludesOverview?: boolean;
+  telemetryModules?: boolean | TelemetryModuleName[] | Partial<Record<TelemetryModuleName, boolean>>;
   showRaceDataPanel?: boolean;
   raceDataBanners?: {
     initial?: RaceBannerMode;
     enabled?: true | false | RaceBannerEnabledMode[];
   };
   raceDataBannerSize?: RaceDataBannerSize;
+  raceDataTelemetryDetail?: boolean;
   timingTowerVerticalFit?: TimingTowerVerticalFit;
 }
 
@@ -197,9 +205,40 @@ export interface TrackSnapshot {
   seed?: number | null;
   width?: number;
   length?: number;
+  sectors?: TrackSectorSnapshot[];
   [key: string]: unknown;
 }
 
+export interface TrackSectorSnapshot {
+  index: number;
+  id: string;
+  label: string;
+  start: number;
+  end: number;
+  startRatio: number;
+  endRatio: number;
+  length: number;
+}
+
+export interface LapTelemetrySnapshot {
+  currentLap: number;
+  currentSector: number;
+  currentLapTime: number | null;
+  currentSectorElapsed: number | null;
+  currentSectorProgress: number | null;
+  currentSectors: Array<number | null>;
+  sectorPerformance: {
+    current: Array<SectorPerformanceStatus | null>;
+    last: Array<SectorPerformanceStatus | null>;
+    best: Array<SectorPerformanceStatus | null>;
+  };
+  lastLapTime: number | null;
+  bestLapTime: number | null;
+  lastSectors: Array<number | null>;
+  bestSectors: Array<number | null>;
+  completedLaps: number;
+}
+
 export interface RaceEvent {
   type: string;
   at?: number;
@@ -221,6 +260,7 @@ export interface CarSnapshot {
   classifiedRank?: number | null;
   intervalAheadSeconds?: number | null;
   leaderGapSeconds?: number | null;
+  lapTelemetry?: LapTelemetrySnapshot;
   [key: string]: unknown;
 }
 
@@ -288,6 +328,31 @@ export interface F1SimulatorCallbacks {
   }) => void;
 }
 
+export interface F1SimulatorExpertOptions {
+  enabled: boolean;
+  controlledDrivers: string[];
+  frameSkip?: number;
+  visualizeSensors?: boolean | {
+    rays?: boolean;
+  };
+}
+
+export interface F1SimulatorExpertAction {
+  steering: number;
+  throttle: number;
+  brake: number;
+}
+
+export interface F1SimulatorExpertApi {
+  reset(options?: unknown): unknown;
+  step(actions: Record<string, F1SimulatorExpertAction>): unknown;
+  getObservation(): unknown;
+  getState(): unknown;
+  getActionSpec(): PaddockActionSpec;
+  getObservationSpec(): PaddockObservationSpec;
+  destroy(): void;
+}
+
 export interface F1SimulatorOptions extends F1SimulatorCallbacks {
   preset?: PaddockPresetName;
   drivers: SimulatorDriver[];
@@ -304,11 +369,15 @@ export interface F1SimulatorOptions extends F1SimulatorCallbacks {
   showBackLink?: boolean;
   ui?: F1SimulatorUiOptions;
   assets?: F1SimulatorAssets;
+  expert?: F1SimulatorExpertOptions;
 }
 
+export type F1SimulatorRestartOptions = Partial<Omit<F1SimulatorOptions, 'assets' | 'expert'>>;
+
 export interface MountRaceCanvasOptions {
   includeRaceDataPanel?: boolean;
   includeTimingTower?: boolean;
+  includeTelemetrySectorBanner?: boolean;
   timingTowerVerticalFit?: TimingTowerVerticalFit;
 }
 
@@ -316,9 +385,16 @@ export interface MountTelemetryPanelOptions {
   includeOverview?: boolean;
 }
 
+export interface MountRaceTelemetryDrawerOptions {
+  timingTowerVerticalFit?: TimingTowerVerticalFit;
+  drawerInitiallyOpen?: boolean;
+  raceDataTelemetryDetail?: boolean;
+}
+
 export interface F1MountedSimulator {
+  readonly expert: F1SimulatorExpertApi | null;
   destroy(): void;
-  restart(nextOptions?: Partial<F1SimulatorOptions>): void;
+  restart(nextOptions?: F1SimulatorRestartOptions): void;
   selectDriver(driverId: string): void;
   setSafetyCarDeployed(deployed: boolean): void;
   callSafetyCar(): void;
@@ -328,19 +404,26 @@ export interface F1MountedSimulator {
 }
 
 export interface PaddockSimulatorController {
+  readonly expert: F1SimulatorExpertApi | null;
   mountRaceControls<T extends Element>(root: T): T;
   mountCameraControls<T extends Element>(root: T): T;
   mountSafetyCarControl<T extends Element>(root: T): T;
   mountTimingTower<T extends Element>(root: T): T;
   mountRaceCanvas<T extends Element>(root: T, options?: MountRaceCanvasOptions): T;
   mountTelemetryPanel<T extends Element>(root: T, options?: MountTelemetryPanelOptions): T;
+  mountTelemetryCore<T extends Element>(root: T): T;
+  mountTelemetrySectors<T extends Element>(root: T): T;
+  mountTelemetrySectorBanner<T extends Element>(root: T): T;
+  mountTelemetryLapTimes<T extends Element>(root: T): T;
+  mountTelemetrySectorTimes<T extends Element>(root: T): T;
+  mountRaceTelemetryDrawer<T extends Element>(root: T, options?: MountRaceTelemetryDrawerOptions): T;
   mountCarDriverOverview<T extends Element>(root: T): T;
   mountRaceDataPanel<T extends Element>(root: T): T;
   querySelector(selector: string): Element | null;
   querySelectorAll(selector: string): Element[];
   start(): Promise<PaddockSimulatorController>;
   destroy(): void;
-  restart(nextOptions?: Partial<F1SimulatorOptions>): void;
+  restart(nextOptions?: F1SimulatorRestartOptions): void;
   selectDriver(driverId: string): void;
   setSafetyCarDeployed(deployed: boolean): void;
   callSafetyCar(): void;
@@ -369,7 +452,7 @@ export function buildChampionshipDriverGrid(
 export function formatDriverNumber(driverNumber: number | string | null | undefined): string;
 export function normalizeSimulatorDrivers(
   drivers: SimulatorDriver[],
-  options?: { entries?: ChampionshipEntryBlueprint[] },
+  options?: { entries?: ChampionshipEntryBlueprint[]; caller?: string },
 ): NormalizedSimulatorDriver[];
 
 export function metersToSimUnits(meters: number): number;
@@ -395,5 +478,15 @@ export function mountTelemetryPanel<T extends Element>(
   simulator: PaddockSimulatorController,
   options?: MountTelemetryPanelOptions,
 ): T;
+export function mountTelemetryCore<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
+export function mountTelemetrySectors<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
+export function mountTelemetrySectorBanner<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
+export function mountTelemetryLapTimes<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
+export function mountTelemetrySectorTimes<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
+export function mountRaceTelemetryDrawer<T extends Element>(
+  root: T,
+  simulator: PaddockSimulatorController,
+  options?: MountRaceTelemetryDrawerOptions,
+): T;
 export function mountCarDriverOverview<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
 export function mountRaceDataPanel<T extends Element>(root: T, simulator: PaddockSimulatorController): T;

package/src/index.js

@@ -9,8 +9,14 @@ export {
   mountRaceCanvas,
   mountRaceControls,
   mountRaceDataPanel,
+  mountRaceTelemetryDrawer,
   mountSafetyCarControl,
+  mountTelemetryCore,
+  mountTelemetryLapTimes,
   mountTelemetryPanel,
+  mountTelemetrySectorBanner,
+  mountTelemetrySectorTimes,
+  mountTelemetrySectors,
   mountTimingTower,
 } from './api/PaddockSimulatorController.js';
 
@@ -85,13 +91,17 @@ export async function mountF1Simulator(root, options = {}) {
   await app.init();
 
   return {
+    get expert() {
+      return app.expert ?? null;
+    },
     destroy() {
       app.destroy();
       root.innerHTML = '';
     },
     restart(nextOptions = {}) {
-      resolvedOptions = resolveF1SimulatorOptions(mergeRestartOptions(resolvedOptions, nextOptions));
-      app.restart(resolvedOptions);
+      const nextResolvedOptions = resolveF1SimulatorOptions(mergeRestartOptions(resolvedOptions, nextOptions));
+      app.restart(nextResolvedOptions);
+      resolvedOptions = nextResolvedOptions;
     },
     selectDriver(driverId) {
       app.selectCar(driverId, { focus: true });

package/src/rendering/proceduralTrackAsset.js

@@ -48,6 +48,12 @@ function textureOrWhite(texture) {
   return texture ?? Texture.WHITE;
 }
 
+function destroyDisplayChildren(container) {
+  container.removeChildren().forEach((child) => {
+    child.destroy?.({ children: true, texture: false, textureSource: false });
+  });
+}
+
 function arcDistance(track, first, second) {
   const delta = Math.abs(first - second);
   return Math.min(delta, track.length - delta);
@@ -269,7 +275,7 @@ export class ProceduralTrackAsset {
   }
 
   render(track) {
-    this.container.removeChildren();
+    destroyDisplayChildren(this.container);
     this.addGrass();
     this.addGravelRunoff(track);
     this.addBoundaryUnderlay(track);

package/src/simulation/raceSimulation.js

@@ -13,12 +13,15 @@ import { simSpeedToKph, simUnitsToMeters } from './units.js';
 import { getCarCorners, integrateVehiclePhysics, VEHICLE_LIMITS } from './vehiclePhysics.js';
 
 const DEFAULT_TOTAL_LAPS = 10;
+export const FIXED_STEP = 1 / 60;
+const MIN_TOTAL_LAPS = 1;
 const MAX_COLLISION_CORRECTION = 4.5;
 const GRID_SLOT_SPACING = 82;
 const GRID_FIRST_SLOT_DISTANCE = -42;
 const GRID_LATERAL_OFFSET = 42;
 const TIMING_HISTORY_WINDOW_SECONDS = 18;
 const TIMING_HISTORY_MAX_SAMPLES = 720;
+const TELEMETRY_SECTOR_COUNT = 3;
 
 export const DEFAULT_RULES = {
   drsDetectionSeconds: 1,
@@ -57,6 +60,202 @@ function isProgressInZone(track, progress, zone) {
     : wrapped >= start || wrapped <= end;
 }
 
+function createEmptySectorTimes() {
+  return Array.from({ length: TELEMETRY_SECTOR_COUNT }, () => null);
+}
+
+function createEmptySectorPerformance() {
+  return {
+    current: createEmptySectorTimes(),
+    last: createEmptySectorTimes(),
+    best: createEmptySectorTimes(),
+  };
+}
+
+function getSectorLength(track) {
+  return track.length / TELEMETRY_SECTOR_COUNT;
+}
+
+function getLapTelemetryPosition(track, raceDistance, totalLaps = Infinity) {
+  const positiveDistance = Math.max(0, raceDistance ?? 0);
+  const lapIndex = Math.min(
+    Math.floor(positiveDistance / track.length),
+    Math.max(0, totalLaps - 1),
+  );
+  const lapProgress = positiveDistance >= track.length * totalLaps
+    ? track.length
+    : positiveDistance - lapIndex * track.length;
+  const sectorLength = getSectorLength(track);
+  const sectorIndex = Math.min(TELEMETRY_SECTOR_COUNT - 1, Math.floor(lapProgress / sectorLength));
+  const sectorStart = sectorIndex * sectorLength;
+
+  return {
+    completedLaps: Math.floor(positiveDistance / track.length),
+    currentLap: Math.max(1, lapIndex + 1),
+    currentSector: sectorIndex + 1,
+    currentSectorProgress: clamp((lapProgress - sectorStart) / sectorLength, 0, 1),
+  };
+}
+
+function createLapTelemetry(track, currentTime = 0, raceDistance = 0, totalLaps = Infinity) {
+  const position = getLapTelemetryPosition(track, raceDistance, totalLaps);
+  return {
+    ...position,
+    currentLapStartedAt: currentTime,
+    currentSectorStartedAt: currentTime,
+    lastUpdatedAt: currentTime,
+    currentLapTime: 0,
+    currentSectorElapsed: 0,
+    currentSectors: createEmptySectorTimes(),
+    lastLapTime: null,
+    bestLapTime: null,
+    lastSectors: createEmptySectorTimes(),
+    bestSectors: createEmptySectorTimes(),
+    sectorPerformance: createEmptySectorPerformance(),
+  };
+}
+
+function resetLapTelemetry(car, currentTime, track, totalLaps) {
+  car.lapTelemetry = createLapTelemetry(track, currentTime, car.raceDistance, totalLaps);
+}
+
+function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}
+
+function serializeSectorTimes(values) {
+  return createEmptySectorTimes().map((_, index) => finiteOrNull(values?.[index]));
+}
+
+function serializeLapTelemetry(telemetry) {
+  return {
+    currentLap: telemetry.currentLap,
+    currentSector: telemetry.currentSector,
+    currentLapTime: finiteOrNull(telemetry.currentLapTime),
+    currentSectorElapsed: finiteOrNull(telemetry.currentSectorElapsed),
+    currentSectorProgress: finiteOrNull(telemetry.currentSectorProgress),
+    currentSectors: serializeSectorTimes(telemetry.currentSectors),
+    lastLapTime: finiteOrNull(telemetry.lastLapTime),
+    bestLapTime: finiteOrNull(telemetry.bestLapTime),
+    lastSectors: serializeSectorTimes(telemetry.lastSectors),
+    bestSectors: serializeSectorTimes(telemetry.bestSectors),
+    sectorPerformance: {
+      current: serializeSectorPerformance(telemetry.sectorPerformance?.current),
+      last: serializeSectorPerformance(telemetry.sectorPerformance?.last),
+      best: serializeSectorPerformance(telemetry.sectorPerformance?.best),
+    },
+    completedLaps: telemetry.completedLaps,
+  };
+}
+
+function serializeSectorPerformance(values) {
+  return createEmptySectorTimes().map((_, index) => values?.[index] ?? null);
+}
+
+function updateBestSector(telemetry, sectorIndex, sectorTime) {
+  const previousBest = telemetry.bestSectors[sectorIndex];
+  if (!Number.isFinite(previousBest) || sectorTime < previousBest) {
+    telemetry.bestSectors[sectorIndex] = sectorTime;
+  }
+}
+
+function syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, track, totalLaps) {
+  const position = getLapTelemetryPosition(track, currentRaceDistance, totalLaps);
+  telemetry.currentLap = position.currentLap;
+  telemetry.currentSector = position.currentSector;
+  telemetry.currentSectorProgress = position.currentSectorProgress;
+  telemetry.completedLaps = Math.max(telemetry.completedLaps, Math.min(position.completedLaps, totalLaps));
+  telemetry.currentLapTime = Math.max(0, currentTime - telemetry.currentLapStartedAt);
+  telemetry.currentSectorElapsed = Math.max(0, currentTime - telemetry.currentSectorStartedAt);
+}
+
+function classifySectorPerformance(value, personalBest, overallBest) {
+  if (!Number.isFinite(value)) return null;
+  if (Number.isFinite(overallBest) && Math.abs(value - overallBest) <= 1e-6) return 'overall-best';
+  if (Number.isFinite(personalBest) && Math.abs(value - personalBest) <= 1e-6) return 'personal-best';
+  return 'slower';
+}
+
+function updateSectorPerformance(cars) {
+  const overallBestSectors = createEmptySectorTimes();
+  cars.forEach((car) => {
+    car.lapTelemetry?.bestSectors?.forEach((time, index) => {
+      if (!Number.isFinite(time)) return;
+      const previousBest = overallBestSectors[index];
+      if (!Number.isFinite(previousBest) || time < previousBest) overallBestSectors[index] = time;
+    });
+  });
+
+  cars.forEach((car) => {
+    if (!car.lapTelemetry) return;
+    const telemetry = car.lapTelemetry;
+    telemetry.sectorPerformance = {
+      current: telemetry.currentSectors.map((time, index) => (
+        classifySectorPerformance(time, telemetry.bestSectors[index], overallBestSectors[index])
+      )),
+      last: telemetry.lastSectors.map((time, index) => (
+        classifySectorPerformance(time, telemetry.bestSectors[index], overallBestSectors[index])
+      )),
+      best: telemetry.bestSectors.map((time, index) => (
+        classifySectorPerformance(time, telemetry.bestSectors[index], overallBestSectors[index])
+      )),
+    };
+  });
+}
+
+function updateLapTelemetry(car, previousRaceDistance, currentTime, track, totalLaps) {
+  if (!car.lapTelemetry) resetLapTelemetry(car, currentTime, track, totalLaps);
+
+  const telemetry = car.lapTelemetry;
+  const currentRaceDistance = car.raceDistance ?? 0;
+  const previousDistance = Math.max(0, previousRaceDistance ?? currentRaceDistance);
+  const currentDistance = Math.max(0, currentRaceDistance);
+  const travelled = currentDistance - previousDistance;
+  const previousUpdateTime = Number.isFinite(telemetry.lastUpdatedAt) ? telemetry.lastUpdatedAt : currentTime;
+  const elapsedTime = Math.max(0, currentTime - previousUpdateTime);
+
+  if (!Number.isFinite(previousDistance) || !Number.isFinite(currentDistance) || travelled < -1e-3 || travelled > track.length / 2) {
+    resetLapTelemetry(car, currentTime, track, totalLaps);
+    return;
+  }
+
+  const sectorLength = getSectorLength(track);
+  if (travelled > 1e-6) {
+    const firstBoundary = Math.floor(previousDistance / sectorLength) + 1;
+    const lastBoundary = Math.floor(currentDistance / sectorLength);
+
+    for (let boundary = firstBoundary; boundary <= lastBoundary; boundary += 1) {
+      const boundaryDistance = boundary * sectorLength;
+      if (boundaryDistance <= previousDistance + 1e-3 || boundaryDistance > currentDistance + 1e-3) continue;
+
+      const boundaryRatio = clamp((boundaryDistance - previousDistance) / travelled, 0, 1);
+      const crossingTime = previousUpdateTime + boundaryRatio * elapsedTime;
+      const sectorIndex = (boundary - 1) % TELEMETRY_SECTOR_COUNT;
+      const sectorTime = Math.max(0, crossingTime - telemetry.currentSectorStartedAt);
+
+      telemetry.currentSectors[sectorIndex] = sectorTime;
+      updateBestSector(telemetry, sectorIndex, sectorTime);
+
+      if (sectorIndex === TELEMETRY_SECTOR_COUNT - 1) {
+        const lapTime = Math.max(0, crossingTime - telemetry.currentLapStartedAt);
+        telemetry.lastLapTime = lapTime;
+        telemetry.bestLapTime = Number.isFinite(telemetry.bestLapTime)
+          ? Math.min(telemetry.bestLapTime, lapTime)
+          : lapTime;
+        telemetry.lastSectors = serializeSectorTimes(telemetry.currentSectors);
+        telemetry.currentSectors = createEmptySectorTimes();
+        telemetry.currentLapStartedAt = crossingTime;
+        telemetry.completedLaps = Math.max(telemetry.completedLaps + 1, Math.min(Math.floor(boundaryDistance / track.length), totalLaps));
+      }
+
+      telemetry.currentSectorStartedAt = crossingTime;
+    }
+  }
+
+  syncLapTelemetryPosition(telemetry, currentTime, currentRaceDistance, track, totalLaps);
+  telemetry.lastUpdatedAt = currentTime;
+}
+
 function createCar(driver, index, random, track, { standingStart = false } = {}) {
   const gridDistance = GRID_FIRST_SLOT_DISTANCE - index * GRID_SLOT_SPACING;
   const start = pointAt(track, gridDistance);
@@ -123,6 +322,7 @@ function createCar(driver, index, random, track, { standingStart = false } = {})
     drsZoneId: null,
     drsZoneEnabled: false,
     timingHistory: [],
+    lapTelemetry: createLapTelemetry(track, 0, gridDistance),
     drsDetection: {},
     canAttack: true,
     trackState: start,
@@ -131,6 +331,12 @@ function createCar(driver, index, random, track, { standingStart = false } = {})
   };
 }
 
+function normalizeTotalLaps(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return MIN_TOTAL_LAPS;
+  return Math.max(MIN_TOTAL_LAPS, Math.floor(numeric));
+}
+
 function projectOntoAxis(points, axis) {
   let min = Infinity;
   let max = -Infinity;
@@ -345,6 +551,7 @@ function serializeCar(car, rank) {
     raceDistance: car.raceDistance,
     distanceMeters: simUnitsToMeters(car.raceDistance),
     lap: car.lap,
+    lapTelemetry: serializeLapTelemetry(car.lapTelemetry ?? createLapTelemetry({ length: 1 }, 0, 0)),
     gapAhead: car.gapAhead,
     gapAheadMeters: Number.isFinite(car.gapAhead) ? simUnitsToMeters(car.gapAhead) : Infinity,
     gapAheadSeconds: car.gapAheadSeconds,
@@ -373,7 +580,7 @@ export class F1RaceSimulation {
     this.trackSeed = this.track.seed ?? trackSeed;
     this.rules = { ...DEFAULT_RULES, ...rules };
     this.startLightsOutAt = this.rules.startLightCount * this.rules.startLightInterval + this.rules.startLightsOutHold;
-    this.totalLaps = totalLaps;
+    this.totalLaps = normalizeTotalLaps(totalLaps);
     this.time = 0;
     this.events = [];
     this.raceControl = {
@@ -409,6 +616,7 @@ export class F1RaceSimulation {
     }));
     this.recalculateRaceState({ updateDrs: false });
     this.cars.forEach((car) => resetTimingHistory(car, this.time));
+    this.cars.forEach((car) => resetLapTelemetry(car, this.time, this.track, this.totalLaps));
   }
 
   setSafetyCar(deployed) {
@@ -465,6 +673,7 @@ export class F1RaceSimulation {
     car.drsEligible = false;
     car.drsDetection = {};
     resetTimingHistory(car, this.time);
+    resetLapTelemetry(car, this.time, this.track, this.totalLaps);
     this.recalculateRaceState({ updateDrs: false });
     this.evaluateRaceFinish();
   }
@@ -687,12 +896,14 @@ export class F1RaceSimulation {
 
   recalculateRaceState({ updateDrs = true } = {}) {
     this.cars.forEach((car) => {
+      const previousRaceDistance = car.raceDistance;
       if (car.gridLocked) {
         const gridPoint = pointAt(this.track, car.gridDistance);
         car.trackState = nearestTrackState(this.track, car, car.gridDistance);
         car.progress = gridPoint.distance;
         car.raceDistance = car.gridDistance;
         car.lap = 1;
+        resetLapTelemetry(car, this.time, this.track, this.totalLaps);
         return;
       }
 
@@ -702,8 +913,10 @@ export class F1RaceSimulation {
       car.raceDistance = (car.raceDistance ?? previousProgress) + delta;
       car.progress = car.trackState.distance;
       car.lap = this.computeLap(car.raceDistance);
+      updateLapTelemetry(car, previousRaceDistance, this.time, this.track, this.totalLaps);
     });
 
+    updateSectorPerformance(this.cars);
     this.cars.forEach((car) => recordTimingSample(car, this.time));
 
     const ordered = this.orderedCars();

package/src/simulation/trackModel.js

@@ -346,6 +346,26 @@ function normalizeDrsZone(zone, totalLength) {
   };
 }
 
+function createTrackSectors(totalLength) {
+  return Array.from({ length: 3 }, (_, index) => {
+    const startRatio = index / 3;
+    const endRatio = (index + 1) / 3;
+    const start = totalLength * startRatio;
+    const end = totalLength * endRatio;
+
+    return {
+      index: index + 1,
+      id: `s${index + 1}`,
+      label: `S${index + 1}`,
+      start,
+      end,
+      startRatio,
+      endRatio,
+      length: end - start,
+    };
+  });
+}
+
 function scoreStraightWindow(samples, startIndex, windowSize) {
   let curvature = 0;
   for (let offset = 0; offset < windowSize; offset += 1) {
@@ -426,6 +446,7 @@ export function buildTrackModel(track = TRACK) {
     centerlineControls: controls,
     length: totalLength,
     samples: normalizedSamples,
+    sectors: createTrackSectors(totalLength),
     drsZones: (track.drsZones ?? deriveDrsZones(normalizedSamples, totalLength))
       .map((zone) => normalizeDrsZone(zone, totalLength)),
   };