feat: move session timing to channel

Author: tariknz

docs/IMPLEMENTATION_PLAN.md

@@ -17,6 +17,7 @@ import { RelativeGapRuntime } from '../../processors/relativeGapRuntime';
 import { SectorTimingRuntime } from '../../processors/sectorTimingRuntime';
 import { StandingsRuntime } from '../../processors/standingsRuntime';
 import { RadioRuntime } from '../../processors/radioRuntime';
+import { SessionTimingRuntime } from '../../processors/sessionTimingRuntime';
 
 // Keys consumed by the renderer. Anything outside this set is dropped before
 // the telemetry object crosses the IPC boundary — reducing structured-clone
@@ -208,6 +209,16 @@ export async function publishIRacingSDKEvents(
     lifecycle && channelBus
       ? new RadioRuntime(channelBus, lifecycle, perfMetrics, isTapeReplay)
       : undefined;
+  const sessionTimingRuntime =
+    lifecycle && channelBus && lapTimesRuntime
+      ? new SessionTimingRuntime(
+          channelBus,
+          lifecycle,
+          perfMetrics,
+          lapTimesRuntime,
+          isTapeReplay
+        )
+      : undefined;
 
   let shouldStop = false;
   let lastRunningState: boolean | undefined = undefined;
@@ -312,6 +323,7 @@ export async function publishIRacingSDKEvents(
           sectorTimingRuntime?.onFrame(telemetry);
           standingsRuntime?.onFrame(telemetry);
           radioRuntime?.onFrame(telemetry);
+          sessionTimingRuntime?.onFrame(telemetry);
           if (
             perfTelemetryDeliveryEnabled &&
             overlayManager.hasLegacyStreamSubscribers('telemetry')
@@ -346,6 +358,7 @@ export async function publishIRacingSDKEvents(
             relativeGapRuntime?.onSession(session);
             sectorTimingRuntime?.onSession(session);
             standingsRuntime?.onSession(session);
+            sessionTimingRuntime?.onSession(session);
             overlayManager.publishMessage('sessionData', session);
             sessionCallbacks.forEach((callback) => callback(session));
             perfMetrics.markEnd('sessionPublish');
@@ -409,6 +422,7 @@ export async function publishIRacingSDKEvents(
       sectorTimingRuntime?.dispose();
       standingsRuntime?.dispose();
       radioRuntime?.dispose();
+      sessionTimingRuntime?.dispose();
       referenceLapRuntime?.dispose();
       perfMetrics.stopReporting();
     },

src/app/bridge/iracingSdk/iracingSdkBridge.ts

@@ -9,6 +9,8 @@ import { RelativeGapRuntime } from '../../../processors/relativeGapRuntime';
 import { SectorTimingRuntime } from '../../../processors/sectorTimingRuntime';
 import { StandingsRuntime } from '../../../processors/standingsRuntime';
 import { RadioRuntime } from '../../../processors/radioRuntime';
+import { SessionTimingRuntime } from '../../../processors/sessionTimingRuntime';
+import { LapTimesRuntime } from '../../../processors/lapTimesRuntime';
 
 export async function publishIRacingSDKEvents(
   overlayManager: OverlayManager,
@@ -19,6 +21,10 @@ export async function publishIRacingSDKEvents(
   perfMetrics.startReporting();
 
   const bridge = generateMockData();
+  const lapTimesRuntime =
+    channelBus && lifecycle
+      ? new LapTimesRuntime(channelBus, lifecycle, perfMetrics)
+      : undefined;
   const carSpeedsRuntime = channelBus
     ? new CarSpeedsRuntime(channelBus, lifecycle, perfMetrics)
     : undefined;
@@ -46,24 +52,36 @@ export async function publishIRacingSDKEvents(
   const radioRuntime = channelBus
     ? new RadioRuntime(channelBus, lifecycle, perfMetrics)
     : undefined;
+  const sessionTimingRuntime =
+    channelBus && lapTimesRuntime
+      ? new SessionTimingRuntime(
+          channelBus,
+          lifecycle,
+          perfMetrics,
+          lapTimesRuntime
+        )
+      : undefined;
 
   bridge.onSessionData((session) => {
     carSpeedsRuntime?.onSession(session);
     referenceLapRuntime?.onSession(session);
     relativeGapRuntime?.onSession(session);
     sectorTimingRuntime?.onSession(session);
     standingsRuntime?.onSession(session);
+    sessionTimingRuntime?.onSession(session);
     overlayManager.publishMessage('sessionData', session);
   });
 
   bridge.onTelemetry((telemetry) => {
     perfMetrics.markStart('processTelemetry');
+    lapTimesRuntime?.onFrame(telemetry);
     carSpeedsRuntime?.onFrame(telemetry);
     referenceLapRuntime?.onFrame(telemetry);
     relativeGapRuntime?.onFrame(telemetry);
     sectorTimingRuntime?.onFrame(telemetry);
     standingsRuntime?.onFrame(telemetry);
     radioRuntime?.onFrame(telemetry);
+    sessionTimingRuntime?.onFrame(telemetry);
     perfMetrics.markStart('broadcast');
     overlayManager.publishMessage('telemetry', telemetry);
     perfMetrics.markEnd('broadcast');
@@ -80,10 +98,12 @@ export async function publishIRacingSDKEvents(
     ...bridge,
     stop: () => {
       carSpeedsRuntime?.dispose();
+      lapTimesRuntime?.dispose();
       relativeGapRuntime?.dispose();
       sectorTimingRuntime?.dispose();
       standingsRuntime?.dispose();
       radioRuntime?.dispose();
+      sessionTimingRuntime?.dispose();
       referenceLapRuntime?.dispose();
       perfMetrics.stopReporting();
       originalStop();

src/app/bridge/iracingSdk/mock-data/mockSdkBridge.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import type { Session, Telemetry } from '@irdashies/types';
+import { SessionState } from '@irdashies/types';
+import { SessionTimingProcessor } from './SessionTimingProcessor';
+
+const session = {
+  DriverInfo: {
+    DriverCarIdx: 1,
+    Drivers: [{ CarIdx: 0, CarClassEstLapTime: 60 }, { CarIdx: 1 }],
+  },
+  SessionInfo: {
+    Sessions: [{ SessionNum: 0, SessionType: 'Race', SessionLaps: 10 }],
+  },
+} as unknown as Session;
+
+const frame = (overrides: Record<string, unknown> = {}) =>
+  Object.fromEntries(
+    Object.entries({
+      SessionTime: 20,
+      SessionNum: 0,
+      SessionState: SessionState.Racing,
+      SessionTimeTotal: 600,
+      SessionTimeRemain: 604800,
+      CamCarIdx: 1,
+      LapDistPct: 0.25,
+      CarIdxLap: [2, 2],
+      CarIdxPosition: [1, 2],
+      CarIdxLapDistPct: [0.5, 0.25],
+      CarIdxBestLapTime: [60, 61],
+      CarIdxLapCompleted: [1, 1],
+      CarIdxLastLapTime: [60, 61],
+      ...overrides,
+    }).map(([key, value]) => [
+      key,
+      { value: Array.isArray(value) ? value : [value] },
+    ])
+  ) as unknown as Telemetry;
+
+describe('SessionTimingProcessor', () => {
+  it('projects fixed-lap timing for the focused car', () => {
+    const processor = new SessionTimingProcessor(() => [60, 61]);
+    processor.init(session);
+    processor.onFrame(frame());
+    expect(processor.snapshot()).toMatchObject({
+      sessionType: 'Race',
+      state: SessionState.Racing,
+      currentLap: 2,
+      totalLaps: 10,
+      isFixedLapRace: true,
+      totalRaceLaps: 10,
+      totalRaceTime: 600,
+      adjustedRaceTime: 600,
+      sessionNum: 0,
+    });
+  });
+
+  it('captures the green transition and freezes the lap at checkered', () => {
+    const processor = new SessionTimingProcessor();
+    processor.init(session);
+    processor.onFrame(
+      frame({ SessionTime: 10, SessionState: SessionState.Warmup })
+    );
+    processor.onFrame(
+      frame({ SessionTime: 11, SessionState: SessionState.Racing })
+    );
+    expect(processor.snapshot().greenFlagTimestamp).toBe(11);
+    processor.onFrame(
+      frame({
+        SessionTime: 12,
+        SessionState: SessionState.Checkered,
+        CarIdxLap: [3, 3],
+      })
+    );
+    processor.onFrame(
+      frame({
+        SessionTime: 13,
+        SessionState: SessionState.Checkered,
+        CarIdxLap: [4, 4],
+      })
+    );
+    expect(processor.snapshot().currentLap).toBe(3);
+  });
+
+  it('resets on session changes and ignores replay scrubbing', () => {
+    const processor = new SessionTimingProcessor();
+    processor.init(session);
+    processor.onFrame(frame());
+    processor.onLifecycle({ type: 'sessionNumChange' });
+    expect(processor.snapshot()).toMatchObject({
+      sessionNum: null,
+      currentLap: 0,
+    });
+    processor.onLifecycle({ type: 'enter', replay: true });
+    processor.onFrame(frame({ SessionTime: 30 }));
+    expect(processor.snapshot().currentLap).toBe(0);
+  });
+});