@hotlap.ai/telemetry 1.0.0 → 1.2.0

package/dist/neutral/normalize.js

@@ -0,0 +1,349 @@
+// src/normalize.ts
+var NORMALIZE_THRESHOLDS = {
+  MIN_SAMPLES: 10,
+  MIN_COMPLETION_PCT: 0.9,
+  MAX_AVG_SPEED_KMH: 220,
+  LLT_UPDATE_GRACE_SEC: 2
+};
+function parseTrackLengthKm(weekend) {
+  const raw = weekend?.TrackLength ?? weekend?.TrackLengthOfficial;
+  if (typeof raw !== "string")
+    return null;
+  const m = raw.match(/([\d.]+)\s*km/i);
+  if (!m)
+    return null;
+  const km = parseFloat(m[1]);
+  return Number.isFinite(km) && km > 0 ? km : null;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function normalizeIbt(source) {
+  const n = source.recordCount;
+  const lapArr = source.getAllTyped("Lap");
+  const timeArr = source.getAllTyped("SessionTime");
+  const distArr = source.getAllTyped("LapDist");
+  const pctArr = source.getAllTyped("LapDistPct");
+  const lltArr = source.getAllTyped("LapLastLapTime");
+  const sessArr = source.getAllTyped("SessionNum");
+  const incArr = source.getAllTyped("PlayerCarMyIncidentCount");
+  if (!lapArr || !timeArr || n === 0)
+    return [];
+  const yaml = source.getSessionInfo() ?? {};
+  const weekend = yaml.WeekendInfo;
+  const trackLengthKm = parseTrackLengthKm(weekend);
+  const boundaries = sectorBoundaries(yaml);
+  const meta = driverMeta(yaml);
+  const sessions = new Map;
+  for (let i = 0;i < n; i++) {
+    const lap = lapArr[i];
+    const sess = sessArr ? sessArr[i] : 0;
+    if (!Number.isFinite(lap))
+      continue;
+    let lapsOfSession = sessions.get(sess);
+    if (!lapsOfSession)
+      sessions.set(sess, lapsOfSession = new Map);
+    let acc = lapsOfSession.get(lap);
+    if (!acc)
+      lapsOfSession.set(lap, acc = { lapNumber: lap, indices: [] });
+    acc.indices.push(i);
+  }
+  const out = [];
+  for (const [sessionNum, lapsOfSession] of [...sessions.entries()].sort((a, b) => a[0] - b[0])) {
+    const sessionEntry = yaml.SessionInfo?.Sessions?.find((s) => num(s.SessionNum) === sessionNum);
+    const laps = [];
+    const lapNumbers = [...lapsOfSession.keys()].sort((a, b) => a - b);
+    for (const lapNumber of lapNumbers) {
+      const acc = lapsOfSession.get(lapNumber);
+      const next = lapsOfSession.get(lapNumber + 1);
+      laps.push(normalizeLap(acc, next, {
+        timeArr,
+        distArr,
+        pctArr,
+        lltArr,
+        incArr,
+        trackLengthKm,
+        boundaries
+      }));
+    }
+    out.push({
+      sessionNum,
+      sessionType: str(sessionEntry?.SessionType),
+      sessionName: str(sessionEntry?.SessionName),
+      eventType: str(weekend?.EventType),
+      trackId: num(weekend?.TrackID),
+      trackName: str(weekend?.TrackDisplayName) ?? str(weekend?.TrackName),
+      trackConfigName: str(weekend?.TrackConfigName),
+      trackLengthKm,
+      seriesId: num(weekend?.SeriesID),
+      seasonId: num(weekend?.SeasonID),
+      sessionId: num(weekend?.SessionID),
+      subSessionId: num(weekend?.SubSessionID),
+      driverCarIdx: meta.driverCarIdx,
+      driverName: meta.driverName,
+      carId: meta.carId,
+      carScreenName: meta.carScreenName,
+      carPath: meta.carPath,
+      tickRate: source.tickRate,
+      laps
+    });
+  }
+  return out;
+}
+function driverMeta(yaml) {
+  const driverCarIdx = num(yaml.DriverInfo?.DriverCarIdx) ?? 0;
+  const driver = yaml.DriverInfo?.Drivers?.find((d) => num(d.CarIdx) === driverCarIdx);
+  return {
+    driverCarIdx,
+    driverName: str(driver?.UserName),
+    carId: num(driver?.CarID),
+    carScreenName: str(driver?.CarScreenName),
+    carPath: str(driver?.CarPath)
+  };
+}
+function sectorBoundaries(yaml) {
+  const sectors = yaml.SplitTimeInfo?.Sectors;
+  if (!Array.isArray(sectors) || sectors.length === 0)
+    return [];
+  const pcts = sectors.map((s) => num(s.SectorStartPct)).filter((p) => p != null && p >= 0 && p < 1).sort((a, b) => a - b);
+  if (pcts.length === 0)
+    return [];
+  if (pcts[0] !== 0)
+    pcts.unshift(0);
+  return pcts;
+}
+function normalizeLap(acc, next, ctx) {
+  const { timeArr, distArr, pctArr, lltArr, incArr, trackLengthKm, boundaries } = ctx;
+  const idx = acc.indices;
+  const flags = [];
+  const isOutLap = acc.lapNumber === 0;
+  if (isOutLap)
+    flags.push("out-lap");
+  let minT = Infinity, maxT = -Infinity, minD = Infinity, maxD = -Infinity;
+  for (const i of idx) {
+    const t = timeArr[i];
+    if (t < minT)
+      minT = t;
+    if (t > maxT)
+      maxT = t;
+    if (distArr) {
+      const d = distArr[i];
+      if (Number.isFinite(d)) {
+        if (d < minD)
+          minD = d;
+        if (d > maxD)
+          maxD = d;
+      }
+    }
+  }
+  const sampleSpanSec = maxT - minT;
+  const distanceKm = distArr && maxD > minD ? (maxD - minD) / 1000 : 0;
+  const completionPct = trackLengthKm && trackLengthKm > 0 ? distanceKm / trackLengthKm : null;
+  if (idx.length < NORMALIZE_THRESHOLDS.MIN_SAMPLES)
+    flags.push("too-few-samples");
+  if (completionPct != null && completionPct < NORMALIZE_THRESHOLDS.MIN_COMPLETION_PCT) {
+    flags.push("low-completion");
+  }
+  let lapTimeSec = null;
+  let timingSource = null;
+  if (lltArr && next && next.indices.length > 0 && !isOutLap) {
+    const lltDuringLap = lastFinite(lltArr, idx);
+    let updated = null;
+    for (const i of next.indices) {
+      const v = lltArr[i];
+      if (v > 0 && (lltDuringLap == null || Math.abs(v - lltDuringLap) > 0.000000001))
+        updated = v;
+    }
+    if (updated != null) {
+      lapTimeSec = updated;
+      timingSource = "lap-last-lap-time";
+    }
+  }
+  let completed = timingSource === "lap-last-lap-time";
+  if (lapTimeSec == null && !isOutLap) {
+    flags.push("no-lap-last-time");
+    const nextSpanSec = next && next.indices.length > 0 ? timeArr[next.indices[next.indices.length - 1]] - timeArr[next.indices[0]] : null;
+    const updateMissed = lltArr != null && nextSpanSec != null && nextSpanSec < NORMALIZE_THRESHOLDS.LLT_UPDATE_GRACE_SEC;
+    if (!lltArr || updateMissed) {
+      const start = crossingStart(acc, ctx);
+      const finish = crossingFinish(acc, next, ctx);
+      if (start != null && finish != null && finish > start) {
+        lapTimeSec = finish - start;
+        timingSource = "crossing-interpolation";
+        completed = coverageComplete(acc, ctx, completionPct);
+      }
+    }
+  }
+  const effectiveTime = lapTimeSec ?? (sampleSpanSec > 0 ? sampleSpanSec : null);
+  if (effectiveTime && distanceKm > 0) {
+    const avgKmh = distanceKm / (effectiveTime / 3600);
+    if (avgKmh > NORMALIZE_THRESHOLDS.MAX_AVG_SPEED_KMH)
+      flags.push("unrealistic-speed");
+  }
+  let incidents = 0;
+  if (incArr && idx.length >= 2) {
+    const first = firstFinite(incArr, idx);
+    const last = lastFinite(incArr, idx);
+    if (first != null && last != null)
+      incidents = Math.max(0, last - first);
+  }
+  if (incidents > 0)
+    flags.push("incident-delta");
+  const sectorTimes = computeSectors(acc, next, ctx);
+  if (sectorTimes.some((s) => s.timeSec == null) && sectorTimes.length > 0) {
+    flags.push("no-sector-data");
+  }
+  let sectorResidualSec = null;
+  if (lapTimeSec != null && sectorTimes.length > 0 && sectorTimes.every((s) => s.timeSec != null)) {
+    const sum = sectorTimes.reduce((a, s) => a + (s.timeSec ?? 0), 0);
+    sectorResidualSec = lapTimeSec - sum;
+  }
+  return {
+    lapNumber: acc.lapNumber,
+    completed,
+    lapTimeSec,
+    timingSource,
+    sampleSpanSec,
+    distanceKm,
+    completionPct,
+    sectorTimes,
+    sectorResidualSec,
+    incidents,
+    flags,
+    sampleCount: idx.length,
+    firstSampleIndex: idx[0],
+    lastSampleIndex: idx[idx.length - 1]
+  };
+}
+function computeSectors(acc, next, ctx) {
+  const { boundaries, timeArr } = ctx;
+  if (boundaries.length === 0 || acc.lapNumber === 0)
+    return [];
+  const pctAt = (i) => pctAtIndex(i, ctx);
+  const crossing = (targetPct) => {
+    let prevI = null;
+    for (const i of acc.indices) {
+      const p = pctAt(i);
+      if (p == null)
+        continue;
+      if (prevI != null) {
+        const p0 = pctAt(prevI);
+        if (p0 <= targetPct && p >= targetPct && p >= p0) {
+          const t0 = timeArr[prevI];
+          const t1 = timeArr[i];
+          if (p === p0)
+            return t0;
+          return t0 + (targetPct - p0) / (p - p0) * (t1 - t0);
+        }
+      }
+      prevI = i;
+    }
+    return null;
+  };
+  const startT = crossingStart(acc, ctx) ?? timeArr[acc.indices[0]];
+  const times = [];
+  for (let b = 1;b < boundaries.length; b++) {
+    times.push(crossing(boundaries[b]));
+  }
+  times.push(crossingFinish(acc, next, ctx));
+  const sectors = [];
+  let prevT = startT;
+  for (let k = 0;k < times.length; k++) {
+    const t = times[k];
+    sectors.push({
+      sectorNum: k + 1,
+      timeSec: t != null && prevT != null ? t - prevT : null
+    });
+    if (t != null)
+      prevT = t;
+  }
+  return sectors;
+}
+function crossingStart(acc, ctx) {
+  const { timeArr } = ctx;
+  const firstI = acc.indices[0];
+  if (firstI === 0)
+    return null;
+  const prevI = firstI - 1;
+  const p0 = pctAtIndex(prevI, ctx);
+  const p1 = pctAtIndex(firstI, ctx);
+  if (p0 == null || p1 == null)
+    return null;
+  const t0 = timeArr[prevI];
+  const t1 = timeArr[firstI];
+  if (p0 > p1) {
+    const step = 1 - p0 + p1;
+    if (step <= 0)
+      return (t0 + t1) / 2;
+    return t0 + (1 - p0) / step * (t1 - t0);
+  }
+  return null;
+}
+function coverageComplete(acc, ctx, completionPct) {
+  if (completionPct != null) {
+    return completionPct >= NORMALIZE_THRESHOLDS.MIN_COMPLETION_PCT;
+  }
+  let minP = Infinity;
+  let maxP = -Infinity;
+  for (const i of acc.indices) {
+    const p = pctAtIndex(i, ctx);
+    if (p == null)
+      continue;
+    if (p < minP)
+      minP = p;
+    if (p > maxP)
+      maxP = p;
+  }
+  return maxP > minP && maxP - minP >= NORMALIZE_THRESHOLDS.MIN_COMPLETION_PCT;
+}
+function crossingFinish(acc, next, ctx) {
+  if (!next || next.indices.length === 0)
+    return null;
+  const { timeArr } = ctx;
+  const lastI = acc.indices[acc.indices.length - 1];
+  const firstNext = next.indices[0];
+  const p0 = pctAtIndex(lastI, ctx);
+  const p1 = pctAtIndex(firstNext, ctx);
+  if (p0 == null || p1 == null)
+    return null;
+  const t0 = timeArr[lastI];
+  const t1 = timeArr[firstNext];
+  const step = 1 - p0 + p1;
+  if (step <= 0)
+    return (t0 + t1) / 2;
+  return t0 + (1 - p0) / step * (t1 - t0);
+}
+function pctAtIndex(i, ctx) {
+  if (ctx.pctArr) {
+    const p = ctx.pctArr[i];
+    return Number.isFinite(p) && p >= 0 ? p : null;
+  }
+  if (ctx.distArr && ctx.trackLengthKm && ctx.trackLengthKm > 0) {
+    const d = ctx.distArr[i];
+    return Number.isFinite(d) ? d / (ctx.trackLengthKm * 1000) : null;
+  }
+  return null;
+}
+function firstFinite(arr, indices) {
+  for (const i of indices) {
+    const v = arr[i];
+    if (Number.isFinite(v))
+      return v;
+  }
+  return null;
+}
+function lastFinite(arr, indices) {
+  for (let k = indices.length - 1;k >= 0; k--) {
+    const v = arr[indices[k]];
+    if (Number.isFinite(v))
+      return v;
+  }
+  return null;
+}
+export {
+  normalizeIbt,
+  NORMALIZE_THRESHOLDS
+};

package/dist/neutral/session-yaml.js

@@ -0,0 +1,20 @@
+import {
+  cleanYamlFast,
+  decodeSessionYaml,
+  parseSessionYaml,
+  parseTrackLengthKm,
+  readSessionInfoRange,
+  resolveSessionMetadata,
+  sessionMetadataFromYamlBytes,
+  sessionTypeForSessionNum
+} from "./ibt-kagktz7r.js";
+export {
+  sessionTypeForSessionNum,
+  sessionMetadataFromYamlBytes,
+  resolveSessionMetadata,
+  readSessionInfoRange,
+  parseTrackLengthKm,
+  parseSessionYaml,
+  decodeSessionYaml,
+  cleanYamlFast
+};

package/dist/normalize.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Canonical telemetry normalization — the single source of truth for what a
+ * lap IS across HotLap.ai (UI, Edge Functions, CLI).
+ *
+ * Implements RFC-0001 (hotlap.ai repo, docs/rfcs/RFC-0001-canonical-telemetry-parser.md):
+ *  - C2: official lap time from the sim's LapLastLapTime channel, with
+ *        crossing-interpolation fallback. Sample striding is never an input.
+ *  - C3: a lap is `completed` only when the sim scored it.
+ *  - C4: sectors computed at full resolution, numbered 1..N (iRacing S1..SN),
+ *        no silent rescaling — the residual is reported instead.
+ *  - C5: session metadata resolved via the SessionNum channel against the
+ *        YAML Sessions list; multi-session files split per session.
+ *  - C7: classify, don't drop — every observed lap appears with flags.
+ *
+ * RUNTIME NEUTRALITY: this module must not import Bun/Deno/Node APIs.
+ * It consumes an already-parsed IBT source (see IbtSource).
+ */
+/** Structural subset of the IBT class this module needs (keeps it testable). */
+export interface IbtSource {
+    readonly tickRate: number;
+    readonly recordCount: number;
+    getAllTyped(key: string): Float32Array | Float64Array | Int32Array | Uint32Array | null;
+    getAll(key: string): unknown[] | null;
+    getSessionInfo<T = unknown>(key?: string): T | null;
+}
+export type LapFlag = 'out-lap' | 'no-lap-last-time' | 'low-completion' | 'incident-delta' | 'unrealistic-speed' | 'too-few-samples' | 'no-sector-data';
+export type TimingSource = 'lap-last-lap-time' | 'crossing-interpolation' | 'sample-span';
+export interface NormalizedSector {
+    /** 1-based, matches iRacing S1/S2/S3 display convention. */
+    sectorNum: number;
+    timeSec: number | null;
+}
+export interface NormalizedLap {
+    lapNumber: number;
+    completed: boolean;
+    /** Official lap time (null when the lap was never completed/scored and no fallback exists). */
+    lapTimeSec: number | null;
+    timingSource: TimingSource | null;
+    /** Diagnostic: max−min SessionTime within the lap. Never the official time. */
+    sampleSpanSec: number;
+    distanceKm: number;
+    completionPct: number | null;
+    sectorTimes: NormalizedSector[];
+    /** lapTimeSec − Σ sectors; ≈0 when timing and sectors agree. Null without both. */
+    sectorResidualSec: number | null;
+    incidents: number;
+    flags: LapFlag[];
+    sampleCount: number;
+    /** First/last record indices of this lap in the file (for consumers extracting points). */
+    firstSampleIndex: number;
+    lastSampleIndex: number;
+}
+export interface NormalizedSession {
+    sessionNum: number;
+    /** Sessions[sessionNum].SessionType — full string, e.g. "Offline Testing", "Lone Qualify". */
+    sessionType: string | null;
+    sessionName: string | null;
+    /** WeekendInfo.EventType — event-level context, distinct from sessionType. */
+    eventType: string | null;
+    trackId: number | null;
+    trackName: string | null;
+    trackConfigName: string | null;
+    trackLengthKm: number | null;
+    seriesId: number | null;
+    seasonId: number | null;
+    sessionId: number | null;
+    subSessionId: number | null;
+    driverCarIdx: number;
+    driverName: string | null;
+    carId: number | null;
+    carScreenName: string | null;
+    carPath: string | null;
+    tickRate: number;
+    laps: NormalizedLap[];
+}
+export declare const NORMALIZE_THRESHOLDS: {
+    readonly MIN_SAMPLES: 10;
+    readonly MIN_COMPLETION_PCT: 0.9;
+    readonly MAX_AVG_SPEED_KMH: 220;
+    /**
+     * LapLastLapTime updates shortly after the line crossing. If the recording
+     * contains fewer than this many seconds of lap N+1, a missing update means
+     * "recording ended before the sim published the time", not "unscored lap".
+     */
+    readonly LLT_UPDATE_GRACE_SEC: 2;
+};
+/**
+ * Normalize a parsed .ibt file into one NormalizedSession per SessionNum
+ * observed in the channel data (RFC C5).
+ */
+export declare function normalizeIbt(source: IbtSource): NormalizedSession[];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,gFAAgF;AAChF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;IACxF,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC;IACtC,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC;CACrD;AAMD,MAAM,MAAM,OAAO,GACf,SAAS,GACT,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,iBAAiB,GACjB,gBAAgB,CAAC;AAErB,MAAM,MAAM,YAAY,GACpB,mBAAmB,GACnB,wBAAwB,GACxB,aAAa,CAAC;AAElB,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,+FAA+F;IAC/F,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,+EAA+E;IAC/E,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,mFAAmF;IACnF,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,8EAA8E;IAC9E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,aAAa,EAAE,CAAC;CACvB;AAMD,eAAO,MAAM,oBAAoB;;;;IAI/B;;;;OAIG;;CAEK,CAAC;AAuCX;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,iBAAiB,EAAE,CA2EnE"}

package/dist/session-yaml.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Fast single-pass YAML cleaning function.
+ * Combines multiple string operations to reduce intermediate allocations.
+ */
+export declare function cleanYamlFast(yaml: string): string;
+/**
+ * Read the session-info byte range from the .ibt fixed header (first 48+
+ * bytes are sufficient). For consumers that range-download instead of
+ * loading the whole file.
+ */
+export declare function readSessionInfoRange(headerBytes: ArrayBuffer | Uint8Array): {
+    sessionInfoLen: number;
+    sessionInfoOffset: number;
+};
+/**
+ * Canonical text decode (RFC C5/D5): UTF-8 first; if replacement characters
+ * appear, fall back to windows-1252 (older iRacing builds and non-ASCII
+ * driver/team names). A plain lossy UTF-8 decode corrupts those names —
+ * that was divergence D5.
+ */
+export declare function decodeSessionYaml(bytes: Uint8Array): string;
+export interface SessionYamlDoc {
+    WeekendInfo?: Record<string, unknown>;
+    DriverInfo?: {
+        DriverCarIdx?: number;
+        Drivers?: Array<Record<string, unknown>>;
+        [key: string]: unknown;
+    };
+    SplitTimeInfo?: {
+        Sectors?: Array<{
+            SectorNum?: number;
+            SectorStartPct?: number;
+        }>;
+    };
+    SessionInfo?: {
+        Sessions?: Array<Record<string, unknown>>;
+    };
+    [key: string]: unknown;
+}
+/** Clean + parse the raw YAML text with a real YAML parser (never regex). */
+export declare function parseSessionYaml(raw: string): SessionYamlDoc | null;
+export interface ResolvedSessionEntry {
+    sessionNum: number | null;
+    /** Full string, e.g. "Offline Testing", "Lone Qualify" — never truncated. */
+    sessionType: string | null;
+    sessionName: string | null;
+    raw: Record<string, unknown>;
+}
+export interface SessionMetadata {
+    trackId: number | null;
+    trackName: string | null;
+    trackConfigName: string | null;
+    trackLengthKm: number | null;
+    trackNumTurns: number | null;
+    eventType: string | null;
+    category: string | null;
+    seriesId: number | null;
+    seasonId: number | null;
+    sessionId: number | null;
+    subSessionId: number | null;
+    raceWeek: number | null;
+    official: boolean | null;
+    driverCarIdx: number;
+    driverName: string | null;
+    driverUserId: number | null;
+    carId: number | null;
+    carScreenName: string | null;
+    carPath: string | null;
+    carClassId: number | null;
+    carNumber: string | null;
+    teamName: string | null;
+    sessions: ResolvedSessionEntry[];
+    /** Raw parsed doc for specialized consumers (results positions, sectors…). */
+    doc: SessionYamlDoc;
+}
+export declare function parseTrackLengthKm(value: unknown): number | null;
+export declare function resolveSessionMetadata(doc: SessionYamlDoc): SessionMetadata;
+/**
+ * Session-type resolution per RFC C5: the type of the session the telemetry
+ * was recorded in is Sessions[n].SessionType where n comes from the
+ * SessionNum CHANNEL — never "the first SessionType in the document" (that
+ * was divergence D4) and never WeekendInfo.EventType (kept separately).
+ */
+export declare function sessionTypeForSessionNum(meta: Pick<SessionMetadata, 'sessions'>, sessionNum: number): string | null;
+/** Convenience: raw YAML byte range → resolved metadata (or null on parse failure). */
+export declare function sessionMetadataFromYamlBytes(bytes: Uint8Array): SessionMetadata | null;
+//# sourceMappingURL=session-yaml.d.ts.map

package/dist/session-yaml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-yaml.d.ts","sourceRoot":"","sources":["../src/session-yaml.ts"],"names":[],"mappings":"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"}

package/dist/telemetry-server.js

@@ -2,10 +2,11 @@
 // @bun
 import {
   createIRSDK
-} from "./live.js";
-import"./index-k5bgtn4c.js";
-import"./binary-reader.js";
-import"./constants.js";
+} from "./index-t4qz2011.js";
+import"./index-hxw291vy.js";
+import"./index-c5jf6rjt.js";
+import"./index-wb6ebd0j.js";
+import"./index-ftpvnye9.js";
 
 // src/telemetry-server.ts
 var TELEMETRY_PORT = 32100;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hotlap.ai/telemetry",
