@inventure71/paddockjs 4.1.0 → 4.3.0

package/src/environment/index.d.ts

@@ -1,43 +1,17 @@
-export type TireCompound = 'S' | 'M' | 'H';
+import type { PaddockProceduralTrackProfile, PaddockProceduralTrackOptions, PaddockTrackPoint, PaddockDrsZone, PaddockResolvedProceduralTrackOptions, PaddockProceduralTrack } from '../data/trackTypes.js';
+import type { TireCompound, SimulatorDriver, ChampionshipEntryBlueprint } from '../data/entryTypes.js';
+export type { PaddockProceduralTrackProfile, PaddockProceduralTrackOptions, PaddockTrackPoint, PaddockDrsZone, PaddockResolvedProceduralTrackOptions, PaddockProceduralTrack } from '../data/trackTypes.js';
+export type { TireCompound, SimulatorDriver, ChampionshipEntryBlueprint } from '../data/entryTypes.js';
+
+import type { TeamData } from '../data/teamTypes.js';
+
+export type {
+  PaddockPitCrewStats,
+  PaddockThemeSelector,
+  TeamData,
+} from '../data/teamTypes.js';
+
 export type PaddockPhysicsMode = 'arcade' | 'advanced';
-export type PaddockProceduralTrackProfile = 'race' | 'training-short' | 'training-medium' | 'training-technical';
-
-export interface PaddockProceduralTrackOptions {
-  profile?: PaddockProceduralTrackProfile;
-  minLengthMeters?: number;
-  maxLengthMeters?: number;
-  startStraightMeters?: number;
-  includePitLane?: boolean;
-  length?: {
-    minMeters?: number;
-    maxMeters?: number;
-  };
-  startStraight?: {
-    gridMeters?: number;
-    exitMeters?: number;
-    blendMeters?: number;
-    lockExtraMeters?: number;
-  };
-  pitLane?: {
-    enabled?: boolean;
-  };
-  shape?: {
-    scale?: number;
-    cornerDensity?: number;
-    variation?: number;
-  };
-  validation?: {
-    minClearanceMultiplier?: number;
-    minShapeVariation?: number;
-    minNonAdjacentArcMeters?: number;
-    maxLocalTurnRadians?: number;
-    maxSampleHeadingDeltaRadians?: number;
-  };
-  attempts?: {
-    primary?: number;
-    fallback?: number;
-  };
-}
 
 export type PaddockStabilityState = 'stable' | 'understeer' | 'oversteer' | 'spin-risk' | 'destroyed';
 export type PaddockPitIntent = 0 | 1 | 2;
@@ -109,45 +83,6 @@ export interface PaddockReplayGhostSnapshot {
   };
 }
 
