@inventure71/paddockjs 2.0.0 → 3.0.0

package/src/environment/specs.js

@@ -1,7 +1,8 @@
 import { normalizeLookaheadMeters } from './observationOptions.js';
+import { effectiveSensorOptions } from './observations.js';
 import { normalizeRayOptions } from './sensors.js';
 
-const PHYSICAL_RAY_SURFACE_CHANNELS = Object.freeze(['kerb', 'illegalSurface']);
+const MODEL_RAY_SURFACE_CHANNELS = Object.freeze(['kerb', 'illegalSurface']);
 
 export function buildActionSpec(options) {
   const compounds = Array.isArray(options.rules?.modules?.tireStrategy?.compounds) &&
@@ -32,7 +33,7 @@ export function buildObservationSpec(options) {
     : normalizeLookaheadMeters(options.observation?.lookaheadMeters);
   const profile = options.observation?.profile ?? 'default';
   return {
-    version: profile === 'physical-driver' ? 4 : 2,
+    version: profile === 'physical-driver' ? 6 : 3,
     controlledDrivers: [...options.controlledDrivers],
     object: {
       profile,
@@ -45,12 +46,15 @@ export function buildObservationSpec(options) {
         { name: 'steeringAngleRadians', unit: 'rad' },
         { name: 'throttle', unit: 'normalized' },
         { name: 'brake', unit: 'normalized' },
+        { name: 'appliedControls', unit: 'nullable:normalized-controls' },
         { name: 'lateralG', unit: 'g' },
         { name: 'longitudinalG', unit: 'g' },
         { name: 'gripUsage', unit: 'ratio' },
         { name: 'slipAngleRadians', unit: 'rad' },
         { name: 'tractionLimited', unit: 'boolean' },
         { name: 'stabilityState', unit: 'label' },
+        { name: 'destroyed', unit: 'boolean' },
+        { name: 'destroyReason', unit: 'nullable:label' },
         { name: 'lap', unit: 'count' },
         { name: 'completedLaps', unit: 'count' },
         { name: 'lapProgressMeters', unit: 'm' },
@@ -99,40 +103,8 @@ export function buildObservationSpec(options) {
         { name: 'redFlag', unit: 'boolean' },
         { name: 'totalLaps', unit: 'count' },
       ],
-      rays: {
-        enabled: Boolean(rayOptions.enabled),
-        anglesDegrees: [...rayOptions.anglesDegrees],
-        lengthMeters: rayOptions.lengthMeters,
-        defaultLengthMeters: rayOptions.defaultLengthMeters,
-        rays: rayOptions.rays.map((ray) => ({ ...ray })),
-        channels: [...rayOptions.channels],
-        precision: rayOptions.precision,
-        track: {
-          distanceMeters: { unit: 'm', noHitValue: rayOptions.lengthMeters },
-          hit: { unit: 'boolean' },
-          kind: { values: ['exit', 'entry', null] },
-        },
-        roadEdge: {
-          distanceMeters: { unit: 'm', noHitValue: rayOptions.lengthMeters },
-          hit: { unit: 'boolean' },
-          kind: { values: ['exit', 'entry', null] },
-        },
-        kerb: surfaceRaySpec(rayOptions.lengthMeters),
-        illegalSurface: surfaceRaySpec(rayOptions.lengthMeters),
-        car: {
-          distanceMeters: { unit: 'm', noHitValue: rayOptions.lengthMeters },
-          hit: { unit: 'boolean' },
-          driverId: { nullable: true },
-          targetId: { nullable: true },
-          targetType: { values: ['car', 'replayGhost', null] },
-          relativeSpeedKph: { unit: 'kph' },
-        },
-      },
-      nearbyCars: {
-        enabled: Boolean(nearbyOptions.enabled),
-        maxCars: nearbyOptions.maxCars,
-        radiusMeters: nearbyOptions.radiusMeters,
-      },
+      rays: buildRayObjectSpec(rayOptions),
+      nearbyCars: buildNearbyObjectSpec(nearbyOptions),
       track: {
         lengthMeters: { unit: 'm' },
         widthMeters: { unit: 'm' },
@@ -149,6 +121,69 @@ export function buildObservationSpec(options) {
     vector: {
       schema: buildVectorSchema({ rayOptions, nearbyOptions, lookaheadMeters, profile }),
     },
+    perDriver: buildPerDriverObservationSpecs(options, { rayOptions, nearbyOptions, lookaheadMeters, profile }),
+  };
+}
+
+function buildPerDriverObservationSpecs(options, { rayOptions, nearbyOptions, lookaheadMeters, profile }) {
+  if (Object.keys(options.sensorsByDriver ?? {}).length === 0) return {};
+  const defaultSensors = { rays: rayOptions, nearbyCars: nearbyOptions };
+  return Object.fromEntries(options.controlledDrivers.map((driverId) => {
+    const sensors = effectiveSensorOptions(options, driverId, defaultSensors, true);
+    return [driverId, {
+      object: {
+        rays: buildRayObjectSpec(sensors.rays),
+        nearbyCars: buildNearbyObjectSpec(sensors.nearbyCars),
+      },
+      vector: {
+        schema: buildVectorSchema({
+          rayOptions: sensors.rays,
+          nearbyOptions: sensors.nearbyCars,
+          lookaheadMeters,
+          profile,
+        }),
+      },
+    }];
+  }));
+}
+
+function buildRayObjectSpec(rayOptions) {
+  return {
+    enabled: Boolean(rayOptions.enabled),
+    anglesDegrees: [...rayOptions.anglesDegrees],
+    lengthMeters: rayOptions.lengthMeters,
+    defaultLengthMeters: rayOptions.defaultLengthMeters,
+    rays: rayOptions.rays.map((ray) => ({ ...ray })),
+    channels: [...rayOptions.channels],
+    precision: rayOptions.precision,
+    track: {
+      distanceMeters: { unit: 'm', noHitValue: rayOptions.lengthMeters },
+      hit: { unit: 'boolean' },
+      kind: { values: ['exit', 'entry', null] },
+    },
+    roadEdge: {
+      distanceMeters: { unit: 'm', noHitValue: rayOptions.lengthMeters },
+      hit: { unit: 'boolean' },
+      kind: { values: ['exit', 'entry', null] },
+    },
+    kerb: surfaceRaySpec(rayOptions.lengthMeters),
+    illegalSurface: surfaceRaySpec(rayOptions.lengthMeters),
+    car: {
+      distanceMeters: { unit: 'm', noHitValue: rayOptions.lengthMeters },
+      hit: { unit: 'boolean' },
+      driverId: { nullable: true },
+      targetId: { nullable: true },
+      targetType: { values: ['car', 'replayGhost', null] },
+      relativeSpeedKph: { unit: 'kph' },
+    },
+  };
+}
+
+function buildNearbyObjectSpec(nearbyOptions) {
+  return {
+    enabled: Boolean(nearbyOptions.enabled),
+    maxCars: nearbyOptions.maxCars,
+    radiusMeters: nearbyOptions.radiusMeters,
   };
 }
 
@@ -193,6 +228,7 @@ function buildVectorSchema({ rayOptions, nearbyOptions, lookaheadMeters, profile
         { name: `contactPatches[${index}].surfaceCode`, scale: 'surface-code' },
         { name: `contactPatches[${index}].onLegalSurface`, scale: 'boolean' },
         { name: `contactPatches[${index}].signedOffsetMeters`, unit: 'm', scale: 'fixed:meters' },
+        { name: `contactPatches[${index}].crossTrackErrorMeters`, unit: 'm', scale: 'fixed:meters' },
       );
     }
   }
@@ -212,15 +248,16 @@ function buildVectorSchema({ rayOptions, nearbyOptions, lookaheadMeters, profile
         { name: `rays[${index}].car.distanceRatio`, scale: '0..1' },
         { name: `rays[${index}].car.hit`, scale: 'boolean' },
         { name: `rays[${index}].car.relativeSpeedKph`, unit: 'kph', scale: 'fixed:200' },
+        { name: `rays[${index}].car.targetTypeReplayGhost`, scale: 'boolean' },
       );
-      if (includePhysicalDriverSenses) {
-        PHYSICAL_RAY_SURFACE_CHANNELS.forEach((channel) => {
+      MODEL_RAY_SURFACE_CHANNELS.forEach((channel) => {
+        if (rayOptions.channels?.includes?.(channel)) {
           schema.push(
             { name: `rays[${index}].${channel}.distanceRatio`, scale: '0..1' },
             { name: `rays[${index}].${channel}.hit`, scale: 'boolean' },
           );
-        });
-      }
+        }
+      });
     });
   }
   if (nearbyOptions.enabled) {
@@ -234,6 +271,7 @@ function buildVectorSchema({ rayOptions, nearbyOptions, lookaheadMeters, profile
         { name: `nearbyCars[${index}].relativeHeadingRadians`, unit: 'rad', scale: 'fixed:pi' },
         { name: `nearbyCars[${index}].ahead`, scale: 'boolean' },
         { name: `nearbyCars[${index}].sameLap`, scale: 'boolean' },
+        { name: `nearbyCars[${index}].entityTypeReplayGhost`, scale: 'boolean' },
       );
       if (includePhysicalDriverSenses) {
         schema.push(

package/src/index.d.ts

@@ -2,6 +2,7 @@ import type {
   PaddockActionSpec,
   PaddockDriverControllerLoop,
   PaddockDriverControllerLoopOptions,
+  PaddockEnvironmentOptions,
   PaddockObservationSpec,
   PaddockParticipantInteraction as EnvPaddockParticipantInteraction,
   PaddockParticipantInteractionsOptions as EnvPaddockParticipantInteractionsOptions,
@@ -23,7 +24,7 @@ export type {
 } from './environment/index.js';
 
 export type TireCompound = 'S' | 'M' | 'H';
-export type PaddockPhysicsMode = 'arcade' | 'simulator';
+export type PaddockPhysicsMode = 'arcade' | 'advanced';
 export type PaddockWarmupPolicy = 'config-change' | 'always' | 'never';
 export type PaddockProceduralTrackProfile = 'race' | 'training-short' | 'training-medium' | 'training-technical';
 
@@ -81,11 +82,12 @@ export type PaddockPitIntentRequest = PaddockPitIntent | {
   pitTargetCompound?: TireCompound | string;
   targetTire?: TireCompound | string;
 };
-export type CameraMode = 'overview' | 'leader' | 'selected' | 'show-all' | 'pit';
+export type CameraMode = 'overview' | 'leader' | 'selected' | 'driver' | 'show-all' | 'pit';
 export type RaceBannerMode = 'project' | 'radio' | 'hidden';
 export type RaceBannerEnabledMode = 'project' | 'radio';
 export type RaceDataBannerSize = 'auto' | 'custom';
 export type TimingTowerVerticalFit = 'expand-race-view' | 'scroll';
+export type TimingGapMode = 'interval' | 'leader';
 export type LayoutPreset = 'standard' | 'left-tower-overlay';
 export type CameraControlsMode = 'embedded' | 'external' | false;
 export type PaddockPresetName = 'dashboard' | 'timing-overlay' | 'compact-race' | 'full-dashboard';
@@ -111,6 +113,7 @@ export interface TeamData {
   name?: string;
   color?: string;
   icon?: string;
+  theme?: PaddockThemeSelector;
   pitCrew?: PaddockPitCrewStats;
   pitCrewStats?: PaddockPitCrewStats;
 }
@@ -254,12 +257,84 @@ export interface NormalizedSimulatorDriver extends SimulatorDriver {
   };
 }
 
-export interface F1SimulatorTheme {
-  accentColor?: string;
-  greenColor?: string;
-  yellowColor?: string;
-  timingTowerMaxWidth?: string;
-  raceViewMinHeight?: string;
+export type PaddockThemeMode = 'dark' | 'light' | 'system';
+export type PaddockThemeSelector = 'default' | 'active' | 'selectedTeam' | 'team' | `team:${string}` | string;
+export type PaddockThemeTokenValue = string | { light?: string; dark?: string };
+export type PaddockThemeTokenName =
+  | 'primary'
+  | 'primaryText'
+  | 'secondary'
+  | 'secondaryText'
+  | 'surface'
+  | 'surfaceRaised'
+  | 'surfacePanel'
+  | 'text'
+  | 'mutedText'
+  | 'border'
+  | 'success'
+  | 'warning'
+  | 'danger'
+  | 'info'
+  | 'yellowFlag'
+  | 'greenFlag'
+  | 'redFlag'
+  | 'safetyCar'
+  | 'drsActive'
+  | 'pitLane'
+  | 'track'
+  | 'trackEdge'
+  | 'timingTowerMaxWidth'
+  | 'raceViewMinHeight';
+
+export interface F1SimulatorThemeTokens extends Partial<Record<PaddockThemeTokenName, PaddockThemeTokenValue>> {
+  /** Compatibility alias for `primary`. Prefer `tokens.primary` in new 3.0.0 code. */
+  accentColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `greenFlag`. Prefer `tokens.greenFlag` or `tokens.success`. */
+  greenColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `yellowFlag`. Prefer `tokens.yellowFlag` or `tokens.warning`. */
+  yellowColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `info`. */
+  blueColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `redFlag`. Prefer `tokens.redFlag` or `tokens.danger`. */
+  raceControlRedColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `surface`. */
+  surfaceColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `surfaceRaised`. */
+  surfaceRaisedColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `surfacePanel`. */
+  surfacePanelColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `border`. */
+  lineColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `border`. */
+  lineStrongColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `text`. */
+  textColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `mutedText`. */
+  mutedTextColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `track`. */
+  trackColor?: PaddockThemeTokenValue;
+  /** Compatibility alias for `trackEdge`. */
+  trackEdgeColor?: PaddockThemeTokenValue;
+}
+
+export interface F1SimulatorThemePackage extends F1SimulatorThemeTokens {
+  extends?: string;
+  tokens?: F1SimulatorThemeTokens;
+  components?: Record<string, Partial<Record<string, PaddockThemeTokenName>>>;
+  light?: F1SimulatorThemeTokens;
+  dark?: F1SimulatorThemeTokens;
+}
+
+export interface F1SimulatorTheme extends Omit<F1SimulatorThemePackage, 'components'> {
+  mode?: PaddockThemeMode;
+  use?: string;
+  themes?: Record<string, F1SimulatorThemePackage>;
+  componentThemes?: Record<string, PaddockThemeSelector | { theme: PaddockThemeSelector }>;
+  teamThemes?: Record<string, PaddockThemeSelector | { theme: PaddockThemeSelector }>;
+  components?: Record<
+    string,
+    PaddockThemeSelector | { theme: PaddockThemeSelector } | Partial<Record<string, PaddockThemeTokenName>>
+  >;
 }
 
 export interface F1SimulatorUiOptions {
@@ -277,10 +352,15 @@ export interface F1SimulatorUiOptions {
   };
   raceDataBannerSize?: RaceDataBannerSize;
   raceDataTelemetryDetail?: boolean;
+  driverCamera?: boolean;
   penaltyBanners?: boolean;
   timingPenaltyBadges?: boolean;
   simulationSpeedControl?: boolean;
   timingTowerVerticalFit?: TimingTowerVerticalFit;
+  timingGapMode?: TimingGapMode;
+  timingGapModeToggle?: boolean;
+  timingEntryVerticalPadding?: number;
+  responsiveNarrowLayout?: boolean;
 }
 
 export interface F1SimulatorDebugOptions {
@@ -638,6 +718,18 @@ export interface WheelSurfaceSnapshot {
   fullyOutsideWhiteLine: boolean;
 }
 
+export interface CarTrackStateSnapshot {
+  distance: number;
+  signedOffset: number;
+  crossTrackError: number;
+  surface: string;
+  inPitLane: boolean;
+  pitLanePart: 'entry' | 'fast-lane' | 'working-lane' | 'exit' | 'service-box' | 'garage-box' | null;
+  pitBoxId: string | null;
+  curvature: number;
+  heading: number;
+}
+
 export interface CarSnapshot {
   id: string;
   rank: number | null;
@@ -648,6 +740,8 @@ export interface CarSnapshot {
   tire: TireCompound;
   interaction?: PaddockParticipantInteraction;
   lap: number;
+  velocityX?: number | null;
+  velocityY?: number | null;
   speedKph: number;
   finishRank?: number | null;
   status?: 'racing' | 'waved-flag' | 'destroyed' | string;
@@ -681,6 +775,7 @@ export interface CarSnapshot {
   stabilityState?: PaddockStabilityState;
   signedOffset?: number;
   crossTrackError?: number;
+  trackState?: CarTrackStateSnapshot | null;
   inPitLane?: boolean;
   wheels?: WheelSurfaceSnapshot[];
   pitLanePart?: 'entry' | 'fast-lane' | 'working-lane' | 'exit' | 'service-box' | 'garage-box' | null;
@@ -789,6 +884,7 @@ export interface F1SimulatorExpertOptions {
   enabled: boolean;
   controlledDrivers: string[];
   frameSkip?: number;
+  episode?: PaddockEnvironmentOptions['episode'];
   visualizeSensors?: boolean | {
     rays?: boolean;
     drivers?: 'selected' | 'all' | string[];
@@ -860,7 +956,6 @@ export interface F1SimulatorOptions extends F1SimulatorCallbacks {
   seed?: number;
   trackSeed?: number;
   trackGeneration?: PaddockProceduralTrackOptions;
-  trackQueryIndex?: boolean;
   warmup?: PaddockWarmupOptions | boolean;
   totalLaps?: number;
   physicsMode?: PaddockPhysicsMode;
@@ -887,6 +982,7 @@ export interface MountRaceCanvasOptions {
   includeTimingTower?: boolean;
   includeTelemetrySectorBanner?: boolean;
   timingTowerVerticalFit?: TimingTowerVerticalFit;
+  responsiveNarrowLayout?: boolean;
 }
 
 export interface MountTelemetryPanelOptions {
@@ -897,6 +993,7 @@ export interface MountRaceTelemetryDrawerOptions {
   timingTowerVerticalFit?: TimingTowerVerticalFit;
   drawerInitiallyOpen?: boolean;
   raceDataTelemetryDetail?: boolean;
+  responsiveNarrowLayout?: boolean;
 }
 
 export interface F1MountedSimulator {
@@ -914,6 +1011,9 @@ export interface F1MountedSimulator {
   getPitIntent(driverId: string): PaddockPitIntent;
   getPitTargetCompound(driverId: string): TireCompound | string | null;
   getSimulationSpeed(): number;
+  setTimingGapMode(mode: TimingGapMode): TimingGapMode;
+  getTimingGapMode(): TimingGapMode;
+  toggleTimingGapMode(): TimingGapMode;
   servePenalty(penaltyId: string): PaddockPenaltyEntry | null;
   cancelPenalty(penaltyId: string): PaddockPenaltyEntry | null;
   getSnapshot(): RaceSnapshot | null;
@@ -951,6 +1051,9 @@ export interface PaddockSimulatorController {
   getPitIntent(driverId: string): PaddockPitIntent;
   getPitTargetCompound(driverId: string): TireCompound | string | null;
   getSimulationSpeed(): number;
+  setTimingGapMode(mode: TimingGapMode): TimingGapMode;
+  getTimingGapMode(): TimingGapMode;
+  toggleTimingGapMode(): TimingGapMode;
   servePenalty(penaltyId: string): PaddockPenaltyEntry | null;
   cancelPenalty(penaltyId: string): PaddockPenaltyEntry | null;
   getSnapshot(): RaceSnapshot | null;

package/src/index.js

@@ -1,6 +1,7 @@
 import './styles.css';
 import { F1SimulatorApp } from './app/F1SimulatorApp.js';
 import { resolveF1SimulatorOptions } from './config/defaultOptions.js';
+import { mergeRestartOptions } from './config/restartOptions.js';
 import { createF1SimulatorShell } from './ui/shellTemplate.js';
 export {
   createPaddockSimulator,
@@ -51,38 +52,6 @@ function assertMountRoot(root) {
   }
 }
 
-function mergeRestartOptions(previousOptions, nextOptions) {
-  const resetFromPreset = Object.hasOwn(nextOptions, 'preset');
-  const previousUi = resetFromPreset ? {} : previousOptions.ui;
-  const previousTheme = resetFromPreset ? {} : previousOptions.theme;
-  return {
-    ...previousOptions,
-    ...nextOptions,
-    ui: {
-      ...previousUi,
-      ...(nextOptions.ui ?? {}),
-      raceDataBanners: {
-        ...(previousUi.raceDataBanners ?? {}),
-        ...(nextOptions.ui?.raceDataBanners ?? {}),
-      },
-    },
-    theme: {
-      ...previousTheme,
-      ...(nextOptions.theme ?? {}),
-    },
-    assets: {
-      ...previousOptions.assets,
-      ...(nextOptions.assets ?? {}),
-      trackTextures: {
-        ...previousOptions.assets.trackTextures,
-        ...(nextOptions.assets?.trackTextures ?? {}),
-      },
-    },
-    drivers: nextOptions.drivers ?? previousOptions.drivers,
-    entries: nextOptions.entries ?? previousOptions.entries,
-  };
-}
-
 export async function mountF1Simulator(root, options = {}) {
   assertMountRoot(root);
 
@@ -92,6 +61,21 @@ export async function mountF1Simulator(root, options = {}) {
   const app = new F1SimulatorApp(shell, resolvedOptions);
   await app.init();
 
+  const syncResolvedTimingGapMode = (timingGapMode) => {
+    resolvedOptions = {
+      ...resolvedOptions,
+      ui: {
+        ...resolvedOptions.ui,
+        timingGapMode,
+      },
+    };
+    return timingGapMode;
+  };
+  const syncResolvedRuntimeOptions = () => {
+    syncResolvedTimingGapMode(app.getTimingGapMode());
+    return resolvedOptions;
+  };
+
   return {
     get expert() {
       return app.expert ?? null;
@@ -101,7 +85,7 @@ export async function mountF1Simulator(root, options = {}) {
       root.innerHTML = '';
     },
     restart(nextOptions = {}) {
-      const nextResolvedOptions = resolveF1SimulatorOptions(mergeRestartOptions(resolvedOptions, nextOptions));
+      const nextResolvedOptions = resolveF1SimulatorOptions(mergeRestartOptions(syncResolvedRuntimeOptions(), nextOptions));
       app.restart(nextResolvedOptions);
       resolvedOptions = nextResolvedOptions;
     },
@@ -139,6 +123,15 @@ export async function mountF1Simulator(root, options = {}) {
     getSimulationSpeed() {
       return app.simulationSpeed;
     },
+    setTimingGapMode(mode) {
+      return syncResolvedTimingGapMode(app.setTimingGapMode(mode));
+    },
+    getTimingGapMode() {
+      return app.getTimingGapMode();
+    },
+    toggleTimingGapMode() {
+      return syncResolvedTimingGapMode(app.toggleTimingGapMode());
+    },
     servePenalty(penaltyId) {
       return app.servePenalty(penaltyId);
     },

package/src/simulation/driver/driverController.js

@@ -37,7 +37,7 @@ export function decideDriverControls({ car, orderIndex, race }) {
 }
 
 function shouldStabilizeSimulatorCar(car, race) {
-  if (race.physicsMode !== 'simulator') return false;
+  if (race.physicsMode !== 'advanced') return false;
   const gripUsage = car.gripUsage ?? 0;
   const slipAngle = Math.abs(car.slipAngleRadians ?? 0);
   const edgeDistance = race.track.width / 2 - VEHICLE_LIMITS.carWidth * 2.25;

package/src/simulation/driver/edgeRecovery.js

@@ -5,7 +5,7 @@ import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
 import { REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX } from './driverControlConstants.js';
 
 export function calculateTrackEdgeGuard(car, race) {
-  const simulatorMode = race.physicsMode === 'simulator';
+  const simulatorMode = race.physicsMode === 'advanced';
   const trackLimit = race.track.width / 2;
   const halfCarWidth = VEHICLE_LIMITS.carWidth / 2;
   const wholeCarOutsideLimit = trackLimit + halfCarWidth;

package/src/simulation/driver/racingControls.js

@@ -10,7 +10,7 @@ import { calculateActualOverlapPenalty, calculatePlannedTrafficPenalty, planRaci
 import { analyzeTrackEdgeMotion } from './recoveryDynamics.js';
 
 export function decideRacingControls(car, orderIndex, race) {
-  if (race.physicsMode === 'simulator') {
+  if (race.physicsMode === 'advanced') {
     return decideSimulatorRacingControls(car, orderIndex, race);
   }
   return decideArcadeRacingControls(car, orderIndex, race);
@@ -389,7 +389,7 @@ export function calculateRacingLineOffset(car, race, lookahead, curvature, edgeG
   if (turnDirection === 0) return 0;
 
   const aggression = car.aggression ?? car.personality?.baseAggression ?? 0.5;
-  const simulatorMode = race.physicsMode === 'simulator';
+  const simulatorMode = race.physicsMode === 'advanced';
   const safeEdge = race.track.width / 2 - VEHICLE_LIMITS.carWidth *
     (simulatorMode ? 2.05 - aggression * 0.08 : 1.15 - aggression * 0.12);
   const apexOffset = turnDirection * safeEdge *

package/src/simulation/driver/rejoinControls.js

@@ -8,7 +8,7 @@ import { VEHICLE_LIMITS } from '../vehicle/vehiclePhysics.js';
 import { analyzeTrackEdgeMotion } from './recoveryDynamics.js';
 
 export function decideRejoinControls(car, race) {
-  if (race.physicsMode === 'simulator') {
+  if (race.physicsMode === 'advanced') {
     return decideSimulatorRejoinControls(car, race);
   }
   return decideArcadeRejoinControls(car, race);
@@ -103,7 +103,7 @@ export function decideSimulatorRejoinControls(car, race) {
 }
 
 function decideRejoinControlsForMode(car, race, profile) {
-  const simulatorMode = race.physicsMode === 'simulator';
+  const simulatorMode = race.physicsMode === 'advanced';
   const lookahead = clamp(car.speed * (profile.simulatorMode ? 0.58 : 0.72) + REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_BASE, REJOIN_LOOKAHEAD_MAX);
   const edgeMotion = analyzeTrackEdgeMotion(car, race);
   const lowSpeedOffTrack = !car.trackState.onTrack && car.speed < kphToSimSpeed(24);

package/src/simulation/pit/pitFlow.js

@@ -17,6 +17,7 @@ import {
   isPitServiceQueueOccupied,
   releasePitQueue,
 } from './pitService.js';
+import { syncPitCarKinematics } from './pitKinematics.js';
 import {
   createPitApproachPoints,
   createRoute,
@@ -209,6 +210,10 @@ export function advancePitStopCar(sim, car, delta) {
     car.speed = 0;
     car.throttle = 0;
     car.brake = 1;
+    car.steeringAngle = 0;
+    car.yawRate = 0;
+    car.turnRadius = Infinity;
+    syncPitCarKinematics(car, { physicsMode: sim.physicsMode });
     applyWheelSurfaceState(car, sim.track);
     car.progress = car.trackState.distance;
     car.raceDistance = getPitBoxRaceDistance(sim, stop, {

package/src/simulation/pit/pitKinematics.js

@@ -0,0 +1,24 @@
+export function syncPitCarKinematics(car, { physicsMode = 'arcade' } = {}) {
+  const speed = Number.isFinite(car.speed) ? car.speed : 0;
+  const heading = Number.isFinite(car.heading) ? car.heading : 0;
+  if (physicsMode === 'advanced') {
+    car.velocityX = Math.cos(heading) * speed;
+    car.velocityY = Math.sin(heading) * speed;
+  } else {
+    car.velocityX = null;
+    car.velocityY = null;
+  }
+  car.appliedControls = {
+    steering: car.steeringAngle ?? 0,
+    throttle: car.throttle ?? 0,
+    brake: car.brake ?? 0,
+  };
+  car.lateralAcceleration = 0;
+  car.longitudinalAcceleration = 0;
+  car.lateralG = 0;
+  car.longitudinalG = 0;
+  car.gripUsage = 0;
+  car.slipAngleRadians = 0;
+  car.tractionLimited = false;
+  car.stabilityState = 'stable';
+}

package/src/simulation/pit/pitQueue.js

@@ -1,5 +1,6 @@
 import { applyWheelSurfaceState } from '../vehicle/wheelSurface.js';
 import { createRoute, routePoint } from './pitRouting.js';
+import { syncPitCarKinematics } from './pitKinematics.js';
 import { PIT_QUEUE_RELEASE_SPEED } from './pitServiceConstants.js';
 import { getPitBoxRaceDistance } from './pitOccupancy.js';
 
@@ -17,6 +18,10 @@ export function beginPitQueue(sim, car, box) {
   car.speed = 0;
   car.throttle = 0;
   car.brake = 1;
+  car.steeringAngle = 0;
+  car.yawRate = 0;
+  car.turnRadius = Infinity;
+  syncPitCarKinematics(car, { physicsMode: sim.physicsMode });
   applyWheelSurfaceState(car, sim.track);
   car.progress = car.trackState.distance;
   car.raceDistance = getPitBoxRaceDistance(sim, stop, {

package/src/simulation/pit/pitRouteMovement.js

@@ -8,6 +8,7 @@ import {
   routeLimiterActiveAt,
   sampleRoute,
 } from './pitRouting.js';
+import { syncPitCarKinematics } from './pitKinematics.js';
 import { completePitPenaltyService } from './pitPenaltyService.js';
 import { completePitService } from './pitTireService.js';
 import { getPitBoxRaceDistance, getPitStopBox } from './pitOccupancy.js';
@@ -51,6 +52,7 @@ export function applyPitRoutePosition(sim, car, delta) {
       VEHICLE_LIMITS.maxSteer,
     );
     car.turnRadius = Math.abs(car.yawRate) < 0.001 ? Infinity : car.speed / Math.abs(car.yawRate);
+    syncPitCarKinematics(car, { physicsMode: sim.physicsMode });
     stop.routeProgress = nextProgress;
     const routeAmount = route.length > 0 ? stop.routeProgress / route.length : 1;
     car.raceDistance = stop.routeStartRaceDistance +
@@ -111,6 +113,7 @@ export function applyPitRoutePosition(sim, car, delta) {
     VEHICLE_LIMITS.maxSteer,
   );
   car.turnRadius = Math.abs(car.yawRate) < 0.001 ? Infinity : car.speed / Math.abs(car.yawRate);
+  syncPitCarKinematics(car, { physicsMode: sim.physicsMode });
   applyWheelSurfaceState(car, sim.track);
   stop.routeProgress = nextProgress;
   const routeAmount = route.length > 0 ? stop.routeProgress / route.length : 1;
@@ -148,6 +151,10 @@ export function advancePitService(sim, car, delta) {
   car.speed = 0;
   car.throttle = 0;
   car.brake = 1;
+  car.steeringAngle = 0;
+  car.yawRate = 0;
+  car.turnRadius = Infinity;
+  syncPitCarKinematics(car, { physicsMode: sim.physicsMode });
   applyWheelSurfaceState(car, sim.track);
   car.progress = car.trackState.distance;
   car.raceDistance = getPitBoxRaceDistance(sim, stop, box);

package/src/simulation/pit/pitRouting.js

@@ -285,11 +285,9 @@ export function nearestDistanceOnRoute(route, position, previousDistance = 0) {
 export function createPitApproachPoints(track, car, pitLane, entryRaceDistance) {
   const currentDistance = car.raceDistance ?? entryRaceDistance - PIT_ENTRY_APPROACH_DISTANCE;
   const remaining = Math.max(0, entryRaceDistance - currentDistance);
-  const currentState = nearestTrackState(track, car, car.progress, { indexMode: 'legacy' });
+  const currentState = nearestTrackState(track, car, car.progress);
   const startOffset = currentState.inPitLane ? 0 : currentState.signedOffset ?? 0;
-  const entryConnectState = nearestTrackState(track, pitLane.entry.trackConnectPoint, pitLane.entry.trackDistance, {
-    indexMode: 'legacy',
-  });
+  const entryConnectState = nearestTrackState(track, pitLane.entry.trackConnectPoint, pitLane.entry.trackDistance);
   const targetOffset = entryConnectState.signedOffset ?? 0;
   const points = [routePoint(car, car.heading)];
   const straightDistance = remaining > metersToSimUnits(14)