-  "version": "1.0.0",
-  "description": "High-performance iRacing SDK for Bun - telemetry parsing and live data",
+  "version": "1.2.0",
+  "description": "High-performance iRacing telemetry library for Bun - IBT file parsing and live data streaming",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -17,6 +17,21 @@
       "import": "./dist/ibt.js",
       "default": "./dist/ibt.js"
     },
+    "./core": {
+      "types": "./dist/ibt.d.ts",
+      "import": "./dist/neutral/ibt.js",
+      "default": "./dist/neutral/ibt.js"
+    },
+    "./normalize": {
+      "types": "./dist/normalize.d.ts",
+      "import": "./dist/neutral/normalize.js",
+      "default": "./dist/neutral/normalize.js"
+    },
+    "./session": {
+      "types": "./dist/session-yaml.d.ts",
+      "import": "./dist/neutral/session-yaml.js",
+      "default": "./dist/neutral/session-yaml.js"
+    },
     "./live": {
       "types": "./dist/live.d.ts",
       "import": "./dist/live.js",
@@ -39,7 +54,8 @@
   ],
   "scripts": {
     "build": "bun run build:js && bun run build:types",
-    "build:js": "bun build ./src/index.ts ./src/ibt.ts ./src/live.ts ./src/constants.ts ./src/cli.ts ./src/telemetry-server.ts ./src/types.ts ./src/binary-reader.ts --outdir ./dist --target bun --splitting",
+    "build:js": "bun build ./src/index.ts ./src/ibt.ts ./src/live.ts ./src/constants.ts ./src/cli.ts ./src/telemetry-server.ts ./src/types.ts ./src/binary-reader.ts --outdir ./dist --target bun --splitting && bun run build:neutral",
+    "build:neutral": "bun build ./src/ibt.ts ./src/normalize.ts ./src/session-yaml.ts --outdir ./dist/neutral --target browser --splitting",
     "build:types": "tsc --emitDeclarationOnly --declaration --declarationMap --outDir ./dist",
     "build:server": "bun build ./src/telemetry-server.ts --compile --outfile ./dist/hotlap-telemetry",
     "clean": "rm -rf dist",
@@ -48,6 +64,8 @@
     "server": "bun run src/telemetry-server.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
+    "fixtures:pull": "bun run scripts/fixtures-pull.ts",
+    "gate:deno": "deno run scripts/deno-gate.ts",
     "bench": "bun run bench/parse-ibt.bench.ts",
     "prepublishOnly": "bun run clean && bun run build"
   },