@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/environment/sensors/surfaceRays.js

@@ -4,13 +4,13 @@ import { metersToSimUnits, simUnitsToMeters } from '../../simulation/units.js';
 import {
   ANALYTIC_TRACK_RAY_MAX_CURVATURE,
   DRIVER_RAY_REFINE_STEPS,
-  PIT_CONNECTOR_RAY_FALLBACK_METERS,
   TRACK_RAY_REFINE_STEPS,
   TRACK_RAY_STEP_METERS,
 } from './rayDefaults.js';
 import { canUseIndexedRecoveryRayApproximation } from './rayGuards.js';
 import { pointOnRay } from './rayGeometry.js';
 import { findIndexedTrackBandBoundaries } from './indexedRayBands.js';
+import { isNearPitConnector } from './pitConnectorProximity.js';
 
 export function requestedSurfaceChannels(channels = []) {
   const requested = [];
@@ -55,7 +55,7 @@ export function estimateSurfaceHits(
 
   const originState = context?.precision === precision
     ? context.originState
-    : nearestRayTrackState(snapshot.track, car, origin, car.progress, precision);
+    : nearestRayTrackState(snapshot.track, car, origin, car.progress);
   writeSurfaceHitsAtOrigin(hits, requested, originState);
   const indexedHits = estimateIndexedSurfaceHits({
     car,
@@ -65,7 +65,6 @@ export function estimateSurfaceHits(
     vector,
     requested,
     originState,
-    precision,
     sharedRayQuery,
     hits,
   });
@@ -90,7 +89,7 @@ export function estimateSurfaceHits(
   let previousState = null;
 
   for (let distance = 0; distance <= maxDistance; distance += step) {
-    const state = nearestRayTrackState(snapshot.track, car, pointOnRay(origin, vector, distance), car.progress, precision);
+    const state = nearestRayTrackState(snapshot.track, car, pointOnRay(origin, vector, distance), car.progress);
     if (pendingKerb && matchesSurfaceChannel('kerb', state)) {
       const hitDistance = previousState
         ? refineSurfaceTransition(snapshot.track, car, origin, vector, car.progress, previousDistance, distance, 'kerb', refineStepsForPrecision(precision))
@@ -187,7 +186,7 @@ function estimateAnalyticSurfaceHits({ car, track, ray, vector, requested, origi
   return hits;
 }
 
-function estimateIndexedSurfaceHits({ car, track, ray, origin, vector, requested, originState, precision, sharedRayQuery, hits }) {
+function estimateIndexedSurfaceHits({ car, track, ray, origin, vector, requested, originState, sharedRayQuery, hits }) {
   if (!originState || car.inPitLane || originState.inPitLane) return null;
   if (!usesMainTrackOnlyRays(car) && isNearPitConnector(track, originState)) return null;
 
@@ -224,23 +223,9 @@ function estimateIndexedSurfaceHits({ car, track, ray, origin, vector, requested
       writeSurfaceMiss(hits[channel], ray.lengthMeters);
       continue;
     }
-    const hitDistance = usesMainTrackOnlyRays(car) || refineStepsForPrecision(precision) <= 0 || precision === 'debug'
-      ? boundaryDistance
-      : sampledIndexedSurfaceDistance({
-        track,
-        car,
-        origin,
-        vector,
-        progressHint: car.progress,
-        distance: boundaryDistance,
-        maxDistance: metersToSimUnits(ray.lengthMeters),
-        channel,
-        precision,
-      });
-    if (hitDistance == null) return null;
     writeSurfaceHit(
       hits[channel],
-      simUnitsToMeters(hitDistance),
+      simUnitsToMeters(boundaryDistance),
       channel === 'kerb'
         ? 'kerb'
         : surfaceBeyondKerb(track, originState.signedOffset ?? 0, lateral, metersToSimUnits(ray.lengthMeters)),
@@ -250,28 +235,6 @@ function estimateIndexedSurfaceHits({ car, track, ray, origin, vector, requested
   return hits;
 }
 
-function sampledIndexedSurfaceDistance({
-  track,
-  car,
-  origin,
-  vector,
-  progressHint,
-  distance,
-  maxDistance,
-  channel,
-  precision,
-}) {
-  const step = metersToSimUnits(TRACK_RAY_STEP_METERS);
-  const firstIndex = Math.max(0, Math.floor(Math.max(0, distance - step * 1.5) / step));
-  const lastIndex = Math.ceil(Math.min(maxDistance, distance + step * 8) / step);
-  for (let index = firstIndex; index <= lastIndex; index += 1) {
-    const sampleDistance = Math.min(maxDistance, index * step);
-    const state = nearestRayTrackState(track, car, pointOnRay(origin, vector, sampleDistance), progressHint, precision);
-    if (matchesSurfaceChannel(channel, state)) return sampleDistance;
-  }
-  return null;
-}
-
 function usesMainTrackOnlyRays(car) {
   return car?.interaction?.profile === 'batch-training';
 }
@@ -320,24 +283,6 @@ function surfaceBeyondKerb(track, offset, lateral, maxDistance) {
   return hitAbs <= gravelOuter ? 'gravel' : 'grass';
 }
 
-function isNearPitConnector(track, state) {
-  const pitLane = track.pitLane;
-  if (!pitLane?.enabled || !Number.isFinite(state?.distance)) return false;
-  const window = metersToSimUnits(PIT_CONNECTOR_RAY_FALLBACK_METERS);
-  const entryDistance = pitLane.entry?.trackDistance ?? pitLane.entry?.distanceFromStart;
-  const exitDistance = pitLane.exit?.trackDistance ?? pitLane.exit?.distanceFromStart;
-  return wrappedTrackDistance(state.distance, entryDistance, track.length) <= window ||
-    wrappedTrackDistance(state.distance, exitDistance, track.length) <= window;
-}
-
-function wrappedTrackDistance(first, second, totalLength) {
-  if (!Number.isFinite(first) || !Number.isFinite(second) || !Number.isFinite(totalLength) || totalLength <= 0) {
-    return Infinity;
-  }
-  const delta = Math.abs(first - second);
-  return Math.min(delta, totalLength - delta);
-}
-
 function refineSurfaceTransition(
   track,
   car,
@@ -396,7 +341,7 @@ function canSampleRecoverySurface(track, originState, vector) {
   return offset > 0 ? lateral < 0 : lateral > 0;
 }
 
-function nearestRayTrackState(track, car, point, progressHint, precision = 'debug') {
+function nearestRayTrackState(track, car, point, progressHint) {
   return nearestTrackState(track, point, progressHint, {
     allowPitOverride: pitOverrideAllowedForCar(car),
   });

package/src/environment/sensors/trackRays.js

@@ -6,13 +6,13 @@ import { metersToSimUnits, simUnitsToMeters } from '../../simulation/units.js';
 import {
   ANALYTIC_TRACK_RAY_MAX_CURVATURE,
   DRIVER_RAY_REFINE_STEPS,
-  PIT_CONNECTOR_RAY_FALLBACK_METERS,
   TRACK_RAY_REFINE_STEPS,
   TRACK_RAY_STEP_METERS,
 } from './rayDefaults.js';
 import { canUseIndexedRecoveryRayApproximation } from './rayGuards.js';
 import { degreesToRadians, getCarRayOrigin, getCarRayVector, pointOnRay } from './rayGeometry.js';
 import { findIndexedTrackBandBoundaries } from './indexedRayBands.js';
+import { isNearPitConnector } from './pitConnectorProximity.js';
 
 const RAY_TRACK_STATE_REUSE_POSITION_TOLERANCE = metersToSimUnits(1);
 const RAY_TRACK_STATE_REUSE_PROGRESS_TOLERANCE = metersToSimUnits(0.25);
@@ -25,7 +25,7 @@ export function createTrackRayContext(car, snapshot, origin, precision = 'debug'
   const reusedOriginState = reusableRayOriginState(snapshot.track, car, origin);
   return {
     origin,
-    originState: reusedOriginState ?? nearestRayTrackState(snapshot.track, car, origin, car.progress, precision),
+    originState: reusedOriginState ?? nearestRayTrackState(snapshot.track, car, origin, car.progress),
     precision,
   };
 }
@@ -48,7 +48,7 @@ export function estimateTrackHit(
   const step = metersToSimUnits(TRACK_RAY_STEP_METERS);
   const originState = context?.precision === precision
     ? context.originState
-    : nearestRayTrackState(snapshot.track, car, origin, car.progress, precision);
+    : nearestRayTrackState(snapshot.track, car, origin, car.progress);
   const includePitLane = Boolean(car.inPitLane || car.pitLanePart || originState.inPitLane);
   const indexedHit = estimateIndexedTrackHit({
     car,
@@ -62,22 +62,9 @@ export function estimateTrackHit(
     sharedRayQuery,
   });
   if (indexedHit) return indexedHit;
-  const directionalAnalyticHit = canUseDirectionalAnalyticTrackHit({ car, track: snapshot.track, originState, ray, includePitLane })
-    ? estimateAnalyticMainTrackHit({
-      car,
-      track: snapshot.track,
-      origin,
-      originState,
-      ray,
-      lengthMeters,
-      includePitLane,
-    })
-    : null;
-  if (directionalAnalyticHit) return directionalAnalyticHit;
   const analyticHit = estimateAnalyticMainTrackHit({
     car,
     track: snapshot.track,
-    origin,
     originState,
     ray,
     lengthMeters,
@@ -88,7 +75,7 @@ export function estimateTrackHit(
   let previousInside = null;
 
   for (let distance = 0; distance <= maxDistance; distance += step) {
-    const state = nearestRayTrackState(snapshot.track, car, pointOnRay(origin, ray, distance), car.progress, precision);
+    const state = nearestRayTrackState(snapshot.track, car, pointOnRay(origin, ray, distance), car.progress);
     const inside = isInsideTrackBorder(state, snapshot.track, includePitLane);
     if (previousInside == null) {
       previousInside = inside;
@@ -109,7 +96,6 @@ export function estimateTrackHit(
         kind,
         includePitLane,
         refineStepsForPrecision(precision),
-        precision,
       );
       return {
         hit: true,
@@ -132,7 +118,7 @@ export function createTrackMiss(lengthMeters) {
   };
 }
 
-function estimateAnalyticMainTrackHit({ car, track, origin, originState, ray, lengthMeters, includePitLane }) {
+function estimateAnalyticMainTrackHit({ car, track, originState, ray, lengthMeters, includePitLane }) {
   if (includePitLane || (!usesMainTrackOnlyRays(car) && isNearPitConnector(track, originState))) return null;
   if (!canUseIndexedRecoveryRayApproximation(track, originState)) return null;
   if (Math.abs(originState.curvature ?? 0) > ANALYTIC_TRACK_RAY_MAX_CURVATURE) return null;
@@ -162,15 +148,6 @@ function estimateAnalyticMainTrackHit({ car, track, origin, originState, ray, le
   };
 }
 
-function canUseDirectionalAnalyticTrackHit({ car, track, originState, ray, includePitLane }) {
-  if (includePitLane || (!usesMainTrackOnlyRays(car) && isNearPitConnector(track, originState))) return false;
-  if (!canUseIndexedRecoveryRayApproximation(track, originState)) return false;
-  if (Math.abs(originState.curvature ?? 0) > ANALYTIC_TRACK_RAY_MAX_CURVATURE) return false;
-
-  const lateral = ray.x * originState.normalX + ray.y * originState.normalY;
-  return Math.abs(lateral) >= 0.08;
-}
-
 function estimateIndexedTrackHit({ car, track, origin, originState, ray, lengthMeters, includePitLane, precision, sharedRayQuery }) {
   if (includePitLane || (!usesMainTrackOnlyRays(car) && isNearPitConnector(track, originState))) return null;
   const trackHalfWidth = track.width / 2;
@@ -205,7 +182,6 @@ function estimateIndexedTrackHit({ car, track, origin, originState, ray, lengthM
       kind,
       includePitLane,
       precision,
-      originInside: inside,
     });
   if (hitDistance == null) return null;
   return {
@@ -219,24 +195,6 @@ function usesMainTrackOnlyRays(car) {
   return car?.interaction?.profile === 'batch-training';
 }
 
-function isNearPitConnector(track, state) {
-  const pitLane = track.pitLane;
-  if (!pitLane?.enabled || !Number.isFinite(state?.distance)) return false;
-  const window = metersToSimUnits(PIT_CONNECTOR_RAY_FALLBACK_METERS);
-  const entryDistance = pitLane.entry?.trackDistance ?? pitLane.entry?.distanceFromStart;
-  const exitDistance = pitLane.exit?.trackDistance ?? pitLane.exit?.distanceFromStart;
-  return wrappedTrackDistance(state.distance, entryDistance, track.length) <= window ||
-    wrappedTrackDistance(state.distance, exitDistance, track.length) <= window;
-}
-
-function wrappedTrackDistance(first, second, totalLength) {
-  if (!Number.isFinite(first) || !Number.isFinite(second) || !Number.isFinite(totalLength) || totalLength <= 0) {
-    return Infinity;
-  }
-  const delta = Math.abs(first - second);
-  return Math.min(delta, totalLength - delta);
-}
-
 function estimateLocalTrackHit(car, snapshot, angleDegrees, lengthMeters) {
   const trackHalfWidthMeters = simUnitsToMeters(snapshot.track.width / 2);
   const offsetMeters = simUnitsToMeters(car.signedOffset ?? 0);
@@ -277,13 +235,12 @@ function refineTrackTransitionDistance(
   kind,
   includePitLane = true,
   refineSteps = TRACK_RAY_REFINE_STEPS,
-  precision = 'debug',
 ) {
   let low = lowDistance;
   let high = highDistance;
   for (let index = 0; index < refineSteps; index += 1) {
     const middle = (low + high) / 2;
-    const state = nearestRayTrackState(track, car, pointOnRay(origin, ray, middle), progressHint, precision);
+    const state = nearestRayTrackState(track, car, pointOnRay(origin, ray, middle), progressHint);
     const inside = isInsideTrackBorder(state, track, includePitLane);
     if (kind === 'entry') {
       if (inside) high = middle;
@@ -297,7 +254,7 @@ function refineTrackTransitionDistance(
   return high;
 }
 
-function nearestRayTrackState(track, car, point, progressHint, precision = 'debug') {
+function nearestRayTrackState(track, car, point, progressHint) {
   return nearestTrackState(track, point, progressHint, {
     allowPitOverride: pitOverrideAllowedForCar(car),
   });
@@ -440,7 +397,6 @@ function validatedIndexedTransitionDistance({
   kind,
   includePitLane,
   precision = 'driver',
-  originInside = kind === 'exit',
 }) {
   const step = metersToSimUnits(TRACK_RAY_STEP_METERS);
   const refineSteps = refineStepsForPrecision(precision);
@@ -460,7 +416,6 @@ function validatedIndexedTransitionDistance({
       ? !previousInside && inside
       : previousInside && !inside;
     if (matched) {
-      if (refineSteps <= 0) return distance;
       return refineValidatedTransitionDistance(
         track,
         car,
@@ -479,34 +434,6 @@ function validatedIndexedTransitionDistance({
   return null;
 }
 
-function sampledIndexedTransitionDistance({
-  track,
-  car,
-  origin,
-  ray,
-  progressHint,
-  distance,
-  maxDistance,
-  kind,
-  includePitLane,
-}) {
-  const step = metersToSimUnits(TRACK_RAY_STEP_METERS);
-  const firstIndex = Math.max(1, Math.floor(Math.max(0, distance - step * 1.5) / step));
-  const lastIndex = Math.ceil(Math.min(maxDistance, distance + step * 8) / step);
-  for (let index = firstIndex; index <= lastIndex; index += 1) {
-    const high = Math.min(maxDistance, index * step);
-    const low = Math.max(0, high - step);
-    if (high <= low) continue;
-    const previousInside = validatedInsideTrackBorder(track, car, origin, ray, low, progressHint, includePitLane);
-    const inside = validatedInsideTrackBorder(track, car, origin, ray, high, progressHint, includePitLane);
-    const matched = kind === 'entry'
-      ? !previousInside && inside
-      : previousInside && !inside;
-    if (matched) return high;
-  }
-  return null;
-}
-
 function refineValidatedTransitionDistance(track, car, origin, ray, progressHint, lowDistance, highDistance, kind, includePitLane, refineSteps) {
   let low = lowDistance;
   let high = highDistance;

package/src/environment/simulationSetup.js

@@ -0,0 +1,30 @@
+import { createRaceSimulation, FIXED_STEP } from '../simulation/raceSimulation.js';
+import { disableWarmupOptions, runWarmupWithGuard } from '../simulation/warmup/runtimeWarmup.js';
+import { applyControlledRunoffResponse, initializeControlledPitIntentForSimulation } from './driverReset.js';
+import { buildEnvironmentObservation } from './observations.js';
+import { applyEnvironmentScenario } from './scenarios.js';
+
+export function createSimulationWithEnvironmentScenario(options) {
+  runWarmupWithGuard({
+    options,
+    surface: 'environment',
+    execute: ({ warmup }) => {
+      const warmupSimulation = createRaceSimulation(disableWarmupOptions(options, warmup.surface));
+      initializeControlledPitIntentForSimulation(warmupSimulation, options);
+      applyEnvironmentScenario(warmupSimulation, options);
+      applyControlledRunoffResponse(warmupSimulation, options);
+      for (let index = 0; index < warmup.steps; index += 1) warmupSimulation.step(FIXED_STEP);
+      const warmupSnapshot = warmupSimulation.snapshotObservation?.() ?? warmupSimulation.snapshot();
+      buildEnvironmentObservation({
+        snapshot: warmupSnapshot,
+        options,
+        events: [],
+      });
+    },
+  });
+  const sim = createRaceSimulation(disableWarmupOptions(options, 'environment'));
+  initializeControlledPitIntentForSimulation(sim, options);
+  applyEnvironmentScenario(sim, options);
+  applyControlledRunoffResponse(sim, options);
+  return sim;
+}

package/src/environment/specs.js

@@ -1,8 +1,7 @@
 import { normalizeLookaheadMeters } from './observationOptions.js';
-import { effectiveSensorOptions } from './observations.js';
-import { normalizeRayOptions } from './sensors.js';
-
-const MODEL_RAY_SURFACE_CHANNELS = Object.freeze(['kerb', 'illegalSurface']);
+import { effectiveSensorOptions } from './sensorOptions.js';
+import { normalizeRayOptions } from './sensors/rayConfig.js';
+import { buildObservationVectorSchema } from './observationSchema.js';
 
 export function buildActionSpec(options) {
   const compounds = Array.isArray(options.rules?.modules?.tireStrategy?.compounds) &&
@@ -119,7 +118,13 @@ export function buildObservationSpec(options) {
       events: { type: 'array' },
     },
     vector: {
-      schema: buildVectorSchema({ rayOptions, nearbyOptions, lookaheadMeters, profile }),
+      schema: buildObservationVectorSchema({
+        profile,
+        lookaheadCount: lookaheadMeters.length,
+        rayCount: rayOptions.enabled ? rayOptions.anglesDegrees.length : 0,
+        rayChannels: rayOptions.channels,
+        nearbyCount: nearbyOptions.enabled ? nearbyOptions.maxCars : 0,
+      }),
     },
     perDriver: buildPerDriverObservationSpecs(options, { rayOptions, nearbyOptions, lookaheadMeters, profile }),
   };
@@ -136,11 +141,12 @@ function buildPerDriverObservationSpecs(options, { rayOptions, nearbyOptions, lo
         nearbyCars: buildNearbyObjectSpec(sensors.nearbyCars),
       },
       vector: {
-        schema: buildVectorSchema({
-          rayOptions: sensors.rays,
-          nearbyOptions: sensors.nearbyCars,
-          lookaheadMeters,
+        schema: buildObservationVectorSchema({
           profile,
+          lookaheadCount: lookaheadMeters.length,
+          rayCount: sensors.rays.enabled ? sensors.rays.anglesDegrees.length : 0,
+          rayChannels: sensors.rays.channels,
+          nearbyCount: sensors.nearbyCars.enabled ? sensors.nearbyCars.maxCars : 0,
         }),
       },
     }];
@@ -187,106 +193,6 @@ function buildNearbyObjectSpec(nearbyOptions) {
   };
 }
 
-function buildVectorSchema({ rayOptions, nearbyOptions, lookaheadMeters, profile = 'default' }) {
-  const includePhysicalDriverSenses = profile === 'physical-driver';
-  const schema = [
-    { name: 'self.speedKph', unit: 'kph', scale: 'fixed:400' },
-    { name: 'self.speedMetersPerSecond', unit: 'm/s', scale: 'fixed:120' },
-    { name: 'self.steeringAngleRadians', unit: 'rad', scale: 'fixed:pi' },
-    { name: 'self.throttle', scale: '0..1' },
-    { name: 'self.brake', scale: '0..1' },
-    { name: 'self.lateralG', scale: 'fixed:8g' },
-    { name: 'self.longitudinalG', scale: 'fixed:6g' },
-    { name: 'self.gripUsage', scale: '0..2' },
-    { name: 'self.slipAngleRadians', unit: 'rad', scale: 'fixed:pi' },
-    { name: 'self.tractionLimited', scale: 'boolean' },
-    { name: 'self.lapProgressRatio', scale: '0..1' },
-    { name: 'self.trackOffsetMeters', unit: 'm', scale: 'fixed:meters' },
-    { name: 'self.trackHeadingErrorRadians', unit: 'rad', scale: 'fixed:pi' },
-    { name: 'self.onTrack', scale: 'boolean' },
-    { name: 'self.inPitLane', scale: 'boolean' },
-    { name: 'self.tireEnergy', scale: '0..100' },
-    { name: 'self.pitIntent', scale: '0..2' },
-    { name: 'self.pitStopActive', scale: 'boolean' },
-    { name: 'race.positionNormalized', scale: '0..1' },
-    { name: 'race.raceModeGreen', scale: 'boolean' },
-    { name: 'race.raceModeSafetyCar', scale: 'boolean' },
-    { name: 'race.redFlag', scale: 'boolean' },
-    { name: 'race.pitLaneOpen', scale: 'boolean' },
-    { name: 'track.curvature', scale: 'track-curvature' },
-  ];
-  if (includePhysicalDriverSenses) {
-    schema.push(
-      { name: 'self.yawRateRadiansPerSecond', unit: 'rad/s', scale: 'fixed:pi' },
-      { name: 'trackRelation.leftBoundaryMeters', unit: 'm', scale: 'fixed:meters' },
-      { name: 'trackRelation.rightBoundaryMeters', unit: 'm', scale: 'fixed:meters' },
-      { name: 'trackRelation.legalWidthMeters', unit: 'm', scale: 'fixed:meters' },
-    );
-    for (let index = 0; index < 4; index += 1) {
-      schema.push(
-        { name: `contactPatches[${index}].present`, scale: 'boolean' },
-        { 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' },
-      );
-    }
-  }
-  lookaheadMeters.forEach((_, index) => {
-    schema.push(
-      { name: `track.lookahead[${index}].curvature`, scale: 'track-curvature' },
-      { name: `track.lookahead[${index}].headingDeltaRadians`, unit: 'rad', scale: 'fixed:pi' },
-    );
-  });
-  if (rayOptions.enabled) {
-    rayOptions.anglesDegrees.forEach((_, index) => {
-      schema.push(
-        { name: `rays[${index}].track.distanceRatio`, scale: '0..1' },
-        { name: `rays[${index}].track.hit`, scale: 'boolean' },
-        { name: `rays[${index}].track.kindExit`, scale: 'boolean' },
-        { name: `rays[${index}].track.kindEntry`, scale: 'boolean' },
-        { 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' },
-      );
-      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) {
-    for (let index = 0; index < nearbyOptions.maxCars; index += 1) {
-      schema.push(
-        { name: `nearbyCars[${index}].present`, scale: 'boolean' },
-        { name: `nearbyCars[${index}].relativeForwardRatio`, scale: '-1..1' },
-        { name: `nearbyCars[${index}].relativeRightRatio`, scale: '-1..1' },
-        { name: `nearbyCars[${index}].relativeDistanceRatio`, scale: '0..1' },
-        { name: `nearbyCars[${index}].relativeSpeedKph`, unit: 'kph', scale: 'fixed:200' },
-        { 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(
-          { name: `nearbyCars[${index}].behind`, scale: 'boolean' },
-          { name: `nearbyCars[${index}].closingRateMetersPerSecond`, unit: 'm/s', scale: 'fixed:100' },
-          { name: `nearbyCars[${index}].timeToContactSeconds`, unit: 's', scale: 'fixed:10' },
-          { name: `nearbyCars[${index}].leftOverlap`, scale: 'boolean' },
-          { name: `nearbyCars[${index}].rightOverlap`, scale: 'boolean' },
-        );
-      }
-    }
-  }
-  return schema;
-}
-
 function surfaceRaySpec(lengthMeters) {
   return {
     distanceMeters: { unit: 'm', noHitValue: lengthMeters },