@hotlap.ai/telemetry 1.0.0 → 1.1.0

package/dist/index-t4qz2011.js

@@ -0,0 +1,418 @@
+// @bun
+import {
+  $parse
+} from "./index-hxw291vy.js";
+import {
+  getLatestVarBuffer,
+  parseHeader,
+  parseVarHeaders,
+  readString,
+  readVarValue
+} from "./index-c5jf6rjt.js";
+import {
+  BroadcastMsg,
+  CameraState,
+  ChatCommandMode,
+  FFBCommandMode,
+  PitCommandMode,
+  ReloadTexturesMode,
+  RpyPosMode,
+  RpySrchMode,
+  RpyStateMode,
+  SIM_STATUS_URL,
+  StatusField,
+  TelemCommandMode,
+  VideoCaptureMode
+} from "./index-wb6ebd0j.js";
+import {
+  __require
+} from "./index-ftpvnye9.js";
+
+// src/live.ts
+var kernel32 = null;
+var user32 = null;
+function loadKernel32() {
+  const { dlopen, FFIType, suffix } = __require("bun:ffi");
+  return dlopen(`kernel32.${suffix}`, {
+    OpenEventW: {
+      args: [FFIType.u32, FFIType.bool, FFIType.ptr],
+      returns: FFIType.ptr
+    },
+    OpenFileMappingW: {
+      args: [FFIType.u32, FFIType.bool, FFIType.ptr],
+      returns: FFIType.ptr
+    },
+    MapViewOfFile: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u32, FFIType.u32],
+      returns: FFIType.ptr
+    },
+    UnmapViewOfFile: {
+      args: [FFIType.ptr],
+      returns: FFIType.bool
+    },
+    CloseHandle: {
+      args: [FFIType.ptr],
+      returns: FFIType.bool
+    },
+    WaitForSingleObject: {
+      args: [FFIType.ptr, FFIType.u32],
+      returns: FFIType.u32
+    }
+  });
+}
+function loadUser32() {
+  const { dlopen, FFIType, suffix } = __require("bun:ffi");
+  return dlopen(`user32.${suffix}`, {
+    RegisterWindowMessageW: {
+      args: [FFIType.ptr],
+      returns: FFIType.u32
+    },
+    SendNotifyMessageW: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u32],
+      returns: FFIType.bool
+    }
+  });
+}
+var FILE_MAP_READ = 4;
+var SYNCHRONIZE = 1048576;
+var WAIT_OBJECT_0 = 0;
+var HWND_BROADCAST = 65535;
+var DATA_VALID_EVENT_NAME = "Local\\IRSDKDataValidEvent";
+var MEMMAPFILE = "Local\\IRSDKMemMapFileName";
+var MEMMAPFILESIZE = 1164 * 1024;
+var BROADCASTMSGNAME = "IRSDK_BROADCASTMSG";
+function toWideString(str) {
+  const buf = new Uint8Array((str.length + 1) * 2);
+  for (let i = 0;i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    buf[i * 2] = code & 255;
+    buf[i * 2 + 1] = code >> 8 & 255;
+  }
+  return buf;
+}
+function ensureFFILoaded() {
+  if (process.platform !== "win32") {
+    return false;
+  }
+  try {
+    if (!kernel32)
+      kernel32 = loadKernel32();
+    if (!user32)
+      user32 = loadUser32();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class IRSDK {
+  parseYamlAsync;
+  sharedMemPtr = null;
+  sharedMemBuffer = null;
+  sharedMemView = null;
+  fileMappingHandle = null;
+  dataValidEvent = null;
+  header = null;
+  varHeaders = null;
+  varHeadersNames = null;
+  sessionInfoCache = new Map;
+  broadcastMsgId = null;
+  lastSessionInfoUpdate = 0;
+  workaroundConnectedState = 0;
+  frozenBuffer = null;
+  frozenView = null;
+  frozenBufOffset = 0;
+  testMode = false;
+  isInitialized = false;
+  constructor(options = {}) {
+    this.parseYamlAsync = options.parseYamlAsync ?? false;
+  }
+  get isConnected() {
+    if (!this.header)
+      return false;
+    if (this.header.status === StatusField.STATUS_CONNECTED) {
+      this.workaroundConnectedState = 0;
+    }
+    if (this.workaroundConnectedState === 0 && this.header.status !== StatusField.STATUS_CONNECTED) {
+      this.workaroundConnectedState = 1;
+    }
+    if (this.workaroundConnectedState === 1 && this.get("SessionNum") === null) {
+      this.workaroundConnectedState = 2;
+    }
+    if (this.workaroundConnectedState === 2 && this.get("SessionNum") !== null) {
+      this.workaroundConnectedState = 3;
+    }
+    return (this.dataValidEvent !== null || this.testMode) && (this.header.status === StatusField.STATUS_CONNECTED || this.workaroundConnectedState === 3);
+  }
+  get sessionInfoUpdate() {
+    return this.header?.sessionInfoUpdate ?? 0;
+  }
+  get varHeaderNames() {
+    if (!this.varHeaders)
+      return null;
+    if (!this.varHeadersNames) {
+      this.varHeadersNames = Array.from(this.varHeaders.keys());
+    }
+    return this.varHeadersNames;
+  }
+  async startup(testFile, dumpTo) {
+    if (testFile) {
+      return this.startupFromFile(testFile, dumpTo);
+    }
+    if (!ensureFFILoaded() || !kernel32) {
+      console.error("FFI not available - live telemetry requires Windows");
+      return false;
+    }
+    const simRunning = await this.checkSimStatus();
+    if (!simRunning)
+      return false;
+    const { ptr, toArrayBuffer } = __require("bun:ffi");
+    const eventNameWide = toWideString(DATA_VALID_EVENT_NAME);
+    this.dataValidEvent = kernel32.symbols.OpenEventW(SYNCHRONIZE, false, ptr(eventNameWide));
+    if (!this.waitValidDataEvent()) {
+      this.dataValidEvent = null;
+      return false;
+    }
+    const fileNameWide = toWideString(MEMMAPFILE);
+    this.fileMappingHandle = kernel32.symbols.OpenFileMappingW(FILE_MAP_READ, false, ptr(fileNameWide));
+    if (!this.fileMappingHandle)
+      return false;
+    this.sharedMemPtr = kernel32.symbols.MapViewOfFile(this.fileMappingHandle, FILE_MAP_READ, 0, 0, MEMMAPFILESIZE);
+    if (!this.sharedMemPtr) {
+      kernel32.symbols.CloseHandle(this.fileMappingHandle);
+      this.fileMappingHandle = null;
+      return false;
+    }
+    const arrayBuffer = toArrayBuffer(this.sharedMemPtr, 0, MEMMAPFILESIZE);
+    this.sharedMemBuffer = new Uint8Array(arrayBuffer);
+    this.sharedMemView = new DataView(arrayBuffer);
+    if (this.sharedMemView) {
+      if (dumpTo) {
+        await Bun.write(dumpTo, this.sharedMemBuffer);
+      }
+      this.header = parseHeader(this.sharedMemView);
+      this.isInitialized = this.header.version >= 1 && this.header.varBuf.length > 0;
+      if (this.isInitialized) {
+        this.varHeaders = parseVarHeaders(this.sharedMemView, this.sharedMemBuffer, this.header);
+      }
+    }
+    return this.isInitialized;
+  }
+  async startupFromFile(testFile, dumpTo) {
+    this.testMode = true;
+    const file = Bun.file(testFile);
+    const arrayBuffer = await file.arrayBuffer();
+    this.sharedMemBuffer = new Uint8Array(arrayBuffer);
+    this.sharedMemView = new DataView(arrayBuffer);
+    if (dumpTo) {
+      await Bun.write(dumpTo, this.sharedMemBuffer);
+    }
+    this.header = parseHeader(this.sharedMemView);
+    this.isInitialized = this.header.version >= 1 && this.header.varBuf.length > 0;
+    if (this.isInitialized) {
+      this.varHeaders = parseVarHeaders(this.sharedMemView, this.sharedMemBuffer, this.header);
+    }
+    return this.isInitialized;
+  }
+  shutdown() {
+    this.isInitialized = false;
+    this.lastSessionInfoUpdate = 0;
+    if (kernel32) {
+      if (this.sharedMemPtr) {
+        kernel32.symbols.UnmapViewOfFile(this.sharedMemPtr);
+        this.sharedMemPtr = null;
+      }
+      if (this.fileMappingHandle) {
+        kernel32.symbols.CloseHandle(this.fileMappingHandle);
+        this.fileMappingHandle = null;
+      }
+      if (this.dataValidEvent) {
+        kernel32.symbols.CloseHandle(this.dataValidEvent);
+        this.dataValidEvent = null;
+      }
+    }
+    this.sharedMemBuffer = null;
+    this.sharedMemView = null;
+    this.header = null;
+    this.varHeaders = null;
+    this.varHeadersNames = null;
+    this.sessionInfoCache.clear();
+    this.broadcastMsgId = null;
+    this.frozenBuffer = null;
+    this.frozenView = null;
+    this.testMode = false;
+  }
+  get(key) {
+    if (!this.header || !this.varHeaders)
+      return null;
+    const varHeader = this.varHeaders.get(key);
+    if (!varHeader) {
+      return this.getSessionInfo(key);
+    }
+    const view = this.frozenView ?? this.sharedMemView;
+    if (!view)
+      return null;
+    const varBuf = this.frozenView ? { bufOffset: this.frozenBufOffset } : getLatestVarBuffer(this.header.varBuf);
+    const offset = varBuf.bufOffset + varHeader.offset;
+    return readVarValue(view, offset, varHeader.type, varHeader.count);
+  }
+  freezeVarBufferLatest() {
+    this.unfreezeVarBufferLatest();
+    if (!this.header || !this.sharedMemBuffer)
+      return;
+    this.waitValidDataEvent();
+    const varBuf = this.header.varBuf.reduce((a, b) => a.tickCount > b.tickCount ? a : b);
+    this.frozenBufOffset = 0;
+    this.frozenBuffer = this.sharedMemBuffer.slice(varBuf.bufOffset, varBuf.bufOffset + this.header.bufLen);
+    this.frozenView = new DataView(this.frozenBuffer.buffer);
+  }
+  unfreezeVarBufferLatest() {
+    this.frozenBuffer = null;
+    this.frozenView = null;
+    this.frozenBufOffset = 0;
+  }
+  async checkSimStatus() {
+    try {
+      const response = await fetch(SIM_STATUS_URL);
+      const text = await response.text();
+      return text.includes("running:1");
+    } catch {
+      return false;
+    }
+  }
+  waitValidDataEvent() {
+    if (!kernel32)
+      return true;
+    if (this.dataValidEvent) {
+      return kernel32.symbols.WaitForSingleObject(this.dataValidEvent, 32) === WAIT_OBJECT_0;
+    }
+    return true;
+  }
+  getSessionInfo(key) {
+    if (!this.header || !this.sharedMemBuffer)
+      return null;
+    if (this.lastSessionInfoUpdate < this.header.sessionInfoUpdate) {
+      this.lastSessionInfoUpdate = this.header.sessionInfoUpdate;
+      for (const [k, v] of this.sessionInfoCache) {
+        if (v.data) {
+          this.sessionInfoCache.set(k, { ...v, data: null });
+        }
+      }
+    }
+    const cached = this.sessionInfoCache.get(key);
+    if (cached?.data) {
+      return cached.data;
+    }
+    const start = this.header.sessionInfoOffset;
+    const len = this.header.sessionInfoLen;
+    const raw = readString(this.sharedMemBuffer, start, len);
+    const sectionMatch = raw.match(new RegExp(`
+${key}:
+([\\s\\S]*?)(?=
+
+|$)`));
+    if (!sectionMatch)
+      return null;
+    try {
+      const sectionYaml = `${key}:
+${sectionMatch[1]}`;
+      const cleaned = this.cleanYaml(sectionYaml);
+      const parsed = $parse(cleaned);
+      const result = parsed?.[key] ?? null;
+      this.sessionInfoCache.set(key, { data: result, update: this.lastSessionInfoUpdate });
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  cleanYaml(yaml) {
+    let cleaned = yaml.replace(/[\x81\x8D\x8F\x90\x9D]/g, " ").replace(/[^\x09\x0A\x0D\x20-\x7E\xA0-\xFF]/g, "");
+    cleaned = cleaned.replace(/((?:DriverSetupName|UserName|TeamName|AbbrevName|Initials): )(.*)/g, (_, prefix, value) => {
+      const escaped = value.replace(/["\\]/g, "\\$&");
+      return `${prefix}"${escaped}"`;
+    });
+    cleaned = cleaned.replace(/(\w+: )(,.*)/g, '$1"$2"');
+    return cleaned;
+  }
+  getBroadcastMsgId() {
+    if (!user32)
+      return 0;
+    if (this.broadcastMsgId === null) {
+      const { ptr } = __require("bun:ffi");
+      const msgNameWide = toWideString(BROADCASTMSGNAME);
+      this.broadcastMsgId = user32.symbols.RegisterWindowMessageW(ptr(msgNameWide));
+    }
+    return this.broadcastMsgId;
+  }
+  broadcastMsg(broadcastType, var1 = 0, var2 = 0, var3 = 0) {
+    if (!user32)
+      return false;
+    return user32.symbols.SendNotifyMessageW(HWND_BROADCAST, this.getBroadcastMsgId(), (broadcastType | var1 << 16) >>> 0, (var2 | var3 << 16) >>> 0);
+  }
+  padCarNum(num) {
+    const numStr = String(num);
+    const numLen = numStr.length;
+    let zero = numLen - numStr.replace(/^0+/, "").length;
+    if (zero > 0 && numLen === zero)
+      zero--;
+    const numVal = parseInt(numStr, 10);
+    if (zero) {
+      const numPlace = numVal > 99 ? 3 : numVal > 9 ? 2 : 1;
+      return numVal + 1000 * (numPlace + zero);
+    }
+    return numVal;
+  }
+  camSwitchPos(position = 0, group = 1, camera = 0) {
+    return this.broadcastMsg(BroadcastMsg.CAM_SWITCH_POS, position, group, camera);
+  }
+  camSwitchNum(carNumber = "1", group = 1, camera = 0) {
+    return this.broadcastMsg(BroadcastMsg.CAM_SWITCH_NUM, this.padCarNum(carNumber), group, camera);
+  }
+  camSetState(cameraState = CameraState.CAM_TOOL_ACTIVE) {
+    return this.broadcastMsg(BroadcastMsg.CAM_SET_STATE, cameraState);
+  }
+  replaySetPlaySpeed(speed = 0, slowMotion = false) {
+    return this.broadcastMsg(BroadcastMsg.REPLAY_SET_PLAY_SPEED, speed, slowMotion ? 1 : 0);
+  }
+  replaySetPlayPosition(posMode = RpyPosMode.BEGIN, frameNum = 0) {
+    return this.broadcastMsg(BroadcastMsg.REPLAY_SET_PLAY_POSITION, posMode, frameNum);
+  }
+  replaySearch(searchMode = RpySrchMode.TO_START) {
+    return this.broadcastMsg(BroadcastMsg.REPLAY_SEARCH, searchMode);
+  }
+  replaySetState(stateMode = RpyStateMode.ERASE_TAPE) {
+    return this.broadcastMsg(BroadcastMsg.REPLAY_SET_STATE, stateMode);
+  }
+  reloadAllTextures() {
+    return this.broadcastMsg(BroadcastMsg.RELOAD_TEXTURES, ReloadTexturesMode.ALL);
+  }
+  reloadTexture(carIdx = 0) {
+    return this.broadcastMsg(BroadcastMsg.RELOAD_TEXTURES, ReloadTexturesMode.CAR_IDX, carIdx);
+  }
+  chatCommand(chatCommandMode = ChatCommandMode.BEGIN_CHAT) {
+    return this.broadcastMsg(BroadcastMsg.CHAT_COMMAND, chatCommandMode);
+  }
+  chatCommandMacro(macroNum = 0) {
+    return this.broadcastMsg(BroadcastMsg.CHAT_COMMAND, ChatCommandMode.MACRO, macroNum);
+  }
+  pitCommand(pitCommandMode = PitCommandMode.CLEAR, variable = 0) {
+    return this.broadcastMsg(BroadcastMsg.PIT_COMMAND, pitCommandMode, variable);
+  }
+  telemCommand(telemCommandMode = TelemCommandMode.STOP) {
+    return this.broadcastMsg(BroadcastMsg.TELEM_COMMAND, telemCommandMode);
+  }
+  ffbCommand(ffbCommandMode = FFBCommandMode.FFB_COMMAND_MAX_FORCE, value = 0) {
+    return this.broadcastMsg(BroadcastMsg.FFB_COMMAND, ffbCommandMode, Math.floor(value * 65536));
+  }
+  replaySearchSessionTime(sessionNum = 0, sessionTimeMs = 0) {
+    return this.broadcastMsg(BroadcastMsg.REPLAY_SEARCH_SESSION_TIME, sessionNum, sessionTimeMs);
+  }
+  videoCapture(videoCaptureMode = VideoCaptureMode.TRIGGER_SCREEN_SHOT) {
+    return this.broadcastMsg(BroadcastMsg.VIDEO_CAPTURE, videoCaptureMode);
+  }
+}
+function createIRSDK(options) {
+  return new IRSDK(options);
+}
+
+export { IRSDK, createIRSDK };

package/dist/index-tz5ph8p3.js

@@ -0,0 +1,293 @@
+// @bun
+import {
+  $parse
+} from "./index-hxw291vy.js";
+import {
+  parseDiskSubHeader,
+  parseHeader,
+  parseVarHeaders,
+  readString,
+  readVarValue,
+  readVarValueBatch
+} from "./index-c5jf6rjt.js";
+import {
+  DISK_SUB_HEADER_OFFSET
+} from "./index-wb6ebd0j.js";
+
+// src/ibt.ts
+class IBT {
+  buffer = null;
+  view = null;
+  header = null;
+  diskHeader = null;
+  varHeaders = null;
+  sessionInfoCache = new Map;
+  rawSessionInfo = null;
+  filePath = null;
+  get fileName() {
+    return this.filePath;
+  }
+  get varHeaderBufferTick() {
+    return this.header?.varBuf[0]?.tickCount ?? null;
+  }
+  get varHeaderNames() {
+    if (!this.varHeaders)
+      return null;
+    return Array.from(this.varHeaders.keys());
+  }
+  get recordCount() {
+    return this.diskHeader?.sessionRecordCount ?? 0;
+  }
+  get sessionLapCount() {
+    return this.diskHeader?.sessionLapCount ?? 0;
+  }
+  get sessionStartTime() {
+    return this.diskHeader?.sessionStartTime ?? 0;
+  }
+  get sessionEndTime() {
+    return this.diskHeader?.sessionEndTime ?? 0;
+  }
+  get tickRate() {
+    return this.header?.tickRate ?? 60;
+  }
+  get bufLen() {
+    return this.header?.bufLen ?? 0;
+  }
+  async open(filePath) {
+    this.filePath = filePath;
+    const file = Bun.file(filePath);
+    const arrayBuffer = await file.arrayBuffer();
+    this.buffer = new Uint8Array(arrayBuffer);
+    this.view = new DataView(arrayBuffer);
+    this.header = parseHeader(this.view);
+    this.diskHeader = parseDiskSubHeader(this.view, DISK_SUB_HEADER_OFFSET);
+    this.varHeaders = parseVarHeaders(this.view, this.buffer, this.header);
+    this.sessionInfoCache.clear();
+    this.rawSessionInfo = null;
+  }
+  openSync(filePath) {
+    this.filePath = filePath;
+    const file = Bun.file(filePath);
+    const arrayBuffer = file.arrayBuffer();
+    if (arrayBuffer instanceof Promise) {
+      throw new Error("Sync file reading requires Bun.file().bytes() - use open() instead");
+    }
+    this.buffer = new Uint8Array(arrayBuffer);
+    this.view = new DataView(arrayBuffer);
+    this.header = parseHeader(this.view);
+    this.diskHeader = parseDiskSubHeader(this.view, DISK_SUB_HEADER_OFFSET);
+    this.varHeaders = parseVarHeaders(this.view, this.buffer, this.header);
+    this.sessionInfoCache.clear();
+    this.rawSessionInfo = null;
+  }
+  static async fromBuffer(buffer) {
+    const ibt = new IBT;
+    ibt.buffer = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    ibt.view = new DataView(ibt.buffer.buffer, ibt.buffer.byteOffset, ibt.buffer.byteLength);
+    ibt.header = parseHeader(ibt.view);
+    ibt.diskHeader = parseDiskSubHeader(ibt.view, DISK_SUB_HEADER_OFFSET);
+    ibt.varHeaders = parseVarHeaders(ibt.view, ibt.buffer, ibt.header);
+    return ibt;
+  }
+  close() {
+    this.buffer = null;
+    this.view = null;
+    this.header = null;
+    this.diskHeader = null;
+    this.varHeaders = null;
+    this.sessionInfoCache.clear();
+    this.rawSessionInfo = null;
+    this.filePath = null;
+  }
+  getVarHeader(name) {
+    return this.varHeaders?.get(name);
+  }
+  get(index, key) {
+    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
+      return null;
+    if (index < 0 || index >= this.diskHeader.sessionRecordCount)
+      return null;
+    const varHeader = this.varHeaders.get(key);
+    if (!varHeader)
+      return null;
+    const varBuf = this.header.varBuf[0];
+    if (!varBuf)
+      return null;
+    const varOffset = varHeader.offset + varBuf.bufOffset + index * this.header.bufLen;
+    return readVarValue(this.view, varOffset, varHeader.type, varHeader.count);
+  }
+  getAll(key) {
+    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
+      return null;
+    const varHeader = this.varHeaders.get(key);
+    if (!varHeader)
+      return null;
+    const varBuf = this.header.varBuf[0];
+    if (!varBuf)
+      return null;
+    const baseOffset = varBuf.bufOffset;
+    const bufLen = this.header.bufLen;
+    const recordCount = this.diskHeader.sessionRecordCount;
+    const varOffset = varHeader.offset;
+    const isArray = varHeader.count > 1;
+    const results = new Array(recordCount);
+    for (let i = 0;i < recordCount; i++) {
+      const offset = baseOffset + i * bufLen + varOffset;
+      results[i] = readVarValue(this.view, offset, varHeader.type, varHeader.count);
+    }
+    return results;
+  }
+  getAllTyped(key) {
+    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
+      return null;
+    const varHeader = this.varHeaders.get(key);
+    if (!varHeader || varHeader.count !== 1)
+      return null;
+    const varBuf = this.header.varBuf[0];
+    if (!varBuf)
+      return null;
+    const baseOffset = varBuf.bufOffset;
+    const bufLen = this.header.bufLen;
+    const recordCount = this.diskHeader.sessionRecordCount;
+    const varOffset = varHeader.offset;
+    let output;
+    switch (varHeader.type) {
+      case 4:
+        output = new Float32Array(recordCount);
+        break;
+      case 5:
+        output = new Float64Array(recordCount);
+        break;
+      case 2:
+        output = new Int32Array(recordCount);
+        break;
+      case 3:
+        output = new Uint32Array(recordCount);
+        break;
+      default:
+        return null;
+    }
+    readVarValueBatch(this.view, baseOffset, varOffset, varHeader.type, bufLen, recordCount, output);
+    return output;
+  }
+  getAllMultiple(keys) {
+    const results = new Map;
+    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
+      return results;
+    const varBuf = this.header.varBuf[0];
+    if (!varBuf)
+      return results;
+    const baseOffset = varBuf.bufOffset;
+    const bufLen = this.header.bufLen;
+    const recordCount = this.diskHeader.sessionRecordCount;
+    const varInfos = [];
+    for (const key of keys) {
+      const varHeader = this.varHeaders.get(key);
+      if (varHeader) {
+        const data = new Array(recordCount);
+        varInfos.push({ key, varHeader, data });
+        results.set(key, data);
+      }
+    }
+    for (let i = 0;i < recordCount; i++) {
+      const recordOffset = baseOffset + i * bufLen;
+      for (const { varHeader, data } of varInfos) {
+        const offset = recordOffset + varHeader.offset;
+        data[i] = readVarValue(this.view, offset, varHeader.type, varHeader.count);
+      }
+    }
+    return results;
+  }
+  *iterate(keys) {
+    if (!this.header || !this.view || !this.varHeaders || !this.diskHeader)
+      return;
+    const varBuf = this.header.varBuf[0];
+    if (!varBuf)
+      return;
+    const baseOffset = varBuf.bufOffset;
+    const bufLen = this.header.bufLen;
+    const recordCount = this.diskHeader.sessionRecordCount;
+    const varInfos = [];
+    for (const key of keys) {
+      const varHeader = this.varHeaders.get(key);
+      if (varHeader) {
+        varInfos.push({ key, varHeader });
+      }
+    }
+    for (let i = 0;i < recordCount; i++) {
+      const recordOffset = baseOffset + i * bufLen;
+      const record = new Map;
+      for (const { key, varHeader } of varInfos) {
+        const offset = recordOffset + varHeader.offset;
+        record.set(key, readVarValue(this.view, offset, varHeader.type, varHeader.count));
+      }
+      yield record;
+    }
+  }
+  getRawSessionInfo() {
+    if (!this.header || !this.buffer)
+      return null;
+    if (this.rawSessionInfo === null) {
+      const start = this.header.sessionInfoOffset;
+      const len = this.header.sessionInfoLen;
+      this.rawSessionInfo = readString(this.buffer, start, len);
+    }
+    return this.rawSessionInfo;
+  }
+  getSessionInfo(key) {
+    const raw = this.getRawSessionInfo();
+    if (!raw)
+      return null;
+    if (!key) {
+      if (!this.sessionInfoCache.has("__full__")) {
+        try {
+          const cleaned = this.cleanYaml(raw);
+          this.sessionInfoCache.set("__full__", $parse(cleaned));
+        } catch {
+          return null;
+        }
+      }
+      return this.sessionInfoCache.get("__full__");
+    }
+    if (this.sessionInfoCache.has(key)) {
+      return this.sessionInfoCache.get(key);
+    }
+    const sectionMatch = raw.match(new RegExp(`
+${key}:
+([\\s\\S]*?)(?=
+
+|$)`));
+    if (!sectionMatch)
+      return null;
+    try {
+      const sectionYaml = `${key}:
+${sectionMatch[1]}`;
+      const cleaned = this.cleanYaml(sectionYaml);
+      const parsed = $parse(cleaned);
+      const result = parsed?.[key] ?? null;
+      this.sessionInfoCache.set(key, result);
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  cleanYaml(yaml) {
+    let cleaned = yaml.replace(/[\x81\x8D\x8F\x90\x9D]/g, " ").replace(/[^\x09\x0A\x0D\x20-\x7E\xA0-\xFF]/g, "");
+    cleaned = cleaned.replace(/((?:DriverSetupName|UserName|TeamName|AbbrevName|Initials): )(.*)/g, (_, prefix, value) => {
+      const escaped = value.replace(/["\\]/g, "\\$&");
+      return `${prefix}"${escaped}"`;
+    });
+    cleaned = cleaned.replace(/(\w+: )(,.*)/g, '$1"$2"');
+    return cleaned;
+  }
+}
+async function parseIbt(filePath) {
+  const ibt = new IBT;
+  await ibt.open(filePath);
+  return ibt;
+}
+async function parseIbtBuffer(buffer) {
+  return IBT.fromBuffer(buffer);
+}
+
+export { IBT, parseIbt, parseIbtBuffer };