@inventure71/paddockjs 0.3.0 → 2.0.0

package/src/index.d.ts

@@ -1,9 +1,87 @@
-import type { PaddockActionSpec, PaddockObservationSpec } from './environment/index.js';
-
-export type { PaddockActionSpec, PaddockObservationSpec } from './environment/index.js';
+import type {
+  PaddockActionSpec,
+  PaddockDriverControllerLoop,
+  PaddockDriverControllerLoopOptions,
+  PaddockObservationSpec,
+  PaddockParticipantInteraction as EnvPaddockParticipantInteraction,
+  PaddockParticipantInteractionsOptions as EnvPaddockParticipantInteractionsOptions,
+  PaddockParticipantInteractionOverride as EnvPaddockParticipantInteractionOverride,
+  PaddockParticipantInteractionProfile as EnvPaddockParticipantInteractionProfile,
+  PaddockReplayGhostOptions as EnvPaddockReplayGhostOptions,
+  PaddockReplayGhostSnapshot as EnvPaddockReplayGhostSnapshot,
+  PaddockReplayGhostTrajectorySample as EnvPaddockReplayGhostTrajectorySample,
+} from './environment/index.js';
+
+export type {
+  PaddockActionSpec,
+  PaddockControllerRuntime,
+  PaddockDriverController,
+  PaddockDriverControllerContext,
+  PaddockDriverControllerLoop,
+  PaddockDriverControllerLoopOptions,
+  PaddockObservationSpec,
+} from './environment/index.js';
 
 export type TireCompound = 'S' | 'M' | 'H';
-export type CameraMode = 'overview' | 'leader' | 'selected' | 'show-all';
+export type PaddockPhysicsMode = 'arcade' | 'simulator';
+export type PaddockWarmupPolicy = 'config-change' | 'always' | 'never';
+export type PaddockProceduralTrackProfile = 'race' | 'training-short' | 'training-medium' | 'training-technical';
+
+export interface PaddockWarmupOptions {
+  enabled?: boolean;
+  policy?: PaddockWarmupPolicy;
+  steps?: number;
+}
+
+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 type PaddockStabilityState = 'stable' | 'understeer' | 'oversteer' | 'spin-risk' | 'destroyed';
+export type PaddockPitIntent = 0 | 1 | 2;
+export type PaddockPitIntentRequest = PaddockPitIntent | {
+  intent?: PaddockPitIntent;
+  pitIntent?: PaddockPitIntent;
+  targetCompound?: TireCompound | string;
+  compound?: TireCompound | string;
+  pitCompound?: TireCompound | string;
+  pitTargetCompound?: TireCompound | string;
+  targetTire?: TireCompound | string;
+};
+export type CameraMode = 'overview' | 'leader' | 'selected' | 'show-all' | 'pit';
 export type RaceBannerMode = 'project' | 'radio' | 'hidden';
 export type RaceBannerEnabledMode = 'project' | 'radio';
 export type RaceDataBannerSize = 'auto' | 'custom';