-export interface TeamData {
-  id?: string;
-  name?: string;
-  color?: string;
-  icon?: string;
-  pitCrew?: PaddockPitCrewStats;
-  pitCrewStats?: PaddockPitCrewStats;
-}
-
-export interface PaddockPitCrewStats {
-  speed?: number;
-  consistency?: number;
-  reliability?: number;
-}
-
-export interface SimulatorDriver {
-  id: string;
-  name: string;
-  color: string;
-  link?: string;
-  icon?: string;
-  code?: string;
-  timingName?: string;
-  tire?: TireCompound;
-  raceData?: string[];
-  customFields?: Array<{ label: string; value: string }> | Record<string, string>;
-  team?: TeamData | null;
-  driverNumber?: number;
-}
-
-export interface ChampionshipEntryBlueprint {
-  driverId: string;
-  driverNumber?: number;
-  timingName?: string;
-  driver?: unknown;
-  vehicle?: unknown;
-  team?: TeamData;
-}
-
 export interface RaceEvent {
   type: string;
   at?: number;
@@ -668,14 +603,16 @@ export type PaddockPolicyLike =
   | { predict(observation: PaddockDriverObservation, context: Record<string, unknown>): PaddockAction };
 
 export interface PaddockDriverControllerContext {
+  /** Generation cancellation signal; Paddock-owned loops always supply it. */
+  signal?: AbortSignal;
   runtime: PaddockControllerRuntime;
   mode: string;
   actionRepeat: number;
   controlledDrivers: string[];
   actionSpec: PaddockActionSpec;
   observationSpec: PaddockObservationSpec;
-  result: PaddockEnvironmentResult | unknown;
-  previousResult: PaddockEnvironmentResult | unknown | null;
+  result: PaddockEnvironmentResult;
+  previousResult: PaddockEnvironmentResult | null;
   observation: Record<string, PaddockDriverObservation>;
   orderedObservations: Array<{
     driverId: string;
@@ -685,7 +622,7 @@ export interface PaddockDriverControllerContext {
   }>;
   metrics: Record<string, PaddockEnvironmentDriverMetrics>;
   events: RaceEvent[];
-  info: PaddockEnvironmentResult['info'] | unknown | null;
+  info: PaddockEnvironmentResult['info'] | null;
   previousActions: PaddockActionMap;
   orderedPreviousActions: Array<PaddockAction | null>;
   actions: PaddockActionMap | null;
@@ -721,14 +658,14 @@ export interface PaddockDriverController {
 }
 
 export interface PaddockControllerRuntime {
-  reset(options?: unknown): PaddockEnvironmentResult | unknown;
-  step(actions: PaddockActionMap): PaddockEnvironmentResult | unknown;
+  reset(options?: unknown): PaddockEnvironmentResult;
+  step(actions: PaddockActionMap): PaddockEnvironmentResult;
   resetDrivers?(
     placements: Record<string, PaddockScenarioPlacement>,
     resultOptions?: PaddockEnvironmentResultOptions
-  ): PaddockEnvironmentResult | unknown;
+  ): PaddockEnvironmentResult;
   getObservation(): Record<string, PaddockDriverObservation>;
-  getState?(options?: { output?: 'full' | 'minimal' | 'none' }): PaddockEnvironmentResult['state'] | unknown;
+  getState?(options?: { output?: 'full' | 'minimal' | 'none' }): PaddockEnvironmentResult['state'];
   getActionSpec(): PaddockActionSpec;
   getObservationSpec(): PaddockObservationSpec;
   destroy?(): void;
@@ -743,7 +680,7 @@ export interface PaddockDriverControllerLoopOptions {
 }
 
 export interface PaddockDriverControllerLoop {
-  readonly result: PaddockEnvironmentResult | unknown | null;
+  readonly result: PaddockEnvironmentResult | null;
   readonly actionSpec: PaddockActionSpec | null;
   readonly observationSpec: PaddockObservationSpec | null;
   readonly stats: {
@@ -756,13 +693,13 @@ export interface PaddockDriverControllerLoop {
     running: boolean;
     lastError: unknown | null;
   };
-  reset(options?: unknown): Promise<PaddockEnvironmentResult | unknown>;
+  reset(options?: unknown): Promise<PaddockEnvironmentResult>;
   resetDrivers(
     placements: Record<string, PaddockScenarioPlacement>,
     resultOptions?: PaddockEnvironmentResultOptions
-  ): Promise<PaddockEnvironmentResult | unknown>;
-  step(): Promise<PaddockEnvironmentResult | unknown>;
-  stepFrame(): Promise<PaddockEnvironmentResult | unknown>;
+  ): Promise<PaddockEnvironmentResult>;
+  step(): Promise<PaddockEnvironmentResult>;
+  stepFrame(): Promise<PaddockEnvironmentResult>;
   start(): void;
   stop(): void;
 }
@@ -869,7 +806,13 @@ export function createRolloutTransition(
 ): PaddockRolloutTransition;
 export const ENVIRONMENT_SCENARIO_PRESETS: readonly PaddockScenarioPreset[];
 export const DEFAULT_EVALUATION_CASES: readonly PaddockEvaluationCase[];
-export function createEvaluationTracker(initialResult: PaddockEnvironmentSnapshotResult): {
+export type PaddockEvaluationLapScope = 'since-start' | 'include-history';
+
+export interface PaddockEvaluationTrackerOptions {
+  lapScope?: PaddockEvaluationLapScope;
+}
+
+export function createEvaluationTracker(initialResult: PaddockEnvironmentSnapshotResult, options?: PaddockEvaluationTrackerOptions): {
   update(result: PaddockEnvironmentSnapshotResult): void;
   finish(): Record<string, PaddockEvaluationDriverMetrics>;
 };
@@ -877,6 +820,7 @@ export function runEnvironmentEvaluation(options: {
   baseOptions: PaddockEnvironmentOptions;
   policy: PaddockPolicyLike;
   cases?: PaddockEvaluationCase[];
+  lapScope?: PaddockEvaluationLapScope;
   createEnvironment?: (options: PaddockEnvironmentOptions) => PaddockEnvironment;
 }): PaddockEvaluationReport;
 export function createEnvironmentWorkerProtocol(env: PaddockEnvironment): PaddockEnvironmentWorkerProtocol;

package/src/environment/metrics.js

@@ -1,3 +1,5 @@
+import { isEnvironmentContactEvent, writeEventDriverIds } from './events.js';
+export { isEnvironmentContactEvent } from './events.js';
 import { normalizeAngle } from '../simulation/simMath.js';
 import { pointAt } from '../simulation/track/trackModel.js';
 import { simUnitsToMeters } from '../simulation/units.js';
@@ -26,10 +28,6 @@ export function isEnvironmentCarOffTrack(car) {
   return isOffTrack(car, classifyWheels(car));
 }
 
-export function isEnvironmentContactEvent(event) {
-  return ['collision', 'contact', 'car-contact'].includes(event?.type);
-}
-
 export function buildDriverMetrics({ snapshot, previousSnapshot = null, options, events = [], scratch = null }) {
   const previousById = carsByIdForMetrics(previousSnapshot, scratch, 'previousCarsById');
   const currentById = carsByIdForMetrics(snapshot, scratch, 'currentCarsById');
@@ -179,14 +177,7 @@ function contactCountsByDriver(events, scratch = null) {
   counts.clear();
   events.forEach((event) => {
     if (!isEnvironmentContactEvent(event)) return;
-    eventDriverIds.length = 0;
-    pushEventDriverId(eventDriverIds, event.driverId);
-    pushEventDriverId(eventDriverIds, event.carId);
-    pushEventDriverId(eventDriverIds, event.otherCarId);
-    const extraDriverIds = event.driverIds ?? [];
-    for (let index = 0; index < extraDriverIds.length; index += 1) {
-      pushEventDriverId(eventDriverIds, extraDriverIds[index]);
-    }
+    writeEventDriverIds(eventDriverIds, event);
     for (let index = 0; index < eventDriverIds.length; index += 1) {
       const driverId = eventDriverIds[index];
       counts.set(driverId, (counts.get(driverId) ?? 0) + 1);
@@ -195,8 +186,3 @@ function contactCountsByDriver(events, scratch = null) {
   eventDriverIds.length = 0;
   return counts;
 }
-
-function pushEventDriverId(target, driverId) {
-  if (!driverId || target.includes(driverId)) return;
-  target.push(driverId);
-}

package/src/environment/observationSchema.js

@@ -0,0 +1,104 @@
+export const MODEL_RAY_SURFACE_CHANNELS = Object.freeze(['kerb', 'illegalSurface']);
+
+export function buildObservationVectorSchema({
+  profile = 'default',
+  contactPatchCount = 4,
+  lookaheadCount = 0,
+  rayCount = 0,
+  rayChannels = [],
+  nearbyCount = 0,
+}) {
+  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 < contactPatchCount; 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' },
+      );
+    }
+  }
+  for (let index = 0; index < lookaheadCount; index += 1) {
+    schema.push(
+      { name: `track.lookahead[${index}].curvature`, scale: 'track-curvature' },
+      { name: `track.lookahead[${index}].headingDeltaRadians`, unit: 'rad', scale: 'fixed:pi' },
+    );
+  }
+  for (let index = 0; index < rayCount; index += 1) {
+    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 (rayChannels?.includes?.(channel)) {
+        schema.push(
+          { name: `rays[${index}].${channel}.distanceRatio`, scale: '0..1' },
+          { name: `rays[${index}].${channel}.hit`, scale: 'boolean' },
+        );
+      }
+    });
+  }
+  for (let index = 0; index < nearbyCount; 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;
+}

package/src/environment/observationVector.js

@@ -1,33 +1,8 @@
-const MODEL_RAY_SURFACE_CHANNELS = Object.freeze(['kerb', 'illegalSurface']);
+import { appendRayVectorValues } from './sensors/rayOutputs.js';
+import { buildObservationVectorSchema, MODEL_RAY_SURFACE_CHANNELS } from './observationSchema.js';
 
 export function buildObservationVector(source, sensors, { includeSchema = true, vectorType = 'array' } = {}) {
   const includePhysicalDriverSenses = source.profile === 'physical-driver';
-  const schema = includeSchema ? [
-    { 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' },
-  ] : null;
   const vector = [
     source.self.speedKph / 400,
     source.self.speedMetersPerSecond / 120,
@@ -55,26 +30,13 @@ export function buildObservationVector(source, sensors, { includeSchema = true,
     source.track.curvature ?? 0,
   ];
   if (includePhysicalDriverSenses) {
-    pushSchema(schema,
-      { 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' },
-    );
     vector.push(
       source.self.yawRateRadiansPerSecond / Math.PI,
       source.trackRelation.leftBoundaryMeters,
       source.trackRelation.rightBoundaryMeters,
       source.trackRelation.legalWidthMeters,
     );
-    source.contactPatches.forEach((patch, index) => {
-      pushSchema(schema,
-        { 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' },
-      );
+    source.contactPatches.forEach((patch) => {
       vector.push(
         patch.present ? 1 : 0,
         patch.surfaceCode / 5,
@@ -84,58 +46,21 @@ export function buildObservationVector(source, sensors, { includeSchema = true,
       );
     });
   }
-  source.track.lookahead.forEach((sample, index) => {
-    pushSchema(schema,
-      { name: `track.lookahead[${index}].curvature`, scale: 'track-curvature' },
-      { name: `track.lookahead[${index}].headingDeltaRadians`, unit: 'rad', scale: 'fixed:pi' },
-    );
+  source.track.lookahead.forEach((sample) => {
     vector.push(sample.curvature ?? 0, (sample.headingDeltaRadians ?? 0) / Math.PI);
   });
   if (typeof source.appendRayVectorValues === 'function') {
     source.appendRayVectorValues(vector);
-  } else if (Array.isArray(source.rayVectorValues)) {
-    source.rayVectorValues.forEach((values, index) => {
-      pushRaySchema(schema, index, sensors);
-      vector.push(...values);
-    });
   } else {
-    source.rays.forEach((ray, index) => {
-      pushRaySchema(schema, index, sensors);
-      vector.push(
-        ratio(ray.track.distanceMeters, ray.lengthMeters),
-        ray.track.hit ? 1 : 0,
-        ray.track.kind === 'exit' ? 1 : 0,
-        ray.track.kind === 'entry' ? 1 : 0,
-        ratio(ray.car.distanceMeters, ray.lengthMeters),
-        ray.car.hit ? 1 : 0,
-        ray.car.relativeSpeedKph / 200,
-        ray.car.targetType === 'replayGhost' ? 1 : 0,
-      );
-      MODEL_RAY_SURFACE_CHANNELS.forEach((channel) => {
-        if (sensors.rays.channels?.includes?.(channel)) {
-          vector.push(
-            ratio(ray[channel]?.distanceMeters ?? ray.lengthMeters, ray.lengthMeters),
-            ray[channel]?.hit ? 1 : 0,
-          );
-        }
-      });
+    const surfaceChannels = MODEL_RAY_SURFACE_CHANNELS.filter((channel) => sensors.rays.channels?.includes?.(channel));
+    source.rays.forEach((ray) => {
+      appendRayVectorValues(vector, ray.lengthMeters, ray.track, ray.car, ray, surfaceChannels);
     });
   }
   const nearbyLimit = sensors.nearbyCars.enabled ? (sensors.nearbyCars.maxCars ?? source.nearbyCars.length) : 0;
   const nearbyRadius = sensors.nearbyCars.radiusMeters ?? 150;
   for (let index = 0; index < nearbyLimit; index += 1) {
     const nearby = source.nearbyCars[index] ?? null;
-    pushSchema(schema,
-      { 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' },
-    );
     vector.push(
       nearby ? 1 : 0,
       clampRatio((nearby?.relativeForwardMeters ?? 0) / nearbyRadius),
@@ -148,13 +73,6 @@ export function buildObservationVector(source, sensors, { includeSchema = true,
       nearby?.entityType === 'replayGhost' ? 1 : 0,
     );
     if (includePhysicalDriverSenses) {
-      pushSchema(schema,
-        { 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' },
-      );
       vector.push(
         nearby?.behind ? 1 : 0,
         (nearby?.closingRateMetersPerSecond ?? 0) / 100,
@@ -164,38 +82,21 @@ export function buildObservationVector(source, sensors, { includeSchema = true,
       );
     }
   }
-  return { vector: finalizeVector(vector, vectorType), schema: schema ?? [] };
+  const schema = includeSchema ? buildObservationVectorSchema({
+    profile: source.profile,
+    contactPatchCount: source.contactPatches?.length ?? 0,
+    lookaheadCount: source.track.lookahead.length,
+    rayCount: typeof source.appendRayVectorValues === 'function' ? 0 : source.rays.length,
+    rayChannels: sensors.rays.channels,
+    nearbyCount: nearbyLimit,
+  }) : [];
+  return { vector: finalizeVector(vector, vectorType), schema };
 }
 
 function finalizeVector(vector, vectorType = 'array') {
   return vectorType === 'float32' ? Float32Array.from(vector) : vector;
 }
 
-function pushSchema(schema, ...entries) {
-  if (schema) schema.push(...entries);
-}
-
-function pushRaySchema(schema, index, sensors) {
-  pushSchema(schema,
-    { 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 (sensors.rays.channels?.includes?.(channel)) {
-      pushSchema(schema,
-        { name: `rays[${index}].${channel}.distanceRatio`, scale: '0..1' },
-        { name: `rays[${index}].${channel}.hit`, scale: 'boolean' },
-      );
-    }
-  });
-}
-
 function normalizeLapProgress(source) {
   return ratio(source.self.lapProgressMeters, source.track.lengthMeters || 1);
 }