@hotlap.ai/telemetry 1.2.0 → 1.4.0

package/dist/telemetry-server.js

@@ -2,7 +2,7 @@
 // @bun
 import {
   createIRSDK
-} from "./index-t4qz2011.js";
+} from "./index-ndbp3f5t.js";
 import"./index-hxw291vy.js";
 import"./index-c5jf6rjt.js";
 import"./index-wb6ebd0j.js";
@@ -12,20 +12,98 @@ import"./index-ftpvnye9.js";
 var TELEMETRY_PORT = 32100;
 var TELEMETRY_RATE_HZ = 60;
 var SESSION_INFO_RATE_HZ = 1;
+var FIELD_PUBLISH_EVERY = 4;
+var PROTOCOL_VERSION = 3;
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
 var ir = createIRSDK();
 var tickCount = 0;
 var lastLap = -1;
 var lastSessionNum = -1;
-var sessionInfoSent = false;
-async function connectToIRacing() {
-  console.log("Connecting to iRacing...");
-  const connected = await ir.startup();
-  if (!connected) {
-    console.error("Failed to connect to iRacing. Make sure iRacing is running.");
-    return false;
-  }
-  console.log("Connected to iRacing!");
-  return true;
+var lastSessionInfoFingerprint = "";
+var telemetryKeys = [
+  "SessionTime",
+  "Lap",
+  "LapDistPct",
+  "Speed",
+  "RPM",
+  "Gear",
+  "Throttle",
+  "Brake",
+  "Clutch",
+  "SteeringWheelAngle",
+  "Lat",
+  "Lon",
+  "Alt",
+  "Yaw",
+  "Pitch",
+  "Roll",
+  "LapCurrentLapTime",
+  "LapLastLapTime",
+  "LapBestLapTime",
+  "LapDeltaToBestLap",
+  "FuelLevel",
+  "FuelLevelPct",
+  "OilTemp",
+  "WaterTemp",
+  "IsOnTrack",
+  "PlayerCarPosition",
+  "PlayerCarClassPosition",
+  "BrakeABSactive",
+  "dcBrakeBias",
+  "dcTractionControl",
+  "dcABS",
+  "LFtempCL",
+  "RFtempCL",
+  "LRtempCL",
+  "RRtempCL",
+  "LFpressure",
+  "RFpressure",
+  "LRpressure",
+  "RRpressure",
+  "LFwearM",
+  "RFwearM",
+  "LRwearM",
+  "RRwearM",
+  "SessionNum",
+  "OnPitRoad",
+  "PlayerCarIdx",
+  "CarIdxLapDistPct",
+  "SessionFlags",
+  "CarLeftRight"
+];
+var fieldKeys = [
+  "CarIdxPosition",
+  "CarIdxClassPosition",
+  "CarIdxLap",
+  "CarIdxLapCompleted",
+  "CarIdxEstTime",
+  "CarIdxF2Time",
+  "CarIdxOnPitRoad",
+  "CarIdxTrackSurface",
+  "CarIdxLastLapTime",
+  "CarIdxBestLapTime",
+  "SessionState",
+  "SessionTimeRemain",
+  "SessionLapsRemainEx"
+];
+var telemetryData = {};
+for (const key of telemetryKeys) {
+  telemetryData[key] = null;
+}
+var fieldData = {};
+for (const key of fieldKeys) {
+  fieldData[key] = null;
+}
+var roundedLapDistPct = new Array(64).fill(-1);
+function numArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function boolArray(value) {
+  return Array.isArray(value) ? value : [];
 }
 function getSessionInfo() {
   const weekendInfo = ir.getSessionInfo("WeekendInfo");
@@ -36,6 +114,7 @@ function getSessionInfo() {
   const sessionNum = ir.get("SessionNum") ?? 0;
   return {
     trackId: weekendInfo.TrackID,
+    sectors: getSectorBoundaries(),
     trackName: weekendInfo.TrackName,
     trackDisplayName: weekendInfo.TrackDisplayName,
     trackLength: weekendInfo.TrackLength,
@@ -50,70 +129,230 @@ function getSessionInfo() {
     tickRate: 60
   };
 }
+function getSectorBoundaries() {
+  const splitTimeInfo = ir.getSessionInfo("SplitTimeInfo");
+  const sectors = splitTimeInfo?.Sectors;
+  if (!Array.isArray(sectors))
+    return [];
+  return sectors.map((s) => ({ sectorNum: s.SectorNum ?? -1, startPct: s.SectorStartPct ?? -1 })).filter((s) => s.sectorNum >= 0 && s.startPct >= 0 && s.startPct < 1).sort((a, b) => a.startPct - b.startPct);
+}
+function readNullableNum(key) {
+  const value = telemetryData[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function getTelemetryFrame() {
-  ir.freezeVarBufferLatest();
+  ir.getMultipleInto(telemetryKeys, telemetryData);
   const frame = {
     tick: tickCount++,
-    sessionTime: ir.get("SessionTime") ?? 0,
-    lap: ir.get("Lap") ?? 0,
-    lapDistPct: ir.get("LapDistPct") ?? 0,
-    speed: ir.get("Speed") ?? 0,
-    rpm: ir.get("RPM") ?? 0,
-    gear: ir.get("Gear") ?? 0,
-    throttle: ir.get("Throttle") ?? 0,
-    brake: ir.get("Brake") ?? 0,
-    clutch: ir.get("Clutch") ?? 0,
-    steer: ir.get("SteeringWheelAngle") ?? 0,
-    lat: ir.get("Lat") ?? 0,
-    lon: ir.get("Lon") ?? 0,
-    alt: ir.get("Alt") ?? 0,
-    yaw: ir.get("Yaw") ?? 0,
-    pitch: ir.get("Pitch") ?? 0,
-    roll: ir.get("Roll") ?? 0,
-    lapCurrentLapTime: ir.get("LapCurrentLapTime") ?? 0,
-    lapLastLapTime: ir.get("LapLastLapTime") ?? 0,
-    lapBestLapTime: ir.get("LapBestLapTime") ?? 0,
-    lapDeltaToBestLap: ir.get("LapDeltaToBestLap") ?? 0,
-    fuelLevel: ir.get("FuelLevel") ?? 0,
-    fuelLevelPct: ir.get("FuelLevelPct") ?? 0,
-    oilTemp: ir.get("OilTemp") ?? 0,
-    waterTemp: ir.get("WaterTemp") ?? 0,
-    isOnTrack: ir.get("IsOnTrack") ?? false,
-    playerPosition: ir.get("PlayerCarPosition") ?? 0,
-    playerClassPosition: ir.get("PlayerCarClassPosition") ?? 0,
-    brakeABSactive: ir.get("BrakeABSactive") ?? false,
-    dcBrakeBias: ir.get("dcBrakeBias") ?? 0,
-    dcTractionControl: ir.get("dcTractionControl") ?? 0,
-    dcABS: ir.get("dcABS") ?? 0,
-    tireTempLF: ir.get("LFtempCL") ?? 0,
-    tireTempRF: ir.get("RFtempCL") ?? 0,
-    tireTempLR: ir.get("LRtempCL") ?? 0,
-    tireTempRR: ir.get("RRtempCL") ?? 0
+    sessionTime: telemetryData.SessionTime ?? 0,
+    lap: telemetryData.Lap ?? 0,
+    lapDistPct: telemetryData.LapDistPct ?? 0,
+    speed: telemetryData.Speed ?? 0,
+    rpm: telemetryData.RPM ?? 0,
+    gear: telemetryData.Gear ?? 0,
+    throttle: telemetryData.Throttle ?? 0,
+    brake: telemetryData.Brake ?? 0,
+    clutch: telemetryData.Clutch ?? 0,
+    steer: telemetryData.SteeringWheelAngle ?? 0,
+    lat: telemetryData.Lat ?? 0,
+    lon: telemetryData.Lon ?? 0,
+    alt: telemetryData.Alt ?? 0,
+    yaw: telemetryData.Yaw ?? 0,
+    pitch: telemetryData.Pitch ?? 0,
+    roll: telemetryData.Roll ?? 0,
+    lapCurrentLapTime: telemetryData.LapCurrentLapTime ?? 0,
+    lapLastLapTime: telemetryData.LapLastLapTime ?? 0,
+    lapBestLapTime: telemetryData.LapBestLapTime ?? 0,
+    lapDeltaToBestLap: telemetryData.LapDeltaToBestLap ?? 0,
+    fuelLevel: telemetryData.FuelLevel ?? 0,
+    fuelLevelPct: telemetryData.FuelLevelPct ?? 0,
+    oilTemp: telemetryData.OilTemp ?? 0,
+    waterTemp: telemetryData.WaterTemp ?? 0,
+    isOnTrack: telemetryData.IsOnTrack ?? false,
+    playerPosition: telemetryData.PlayerCarPosition ?? 0,
+    playerClassPosition: telemetryData.PlayerCarClassPosition ?? 0,
+    brakeABSactive: telemetryData.BrakeABSactive ?? false,
+    dcBrakeBias: telemetryData.dcBrakeBias ?? 0,
+    dcTractionControl: telemetryData.dcTractionControl ?? 0,
+    dcABS: telemetryData.dcABS ?? 0,
+    tireTempLF: telemetryData.LFtempCL ?? 0,
+    tireTempRF: telemetryData.RFtempCL ?? 0,
+    tireTempLR: telemetryData.LRtempCL ?? 0,
+    tireTempRR: telemetryData.RRtempCL ?? 0,
+    tirePressureLF: readNullableNum("LFpressure"),
+    tirePressureRF: readNullableNum("RFpressure"),
+    tirePressureLR: readNullableNum("LRpressure"),
+    tirePressureRR: readNullableNum("RRpressure"),
+    tireWearLF: readNullableNum("LFwearM"),
+    tireWearRF: readNullableNum("RFwearM"),
+    tireWearLR: readNullableNum("LRwearM"),
+    tireWearRR: readNullableNum("RRwearM"),
+    sessionNum: telemetryData.SessionNum ?? 0,
+    onPitRoad: telemetryData.OnPitRoad ?? false,
+    playerCarIdx: telemetryData.PlayerCarIdx ?? -1,
+    carIdxLapDistPct: roundCarIdxLapDistPct(numArray(telemetryData.CarIdxLapDistPct)),
+    sessionFlags: (telemetryData.SessionFlags ?? 0) >>> 0,
+    carLeftRight: telemetryData.CarLeftRight ?? 0
   };
-  ir.unfreezeVarBufferLatest();
   return frame;
 }
+function roundCarIdxLapDistPct(raw) {
+  for (let i = 0;i < roundedLapDistPct.length; i++) {
+    const v = raw[i];
+    roundedLapDistPct[i] = v == null || v < 0 ? -1 : Math.round(v * 1e4) / 1e4;
+  }
+  return roundedLapDistPct;
+}
+var cachedPaceCarIdx = -1;
+function getFieldData(frame) {
+  ir.getMultipleInto(fieldKeys, fieldData);
+  const round3 = (v) => Math.round(v * 1000) / 1000;
+  return {
+    tick: frame.tick,
+    sessionTime: frame.sessionTime,
+    sessionNum: frame.sessionNum,
+    sessionState: fieldData.SessionState ?? 0,
+    sessionTimeRemain: fieldData.SessionTimeRemain ?? -1,
+    sessionLapsRemain: fieldData.SessionLapsRemainEx ?? -1,
+    playerCarIdx: frame.playerCarIdx,
+    paceCarIdx: cachedPaceCarIdx,
+    position: numArray(fieldData.CarIdxPosition),
+    classPosition: numArray(fieldData.CarIdxClassPosition),
+    lap: numArray(fieldData.CarIdxLap),
+    lapCompleted: numArray(fieldData.CarIdxLapCompleted),
+    lapDistPct: frame.carIdxLapDistPct,
+    estTime: numArray(fieldData.CarIdxEstTime).map(round3),
+    f2Time: numArray(fieldData.CarIdxF2Time).map(round3),
+    onPitRoad: boolArray(fieldData.CarIdxOnPitRoad),
+    trackSurface: numArray(fieldData.CarIdxTrackSurface),
+    lastLapTime: numArray(fieldData.CarIdxLastLapTime).map(round3),
+    bestLapTime: numArray(fieldData.CarIdxBestLapTime).map(round3)
+  };
+}
+function computeSof(ratings) {
+  if (ratings.length === 0)
+    return 0;
+  const LN2 = Math.log(2);
+  const sum = ratings.reduce((acc, r) => acc + Math.pow(2, -r / 1600), 0);
+  if (sum <= 0)
+    return 0;
+  return Math.round(1600 / LN2 * Math.log(ratings.length / sum));
+}
+function buildSessionState(sessionInfoUpdate) {
+  const weekendInfo = ir.getSessionInfo("WeekendInfo");
+  const driverInfo = ir.getSessionInfo("DriverInfo");
+  if (!weekendInfo || !driverInfo)
+    return null;
+  const sessionNum = ir.get("SessionNum") ?? 0;
+  cachedPaceCarIdx = driverInfo.PaceCarIdx ?? -1;
+  const drivers = [];
+  for (const d of driverInfo.Drivers ?? []) {
+    if (!d || d.CarIdx == null || d.CarIdx < 0)
+      continue;
+    if (d.IsSpectator || d.CarIsPaceCar)
+      continue;
+    drivers.push({
+      carIdx: d.CarIdx,
+      userName: d.UserName ?? "Unknown",
+      teamName: d.TeamName || undefined,
+      carNumber: d.CarNumber ?? "",
+      carClassId: d.CarClassID ?? 0,
+      carClassShortName: d.CarClassShortName ?? "",
+      carClassColor: d.CarClassColor ?? 0,
+      carClassRelSpeed: d.CarClassRelSpeed ?? 0,
+      carClassEstLapTime: d.CarClassEstLapTime ?? 0,
+      iRating: d.IRating ?? 0,
+      licString: d.LicString ?? "",
+      licColor: d.LicColor ?? 0,
+      incidentCount: d.CurDriverIncidentCount ?? 0
+    });
+  }
+  const byClass = new Map;
+  for (const d of drivers) {
+    const list = byClass.get(d.carClassId);
+    if (list)
+      list.push(d);
+    else
+      byClass.set(d.carClassId, [d]);
+  }
+  const classes = [...byClass.entries()].map(([classId, list]) => ({
+    classId,
+    shortName: list[0]?.carClassShortName ?? "",
+    color: list[0]?.carClassColor ?? 0,
+    sof: computeSof(list.map((d) => d.iRating).filter((r) => r > 0)),
+    carCount: list.length
+  }));
+  const sessionsInfo = ir.getSessionInfo("SessionInfo");
+  const session = sessionsInfo?.Sessions?.find((s) => s.SessionNum === sessionNum) ?? sessionsInfo?.Sessions?.[sessionsInfo.Sessions.length - 1];
+  return {
+    sessionInfoUpdate,
+    subSessionId: weekendInfo.SubSessionID ?? 0,
+    trackId: weekendInfo.TrackID,
+    sessionNum,
+    sessionType: session?.SessionType ?? weekendInfo.EventType ?? "Unknown",
+    sessionLaps: session?.SessionLaps ?? "unlimited",
+    sessionTimeTotal: session?.SessionTime ?? "unlimited",
+    drivers,
+    classes,
+    results: (session?.ResultsPositions ?? []).map((r) => ({
+      carIdx: r.CarIdx ?? -1,
+      position: r.Position ?? 0,
+      classPosition: r.ClassPosition ?? 0,
+      fastestTime: r.FastestTime ?? -1,
+      lastTime: r.LastTime ?? -1,
+      lapsComplete: r.LapsComplete ?? 0,
+      incidents: r.Incidents ?? 0
+    })),
+    fastestLap: (session?.ResultsFastestLap ?? []).map((f) => ({
+      carIdx: f.CarIdx ?? -1,
+      fastestTime: f.FastestTime ?? -1
+    }))
+  };
+}
+var LAP_CHANGE_SETTLE_TICKS = 60;
+var pendingLapChange = null;
+function emitLapChange(pending, lapTime, server) {
+  const lapChangeMsg = {
+    type: "lap_change",
+    data: {
+      fromLap: pending.fromLap,
+      toLap: pending.toLap,
+      lapTime,
+      sessionNum: pending.sessionNum
+    }
+  };
+  server.publish("telemetry", JSON.stringify(lapChangeMsg));
+  console.log(`Lap ${pending.fromLap} completed: ${formatLapTime(lapTime)}`);
+}
 function checkLapChange(frame, server) {
   const currentLap = frame.lap;
   const currentSessionNum = ir.get("SessionNum") ?? 0;
   if (currentSessionNum !== lastSessionNum) {
     lastSessionNum = currentSessionNum;
     lastLap = currentLap;
-    sessionInfoSent = false;
+    lastSessionInfoFingerprint = "";
+    pendingLapChange = null;
     return;
   }
+  if (pendingLapChange) {
+    pendingLapChange.ticksWaited++;
+    const settled = frame.lapLastLapTime > 0 && frame.lapLastLapTime !== pendingLapChange.lastLapTimeAtChange;
+    if (settled || pendingLapChange.ticksWaited >= LAP_CHANGE_SETTLE_TICKS) {
+      emitLapChange(pendingLapChange, frame.lapLastLapTime, server);
+      pendingLapChange = null;
+    }
+  }
   if (currentLap !== lastLap && lastLap !== -1) {
-    const lapChangeMsg = {
-      type: "lap_change",
-      data: {
-        fromLap: lastLap,
-        toLap: currentLap,
-        lapTime: frame.lapLastLapTime,
-        sessionNum: currentSessionNum
-      }
+    if (pendingLapChange) {
+      emitLapChange(pendingLapChange, frame.lapLastLapTime, server);
+    }
+    pendingLapChange = {
+      fromLap: lastLap,
+      toLap: currentLap,
+      sessionNum: currentSessionNum,
+      ticksWaited: 0,
+      lastLapTimeAtChange: frame.lapLastLapTime
     };
-    server.publish("telemetry", JSON.stringify(lapChangeMsg));
-    console.log(`Lap ${lastLap} completed: ${formatLapTime(frame.lapLastLapTime)}`);
   }
   lastLap = currentLap;
 }
@@ -124,95 +363,192 @@ function formatLapTime(seconds) {
   const secs = (seconds % 60).toFixed(3).padStart(6, "0");
   return `${mins}:${secs}`;
 }
+var cachedSessionStateJson = null;
 async function main() {
-  const connected = await connectToIRacing();
-  if (!connected) {
-    process.exit(1);
-  }
-  const sessionInfo = getSessionInfo();
-  if (sessionInfo) {
-    console.log(`Track: ${sessionInfo.trackDisplayName}`);
-    console.log(`Driver: ${sessionInfo.driverName}`);
-    console.log(`Car: ${sessionInfo.carName} #${sessionInfo.carNumber}`);
-  }
-  const server = Bun.serve({
-    port: TELEMETRY_PORT,
-    fetch(req, server2) {
-      const url = new URL(req.url);
-      if (url.pathname === "/ws" || req.headers.get("upgrade") === "websocket") {
-        const success = server2.upgrade(req);
-        if (success) {
-          return;
-        }
-        return new Response("WebSocket upgrade failed", { status: 400 });
-      }
-      if (url.pathname === "/status") {
-        return Response.json({
-          connected: ir.isConnected,
-          initialized: ir.isInitialized,
-          sessionInfo: getSessionInfo()
-        });
-      }
-      if (url.pathname === "/health") {
-        return new Response("OK", { status: 200 });
-      }
-      return new Response("Not found", { status: 404 });
-    },
-    websocket: {
-      open(ws) {
-        console.log("Client connected");
-        ws.subscribe("telemetry");
-        const statusMsg = {
-          type: "status",
-          data: {
-            connected: ir.isConnected,
-            initialized: ir.isInitialized
+  const server = (() => {
+    try {
+      return Bun.serve({
+        port: TELEMETRY_PORT,
+        hostname: "127.0.0.1",
+        fetch(req, server2) {
+          const url = new URL(req.url);
+          if (url.pathname === "/ws" || req.headers.get("upgrade") === "websocket") {
+            const success = server2.upgrade(req);
+            if (success) {
+              return;
+            }
+            return new Response("WebSocket upgrade failed", { status: 400, headers: CORS_HEADERS });
+          }
+          if (req.method === "OPTIONS") {
+            return new Response(null, { status: 204, headers: CORS_HEADERS });
+          }
+          if (url.pathname === "/status") {
+            return Response.json({
+              connected: ir.isConnected,
+              initialized: ir.isInitialized,
+              protocol: PROTOCOL_VERSION,
+              sessionInfo: getSessionInfo()
+            }, { headers: CORS_HEADERS });
           }
-        };
-        ws.send(JSON.stringify(statusMsg));
-        const sessionInfo2 = getSessionInfo();
-        if (sessionInfo2) {
-          const sessionMsg = {
-            type: "session_info",
-            data: sessionInfo2
-          };
-          ws.send(JSON.stringify(sessionMsg));
+          if (url.pathname === "/health") {
+            return Response.json({ ok: true, protocol: PROTOCOL_VERSION }, { headers: CORS_HEADERS });
+          }
+          if (url.pathname === "/shutdown" && req.method === "POST") {
+            console.log("Shutdown requested by client");
+            setTimeout(() => {
+              ir.shutdown();
+              process.exit(0);
+            }, 50);
+            return new Response("shutting down", { headers: CORS_HEADERS });
+          }
+          return new Response("Not found", { status: 404, headers: CORS_HEADERS });
+        },
+        websocket: {
+          open(ws) {
+            console.log("Client connected");
+            ws.subscribe("telemetry");
+            const statusMsg = {
+              type: "status",
+              data: {
+                connected: ir.isConnected,
+                initialized: ir.isInitialized
+              }
+            };
+            ws.send(JSON.stringify(statusMsg));
+            const sessionInfo = getSessionInfo();
+            if (sessionInfo) {
+              const sessionMsg = {
+                type: "session_info",
+                data: sessionInfo
+              };
+              ws.send(JSON.stringify(sessionMsg));
+            }
+            if (cachedSessionStateJson) {
+              ws.send(cachedSessionStateJson);
+            }
+          },
+          close(ws) {
+            console.log("Client disconnected");
+          },
+          message(ws, msg) {}
         }
-      },
-      close(ws) {
-        console.log("Client disconnected");
-      },
-      message(ws, msg) {}
+      });
+    } catch (err) {
+      console.error("Could not bind port \u2014 another sidecar instance is likely running:", err);
+      process.exit(0);
     }
-  });
+  })();
   console.log(`
 Telemetry server running at ws://127.0.0.1:${server.port}/ws`);
   console.log(`Status endpoint: http://127.0.0.1:${server.port}/status`);
-  console.log(`Waiting for connections...
+  console.log(`Waiting for iRacing...
 `);
+  const REATTACH_AFTER_MS = 1e4;
+  let startupInFlight = false;
+  let wasConnected = false;
+  let disconnectedSince = null;
+  const ensureIRacing = async () => {
+    if (startupInFlight)
+      return;
+    if (ir.isInitialized) {
+      if (ir.isConnected) {
+        disconnectedSince = null;
+        return;
+      }
+      disconnectedSince ??= Date.now();
+      if (Date.now() - disconnectedSince < REATTACH_AFTER_MS)
+        return;
+      console.log("iRacing gone \u2014 detaching and waiting for a new session");
+      ir.shutdown();
+      lastSessionInfoFingerprint = "";
+      cachedSessionStateJson = null;
+      disconnectedSince = null;
+    }
+    startupInFlight = true;
+    try {
+      const ok = await ir.startup();
+      if (ok) {
+        console.log("Connected to iRacing!");
+        const sessionInfo = getSessionInfo();
+        if (sessionInfo) {
+          console.log(`Track: ${sessionInfo.trackDisplayName}`);
+          console.log(`Driver: ${sessionInfo.driverName}`);
+          console.log(`Car: ${sessionInfo.carName} #${sessionInfo.carNumber}`);
+        }
+      }
+    } catch (err) {
+      console.error("iRacing startup attempt failed:", err);
+    } finally {
+      startupInFlight = false;
+    }
+  };
+  await ensureIRacing();
+  setInterval(ensureIRacing, 2000);
   let lastSessionInfoTime = 0;
+  let fieldTickCounter = 0;
+  let lastSessionStateCheck = 0;
+  let lastSessionStatePublish = 0;
+  let lastPublishedSessionInfoUpdate = -1;
   setInterval(() => {
-    if (!ir.isConnected) {
+    const connected = ir.isConnected && ir.isInitialized;
+    if (connected !== wasConnected) {
+      wasConnected = connected;
+      const statusMsg = {
+        type: "status",
+        data: { connected, initialized: ir.isInitialized }
+      };
+      server.publish("telemetry", JSON.stringify(statusMsg));
+    }
+    if (!connected) {
       return;
     }
+    ir.freezeVarBufferLatest();
     const frame = getTelemetryFrame();
+    fieldTickCounter++;
+    const field = fieldTickCounter % FIELD_PUBLISH_EVERY === 0 ? getFieldData(frame) : null;
+    ir.unfreezeVarBufferLatest();
     checkLapChange(frame, server);
     const telemetryMsg = {
       type: "telemetry",
       data: frame
     };
     server.publish("telemetry", JSON.stringify(telemetryMsg));
+    if (field) {
+      const fieldMsg = { type: "field", data: field };
+      server.publish("telemetry", JSON.stringify(fieldMsg));
+    }
     const now = Date.now();
     if (now - lastSessionInfoTime > 1000 / SESSION_INFO_RATE_HZ) {
       lastSessionInfoTime = now;
-      const sessionInfo2 = getSessionInfo();
-      if (sessionInfo2 && !sessionInfoSent) {
-        const sessionMsg = {
-          type: "session_info",
-          data: sessionInfo2
-        };
-        server.publish("telemetry", JSON.stringify(sessionMsg));
-        sessionInfoSent = true;
+      const weekendInfo = ir.getSessionInfo("WeekendInfo");
+      if (weekendInfo) {
+        const sessionNum = ir.get("SessionNum") ?? 0;
+        const fingerprint = `${weekendInfo.SubSessionID ?? 0}:${sessionNum}:${weekendInfo.TrackID ?? 0}`;
+        if (fingerprint !== lastSessionInfoFingerprint) {
+          const sessionInfo = getSessionInfo();
+          if (sessionInfo) {
+            const sessionMsg = {
+              type: "session_info",
+              data: sessionInfo
+            };
+            server.publish("telemetry", JSON.stringify(sessionMsg));
+            lastSessionInfoFingerprint = fingerprint;
+          }
+        }
+      }
+    }
+    if (now - lastSessionStateCheck > 500) {
+      lastSessionStateCheck = now;
+      const counter = ir.sessionInfoUpdate;
+      if (counter !== lastPublishedSessionInfoUpdate && now - lastSessionStatePublish >= 1000) {
+        const state = buildSessionState(counter);
+        if (state) {
+          const stateMsg = { type: "session_state", data: state };
+          cachedSessionStateJson = JSON.stringify(stateMsg);
+          server.publish("telemetry", cachedSessionStateJson);
+          lastPublishedSessionInfoUpdate = counter;
+          lastSessionStatePublish = now;
+        }
       }
     }
   }, 1000 / TELEMETRY_RATE_HZ);