@@ -13,6 +91,13 @@ 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 type PaddockParticipantInteractionProfile = EnvPaddockParticipantInteractionProfile;
+export type PaddockParticipantInteraction = EnvPaddockParticipantInteraction;
+export type PaddockParticipantInteractionOverride = EnvPaddockParticipantInteractionOverride;
+export type PaddockParticipantInteractionsOptions = EnvPaddockParticipantInteractionsOptions;
+export type PaddockReplayGhostTrajectorySample = EnvPaddockReplayGhostTrajectorySample;
+export type PaddockReplayGhostOptions = EnvPaddockReplayGhostOptions;
+export type PaddockReplayGhostSnapshot = EnvPaddockReplayGhostSnapshot;
 
 export interface CustomField {
   label: string;
@@ -26,6 +111,14 @@ export interface TeamData {
   name?: string;
   color?: string;
   icon?: string;
+  pitCrew?: PaddockPitCrewStats;
+  pitCrewStats?: PaddockPitCrewStats;
+}
+
+export interface PaddockPitCrewStats {
+  speed?: number;
+  consistency?: number;
+  reliability?: number;
 }
 
 export interface SimulatorDriver {
@@ -184,9 +277,16 @@ export interface F1SimulatorUiOptions {
   };
   raceDataBannerSize?: RaceDataBannerSize;
   raceDataTelemetryDetail?: boolean;
+  penaltyBanners?: boolean;
+  timingPenaltyBadges?: boolean;
+  simulationSpeedControl?: boolean;
   timingTowerVerticalFit?: TimingTowerVerticalFit;
 }
 
+export interface F1SimulatorDebugOptions {
+  physicsModeIndicator?: boolean;
+}
+
 export interface TrackTextureAssets {
   asphalt?: string;
 }
@@ -206,9 +306,113 @@ export interface TrackSnapshot {
   width?: number;
   length?: number;
   sectors?: TrackSectorSnapshot[];
+  pitLane?: PitLaneSnapshot;
   [key: string]: unknown;
 }
 
+export interface TrackPointSnapshot {
+  x: number;
+  y: number;
+  heading?: number;
+  distance?: number;
+}
+
+export interface PitLaneSnapshot {
+  enabled: boolean;
+  side: -1 | 1;
+  width: number;
+  offset?: number;
+  boxCount: number;
+  teamCount: number;
+  boxesPerTeam: number;
+  entry: {
+    trackDistance: number;
+    distanceFromStart: number;
+    trackPoint: TrackPointSnapshot;
+    edgePoint: TrackPointSnapshot;
+    trackConnectPoint: TrackPointSnapshot;
+    lanePoint: TrackPointSnapshot;
+    roadCenterline: TrackPointSnapshot[];
+    connector: TrackPointSnapshot[];
+  };
+  exit: {
+    trackDistance: number;
+    distanceFromStart: number;
+    trackPoint: TrackPointSnapshot;
+    edgePoint: TrackPointSnapshot;
+    trackConnectPoint: TrackPointSnapshot;
+    lanePoint: TrackPointSnapshot;
+    roadCenterline: TrackPointSnapshot[];
+    connector: TrackPointSnapshot[];
+  };
+  mainLane: {
+    start: TrackPointSnapshot;
+    end: TrackPointSnapshot;
+    points: TrackPointSnapshot[];
+    length: number;
+    heading: number;
+  };
+  fastLane?: {
+    offset: number;
+    width: number;
+  };
+  workingLane?: {
+    start: TrackPointSnapshot;
+    end: TrackPointSnapshot;
+    points: TrackPointSnapshot[];
+    offset: number;
+    width: number;
+  };
+  serviceNormal: { x: number; y: number };
+  teams?: PitTeamSnapshot[];
+  boxes: PitBoxSnapshot[];
+  serviceAreas?: PitServiceAreaSnapshot[];
+}
+
+export interface PitTeamSnapshot {
+  id: string;
+  name: string;
+  color: string;
+  index: number;
+  boxIds: string[];
+  serviceAreaId?: string | null;
+}
+
+export interface PitBoxSnapshot {
+  id: string;
+  index: number;
+  teamIndex: number;
+  teamBoxIndex: number;
+  teamId?: string;
+  teamName?: string;
+  teamColor?: string;
+  distanceAlongLane: number;
+  laneTarget: TrackPointSnapshot;
+  center: TrackPointSnapshot;
+  length: number;
+  depth: number;
+  corners: TrackPointSnapshot[];
+}
+
+export interface PitServiceAreaSnapshot {
+  id: string;
+  index: number;
+  teamIndex: number;
+  teamId?: string;
+  teamName?: string;
+  teamColor?: string;
+  distanceAlongLane: number;
+  queueDistanceAlongLane: number;
+  laneTarget: TrackPointSnapshot;
+  center: TrackPointSnapshot;
+  queuePoint: TrackPointSnapshot;
+  length: number;
+  depth: number;
+  corners: TrackPointSnapshot[];
+  queueCorners: TrackPointSnapshot[];
+  garageBoxIds: string[];
+}
+
 export interface TrackSectorSnapshot {
   index: number;
   id: string;
@@ -227,6 +431,8 @@ export interface LapTelemetrySnapshot {
   currentSectorElapsed: number | null;
   currentSectorProgress: number | null;
   currentSectors: Array<number | null>;
+  sectorProgress: Array<number | null>;
+  liveSectors: Array<number | null>;
   sectorPerformance: {
     current: Array<SectorPerformanceStatus | null>;
     last: Array<SectorPerformanceStatus | null>;
@@ -239,28 +445,250 @@ export interface LapTelemetrySnapshot {
   completedLaps: number;
 }
 
+export interface PitStopSnapshot {
+  status: 'pending' | 'entering' | 'queued' | 'servicing' | 'exiting' | 'completed';
+  intent: PaddockPitIntent;
+  phase: 'entry' | 'queue' | 'queue-release' | 'penalty' | 'service' | 'exit' | null;
+  boxIndex: number;
+  boxId: string;
+  garageBoxIndex?: number | null;
+  garageBoxId?: string | null;
+  teamId?: string | null;
+  teamColor?: string | null;
+  stopsCompleted: number;
+  queueingForService?: boolean;
+  plannedRaceDistance: number | null;
+  entryRaceDistance: number | null;
+  serviceRemainingSeconds: number | null;
+  penaltyServiceRemainingSeconds: number | null;
+  penaltyServiceTotalSeconds: number | null;
+  servingPenaltyIds: string[];
+  targetTire?: TireCompound | string | null;
+  serviceProfile?: {
+    baseSeconds: number;
+    seconds: number;
+    perfect: boolean;
+    variabilityEnabled: boolean;
+    teamId?: string | null;
+    pitCrew: Required<PaddockPitCrewStats>;
+    speedDeltaSeconds: number;
+    consistencyDeltaSeconds: number;
+    issueDelaySeconds: number;
+    issue?: string | null;
+  } | null;
+}
+
 export interface RaceEvent {
   type: string;
   at?: number;
+  firstShapeId?: string;
+  secondShapeId?: string;
+  contactType?: 'body-body' | 'body-wheel' | 'wheel-body' | 'wheel-wheel' | string;
+  depth?: number;
+  timeOfImpact?: number;
+  [key: string]: unknown;
+}
+
+export type PaddockRulesetName = 'paddock' | 'custom' | 'grandPrix2025' | 'fia2025';
+
+export interface PaddockPitStopRules {
+  enabled?: boolean;
+  pitLaneSpeedLimitKph?: number;
+  defaultStopSeconds?: number;
+  variability?: {
+    enabled?: boolean;
+    perfect?: boolean;
+    speedImpactSeconds?: number;
+    consistencyJitterSeconds?: number;
+    issueChance?: number;
+    issueMaxDelaySeconds?: number;
+  };
+  maxConcurrentPitLaneCars?: number;
+  minimumPitLaneGapMeters?: number;
+  doubleStacking?: boolean;
+  tirePitRequestThresholdPercent?: number;
+  tirePitCommitThresholdPercent?: number;
+}
+
+export interface PaddockTireStrategyRules {
+  enabled?: boolean;
+  compounds?: TireCompound[];
+  mandatoryDistinctDryCompounds?: number | null;
+}
+
+export interface PaddockTireDegradationRules {
+  enabled?: boolean;
+}
+
+export interface PaddockStalledDnfRules {
+  enabled?: boolean;
+  maxStoppedSeconds?: number;
+  speedThresholdKph?: number;
+}
+
+export interface PaddockPenaltySubsectionRules {
+  strictness?: number;
+  timePenaltySeconds?: number;
+  consequences?: PaddockPenaltyConsequence[];
+}
+
+export type PaddockPenaltyConsequence =
+  | { type: 'warning' }
+  | { type: 'time'; seconds: number }
+  | { type: 'driveThrough'; conversionSeconds?: number }
+  | { type: 'stopGo'; seconds?: number; conversionSeconds?: number }
+  | { type: 'positionDrop'; positions: number }
+  | { type: 'gridDrop'; positions: number }
+  | { type: 'disqualification' };
+
+export type PaddockPenaltyStatus = 'issued' | 'served' | 'applied' | 'cancelled';
+
+export interface PaddockTrackLimitPenaltyRules extends PaddockPenaltySubsectionRules {
+  warningsBeforePenalty?: number;
+  relaxedMarginMeters?: number;
+}
+
+export interface PaddockCollisionPenaltyRules extends PaddockPenaltySubsectionRules {
+  minimumSeverity?: number;
+  relaxedSeverityMargin?: number;
+  minimumImpactSpeedKph?: number;
+  relaxedImpactSpeedKph?: number;
+}
+
+export interface PaddockPitLaneSpeedingPenaltyRules extends PaddockPenaltySubsectionRules {
+  speedLimitKph?: number;
+  marginKph?: number;
+  relaxedMarginKph?: number;
+}
+
+export interface PaddockPenaltyRules {
+  enabled?: boolean;
+  stewardStrictness?: number;
+  trackLimits?: PaddockTrackLimitPenaltyRules;
+  collision?: PaddockCollisionPenaltyRules;
+  tireRequirement?: PaddockPenaltySubsectionRules;
+  pitLaneSpeeding?: PaddockPitLaneSpeedingPenaltyRules;
+}
+
+export interface PaddockRaceModules {
+  pitStops?: PaddockPitStopRules;
+  tireStrategy?: PaddockTireStrategyRules;
+  tireDegradation?: PaddockTireDegradationRules;
+  stalledDnf?: PaddockStalledDnfRules;
+  penalties?: PaddockPenaltyRules;
+  weather?: { enabled?: boolean };
+  reliability?: { enabled?: boolean };
+  fuelLoad?: { enabled?: boolean };
+}
+
+export interface PaddockRaceRules {
+  ruleset?: PaddockRulesetName;
+  profile?: PaddockRulesetName;
+  modules?: PaddockRaceModules;
+  drsDetectionSeconds?: number;
+  safetyCarSpeed?: number;
+  safetyCarLeadDistance?: number;
+  safetyCarGap?: number;
+  collisionRestitution?: number;
+  standingStart?: boolean;
+  startLightCount?: number;
+  startLightInterval?: number;
+  startLightsOutHold?: number;
+}
+
+export interface PaddockPenaltyEntry {
+  id: string;
+  type: string;
+  at: number;
+  lap: number;
+  driverId: string;
+  strictness: number;
+  status: PaddockPenaltyStatus;
+  penaltySeconds: number;
+  pendingPenaltySeconds?: number;
+  consequences: PaddockPenaltyConsequence[];
+  serviceType?: 'driveThrough' | 'stopGo' | null;
+  serviceRequired?: boolean;
+  serviceServedAt?: number | null;
+  appliedAt?: number;
+  cancelledAt?: number;
+  unserved?: boolean;
+  positionDrop?: number;
+  gridDrop?: number;
+  disqualified?: boolean;
+  reason?: string;
+  otherCarId?: string;
+  aheadDriverId?: string;
+  atFaultDriverId?: string;
+  sharedFault?: boolean;
+  impactSpeedKph?: number;
+  impactSpeedThresholdKph?: number;
   [key: string]: unknown;
 }
 
+export interface WheelSurfaceSnapshot {
+  id: string;
+  x: number;
+  y: number;
+  signedOffset: number;
+  crossTrackError: number;
+  surface: string;
+  onTrack: boolean;
+  inPitLane: boolean;
+  fullyOutsideWhiteLine: boolean;
+}
+
 export interface CarSnapshot {
   id: string;
-  rank: number;
+  rank: number | null;
   code: string;
   timingCode: string;
   name: string;
   color: string;
   tire: TireCompound;
+  interaction?: PaddockParticipantInteraction;
   lap: number;
   speedKph: number;
+  finishRank?: number | null;
+  status?: 'racing' | 'waved-flag' | 'destroyed' | string;
+  raceStatus?: 'racing' | 'waved-flag' | 'destroyed' | string;
+  wavedFlag?: boolean;
   finished?: boolean;
+  destroyed?: boolean;
+  destroyReason?: string | null;
+  destroyedAt?: number | null;
+  dnf?: boolean;
+  dnfReason?: string | null;
+  dnfAt?: number | null;
+  dnfOrder?: number | null;
+  outOfRace?: boolean;
   finishTime?: number | null;
+  penaltySeconds?: number;
+  adjustedFinishTime?: number | null;
   classifiedRank?: number | null;
   intervalAheadSeconds?: number | null;
   leaderGapSeconds?: number | null;
+  gapAheadLaps?: number;
+  intervalAheadLaps?: number;
+  leaderGapLaps?: number;
   lapTelemetry?: LapTelemetrySnapshot;
+  surface?: string;
+  lateralG?: number;
+  longitudinalG?: number;
+  gripUsage?: number;
+  slipAngleRadians?: number;
+  tractionLimited?: boolean;
+  stabilityState?: PaddockStabilityState;
+  signedOffset?: number;
+  crossTrackError?: number;
+  inPitLane?: boolean;
+  wheels?: WheelSurfaceSnapshot[];
+  pitLanePart?: 'entry' | 'fast-lane' | 'working-lane' | 'exit' | 'service-box' | 'garage-box' | null;
+  pitBoxId?: string | null;
+  pitLaneCrossTrackError?: number | null;
+  usedTireCompounds?: Array<TireCompound | string>;
+  pitIntent?: PaddockPitIntent;
+  pitStop?: PitStopSnapshot | null;
   [key: string]: unknown;
 }
 
@@ -271,11 +699,22 @@ export interface RaceClassificationEntry {
   lap: number;
   finished: boolean;
   finishTime?: number | null;
+  dnf?: boolean;
+  dnfReason?: string | null;
+  dnfAt?: number | null;
+  dnfOrder?: number | null;
+  penaltySeconds?: number;
+  adjustedFinishTime?: number | null;
+  gapLaps?: number;
+  intervalLaps?: number;
+  positionDrop?: number;
+  disqualified?: boolean;
   [key: string]: unknown;
 }
 
 export interface RaceSnapshot {
   time: number;
+  physicsMode: PaddockPhysicsMode;
   world: {
     width: number;
     height: number;
@@ -285,6 +724,15 @@ export interface RaceSnapshot {
   totalLaps: number;
   raceControl: {
     mode: string;
+    redFlag: boolean;
+    pitLaneOpen: boolean;
+    pitLaneStatus?: {
+      enabled: boolean;
+      open: boolean;
+      reason: string;
+      color: string;
+      light: string;
+    };
     finished: boolean;
     finishedAt: number | null;
     winner: CarSnapshot | null;
@@ -294,13 +742,22 @@ export interface RaceSnapshot {
       [key: string]: unknown;
     };
   };
+  pitLaneStatus?: {
+    enabled: boolean;
+    open: boolean;
+    reason: string;
+    color: string;
+    light: string;
+  };
   safetyCar: {
     deployed: boolean;
     [key: string]: unknown;
   };
-  rules: Record<string, unknown>;
+  rules: PaddockRaceRules;
   events: RaceEvent[];
+  penalties: PaddockPenaltyEntry[];
   cars: CarSnapshot[];
+  replayGhosts: PaddockReplayGhostSnapshot[];
 }
 
 export interface LifecycleErrorContext {
@@ -313,7 +770,7 @@ export interface F1SimulatorCallbacks {
   onLoadingChange?: (state: { loading: boolean; phase: string }) => void;
   onReady?: (payload: { snapshot: RaceSnapshot }) => void;
   onError?: (error: unknown, context: LifecycleErrorContext) => void;
-  onDriverSelect?: (driver: CarSnapshot, snapshot: RaceSnapshot) => void;
+  onDriverSelect?: (driver: NormalizedSimulatorDriver, snapshot: RaceSnapshot) => void;
   onRaceEvent?: (event: RaceEvent, snapshot: RaceSnapshot) => void;
   onLapChange?: (payload: {
     previousLeaderLap: number | null;
@@ -334,6 +791,8 @@ export interface F1SimulatorExpertOptions {
   frameSkip?: number;
   visualizeSensors?: boolean | {
     rays?: boolean;
+    drivers?: 'selected' | 'all' | string[];
+    selectedDriverId?: string;
   };
 }
 
@@ -341,15 +800,56 @@ export interface F1SimulatorExpertAction {
   steering: number;
   throttle: number;
   brake: number;
+  pitIntent?: PaddockPitIntent;
+  pitCompound?: TireCompound | string;
+  pitTargetCompound?: TireCompound | string;
+}
+
+export interface PaddockExternalRenderFrame {
+  snapshot: RaceSnapshot;
+  observation: Record<string, unknown>;
+  meta?: Record<string, unknown> | null;
+}
+
+export interface PaddockExternalRendererSource {
+  subscribe(onFrame: (frame: PaddockExternalRenderFrame) => void): () => void;
+}
+
+export interface PaddockExternalRendererState {
+  attached: boolean;
+  lastMeta: Record<string, unknown> | null;
+  lastFrameAt: number | null;
+  lastError: string | null;
+}
+
+export interface PaddockScenarioPlacement {
+  distanceMeters?: number;
+  startDistanceMeters?: number;
+  offsetMeters?: number;
+  speedKph?: number;
+  headingErrorRadians?: number;
+}
+
+export interface PaddockEnvironmentResultOptions {
+  stateOutput?: 'full' | 'minimal' | 'none';
+  observationScope?: 'all' | 'reset';
+  resetDriversObservationScope?: 'all' | 'reset';
 }
 
 export interface F1SimulatorExpertApi {
   reset(options?: unknown): unknown;
   step(actions: Record<string, F1SimulatorExpertAction>): unknown;
+  resetDrivers?(
+    placements: Record<string, PaddockScenarioPlacement>,
+    resultOptions?: PaddockEnvironmentResultOptions
+  ): unknown;
   getObservation(): unknown;
   getState(): unknown;
   getActionSpec(): PaddockActionSpec;
   getObservationSpec(): PaddockObservationSpec;
+  attachExternalRenderer(source: PaddockExternalRendererSource): void;
+  detachExternalRenderer(): void;
+  getExternalRendererState(): PaddockExternalRendererState;
   destroy(): void;
 }
 
@@ -359,7 +859,14 @@ export interface F1SimulatorOptions extends F1SimulatorCallbacks {
   entries?: ChampionshipEntryBlueprint[];
   seed?: number;
   trackSeed?: number;
+  trackGeneration?: PaddockProceduralTrackOptions;
+  trackQueryIndex?: boolean;
+  warmup?: PaddockWarmupOptions | boolean;
   totalLaps?: number;
+  physicsMode?: PaddockPhysicsMode;
+  rules?: PaddockRaceRules;
+  participantInteractions?: PaddockParticipantInteractionsOptions;
+  replayGhosts?: PaddockReplayGhostOptions[];
   initialCameraMode?: CameraMode;
   theme?: F1SimulatorTheme;
   title?: string;
@@ -368,6 +875,7 @@ export interface F1SimulatorOptions extends F1SimulatorCallbacks {
   backLinkLabel?: string;
   showBackLink?: boolean;
   ui?: F1SimulatorUiOptions;
+  debug?: F1SimulatorDebugOptions;
   assets?: F1SimulatorAssets;
   expert?: F1SimulatorExpertOptions;
 }
@@ -397,9 +905,17 @@ export interface F1MountedSimulator {
   restart(nextOptions?: F1SimulatorRestartOptions): void;
   selectDriver(driverId: string): void;
   setSafetyCarDeployed(deployed: boolean): void;
+  setRedFlagDeployed(deployed: boolean): void;
+  setPitLaneOpen(open: boolean): void;
   callSafetyCar(): void;
   clearSafetyCar(): void;
   toggleSafetyCar(): void;
+  setPitIntent(driverId: string, intent: PaddockPitIntentRequest, targetCompound?: TireCompound | string): boolean;
+  getPitIntent(driverId: string): PaddockPitIntent;
+  getPitTargetCompound(driverId: string): TireCompound | string | null;
+  getSimulationSpeed(): number;
+  servePenalty(penaltyId: string): PaddockPenaltyEntry | null;
+  cancelPenalty(penaltyId: string): PaddockPenaltyEntry | null;
   getSnapshot(): RaceSnapshot | null;
 }
 
@@ -426,9 +942,17 @@ export interface PaddockSimulatorController {
   restart(nextOptions?: F1SimulatorRestartOptions): void;
   selectDriver(driverId: string): void;
   setSafetyCarDeployed(deployed: boolean): void;
+  setRedFlagDeployed(deployed: boolean): void;
+  setPitLaneOpen(open: boolean): void;
   callSafetyCar(): void;
   clearSafetyCar(): void;
   toggleSafetyCar(): void;
+  setPitIntent(driverId: string, intent: PaddockPitIntentRequest, targetCompound?: TireCompound | string): boolean;
+  getPitIntent(driverId: string): PaddockPitIntent;
+  getPitTargetCompound(driverId: string): TireCompound | string | null;
+  getSimulationSpeed(): number;
+  servePenalty(penaltyId: string): PaddockPenaltyEntry | null;
+  cancelPenalty(penaltyId: string): PaddockPenaltyEntry | null;
   getSnapshot(): RaceSnapshot | null;
 }
 
@@ -463,6 +987,8 @@ export function simSpeedToMetersPerSecond(simSpeed: number): number;
 
 export function createPaddockSimulator(options: F1SimulatorOptions): PaddockSimulatorController;
 export function mountF1Simulator(root: Element, options: F1SimulatorOptions): Promise<F1MountedSimulator>;
+export function createProceduralTrack(seed?: number | string, options?: PaddockProceduralTrackOptions): unknown;
+export function createPaddockDriverControllerLoop(options: PaddockDriverControllerLoopOptions): PaddockDriverControllerLoop;
 
 export function mountRaceControls<T extends Element>(root: T, simulator: PaddockSimulatorController): T;
 export function mountCameraControls<T extends Element>(root: T, simulator: PaddockSimulatorController): T;