diff --git a/backend/src/api/controllers/result.ts b/backend/src/api/controllers/result.ts
index 02b332b05662..e2d61d6866a9 100644
--- a/backend/src/api/controllers/result.ts
+++ b/backend/src/api/controllers/result.ts
@@ -200,7 +200,7 @@ export async function reportCompletedEventMismatch(
     duration,
     funboxes,
     version,
-    data,
+    eventLog,
   } = req.body;
   // Logger.warning(
   //   `Completed event mismatch for uid ${uid}: ${notMatching.join(", ")}`,
@@ -220,7 +220,7 @@ export async function reportCompletedEventMismatch(
       duration,
       funboxes,
       version,
-      data,
+      eventLog,
     },
     uid,
   );
diff --git a/frontend/__tests__/test/events/data.spec.ts b/frontend/__tests__/test/events/data.spec.ts
index 97c1a57a2c60..f419634b5d4f 100644
--- a/frontend/__tests__/test/events/data.spec.ts
+++ b/frontend/__tests__/test/events/data.spec.ts
@@ -7,7 +7,6 @@ vi.mock("../../../src/ts/test/test-stats", () => ({
 import {
   logTestEvent,
   getAllTestEvents,
-  getEventsPerWord,
   cleanupData,
   resetTestEvents,
   __testing,
@@ -22,6 +21,7 @@ import type {
   TimerEventData,
 } from "../../../src/ts/test/events/types";
 import { Keycode } from "../../../src/ts/constants/keys";
+import { getEventsPerWord } from "../../../src/ts/test/events/helpers";
 
 function keyDown(code: Keycode | "NoCode" = "KeyA"): KeydownEventData {
   return { code };
@@ -251,7 +251,7 @@ describe("data.ts", () => {
       logTestEvent("input", 1020, inputData({ wordIndex: 0, charIndex: 1 }));
       logTestEvent("input", 1030, inputData({ wordIndex: 1, charIndex: 0 }));
 
-      const perWord = getEventsPerWord();
+      const perWord = getEventsPerWord(getAllTestEvents());
       expect(perWord.get(0)).toHaveLength(2);
       expect(perWord.get(1)).toHaveLength(1);
     });
@@ -266,7 +266,7 @@ describe("data.ts", () => {
         wordIndex: 0,
       });
 
-      const perWord = getEventsPerWord();
+      const perWord = getEventsPerWord(getAllTestEvents());
       expect(perWord.get(0)).toHaveLength(3);
     });
 
@@ -277,7 +277,7 @@ describe("data.ts", () => {
         inputType: "deleteContentBackward",
       } as InputEventData);
 
-      const perWord = getEventsPerWord();
+      const perWord = getEventsPerWord(getAllTestEvents());
       expect(perWord.get(0)).toHaveLength(1);
     });
 
@@ -285,7 +285,7 @@ describe("data.ts", () => {
       logTestEvent("input", 1010, inputData({ wordIndex: 0, charIndex: 0 }));
       logTestEvent("input", 1100, inputData({ wordIndex: 0, charIndex: 1 }));
 
-      const perWord = getEventsPerWord(undefined, 50);
+      const perWord = getEventsPerWord(getAllTestEvents(), undefined, 50);
       expect(perWord.get(0)).toHaveLength(1);
     });
 
@@ -293,7 +293,7 @@ describe("data.ts", () => {
       logTestEvent("input", 1010, inputData({ wordIndex: 0, charIndex: 0 }));
       logTestEvent("input", 1100, inputData({ wordIndex: 0, charIndex: 1 }));
 
-      const perWord = getEventsPerWord(50);
+      const perWord = getEventsPerWord(getAllTestEvents(), 50);
       expect(perWord.get(0)).toHaveLength(1);
       const first = perWord.get(0)?.[0];
       expect(first?.type === "input" && first.data.charIndex).toBe(1);
diff --git a/frontend/__tests__/test/events/stats.spec.ts b/frontend/__tests__/test/events/stats.spec.ts
index 8a8ab0044f63..9779372e2821 100644
--- a/frontend/__tests__/test/events/stats.spec.ts
+++ b/frontend/__tests__/test/events/stats.spec.ts
@@ -12,7 +12,7 @@ vi.mock("../../../src/ts/test/test-state", () => ({
 }));
 
 vi.mock("../../../src/ts/config/store", () => ({
-  Config: { mode: "words", funbox: [] as string[] },
+  Config: { mode: "words", funbox: [] as string[], words: 25, time: 0 },
   getConfig: {},
 }));
 
@@ -37,13 +37,19 @@ vi.mock("../../../src/ts/test/custom-text", () => ({
   getLimit: () => customTextLimit,
 }));
 
+vi.mock("../../../src/ts/states/test", () => ({
+  getCurrentQuote: () => null,
+}));
+
 import {
   logTestEvent,
   resetTestEvents,
   getAllTestEvents,
   cleanupData,
+  buildEventLog,
   __testing,
 } from "../../../src/ts/test/events/data";
+import { getEventsPerWord } from "../../../src/ts/test/events/helpers";
 import {
   getStartToFirstKeypressMs,
   getLastKeypressToEndMs,
@@ -157,6 +163,8 @@ describe("stats.ts", () => {
     __testing.resetPressedKeys();
     (Config as { mode: string }).mode = "words";
     (Config as { funbox: string[] }).funbox = [];
+    (Config as { words: number }).words = 25;
+    (Config as { time: number }).time = 0;
     (TestState as { activeWordIndex: number }).activeWordIndex = 0;
     TestWords.list.length = 0;
     inputPerWord.clear();
@@ -170,9 +178,9 @@ describe("stats.ts", () => {
       logTestEvent("timer", 4000, timer("step", 3));
       logTestEvent("timer", 4000, timer("end", 3));
 
-      const events = getAllTestEvents();
+      const eventLog = buildEventLog();
       // end testMs=3000, last step testMs=3000 — gap is 0 < 500, end skipped
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([
         1000, 2000, 3000,
       ]);
     });
@@ -182,9 +190,9 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2500, timer("end", 1));
 
-      const events = getAllTestEvents();
+      const eventLog = buildEventLog();
       // endMs=1500 → 1500%1000=500ms → roundTo2(0.5)=0.5 → boundary added
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([1000, 1500]);
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([1000, 1500]);
     });
 
     it("skips end when too close to last step", () => {
@@ -192,9 +200,9 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2400, timer("end", 1));
 
-      const events = getAllTestEvents();
+      const eventLog = buildEventLog();
       // end at testMs 1400, last step at testMs 1000 — gap is 400 < 500
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([1000]);
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([1000]);
     });
 
     it("includes end boundary when endMs % 1000 rounds to 0.5s", () => {
@@ -203,8 +211,8 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2496, timer("end", 1));
 
-      const events = getAllTestEvents();
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([1000, 1496]);
+      const eventLog = buildEventLog();
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([1000, 1496]);
     });
 
     it("skips end boundary when endMs % 1000 rounds below 0.5s", () => {
@@ -213,8 +221,8 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2494, timer("end", 1));
 
-      const events = getAllTestEvents();
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([1000]);
+      const eventLog = buildEventLog();
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([1000]);
     });
 
     it("skips end boundary for .49 test even when step fires slightly early (drift)", () => {
@@ -225,8 +233,8 @@ describe("stats.ts", () => {
       logTestEvent("timer", 1995, timer("step", 1));
       logTestEvent("timer", 2490, timer("end", 1));
 
-      const events = getAllTestEvents();
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([995]);
+      const eventLog = buildEventLog();
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([995]);
     });
 
     it("includes end boundary for .99 test even when step fires late (drift)", () => {
@@ -237,8 +245,8 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2510, timer("step", 1));
       logTestEvent("timer", 2990, timer("end", 1));
 
-      const events = getAllTestEvents();
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([1510, 1990]);
+      const eventLog = buildEventLog();
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([1510, 1990]);
     });
 
     it("excludes short trailing interval (<500ms) for non-round test duration", () => {
@@ -247,9 +255,9 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2350, timer("end", 1));
 
-      const events = getAllTestEvents();
+      const eventLog = buildEventLog();
       // end testMs=1350, last step testMs=1000 — gap is 350 < 500, end skipped
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([1000]);
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([1000]);
     });
 
     it("excludes short trailing interval (<500ms) for sub one second test duration", () => {
@@ -257,16 +265,16 @@ describe("stats.ts", () => {
       logTestEvent("timer", 1000, timer("start", 0));
       logTestEvent("timer", 1350, timer("end", 0));
 
-      const events = getAllTestEvents();
+      const eventLog = buildEventLog();
       // end testMs=1350, last step testMs=1000 — gap is 350 < 500, end skipped
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([]);
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([]);
     });
 
     it("returns empty when no timer events", () => {
       logTestEvent("keydown", 1000, keyDown());
 
-      const events = getAllTestEvents();
-      expect(statsTesting.getTimerBoundaries(events)).toEqual([]);
+      const eventLog = buildEventLog();
+      expect(statsTesting.getTimerBoundaries(eventLog)).toEqual([]);
     });
 
     it("adjusts end in zen mode by removing trailing afk", () => {
@@ -279,8 +287,8 @@ describe("stats.ts", () => {
       // last keypress at testMs 500, end at testMs 4000 → lkte = 3500
       logTestEvent("timer", 5000, timer("end", 4));
 
-      const events = getAllTestEvents();
-      const boundaries = statsTesting.getTimerBoundaries(events);
+      const eventLog = buildEventLog();
+      const boundaries = statsTesting.getTimerBoundaries(eventLog);
       // adjusted end = 4000 - 3500 = 500, steps at 1000 and 2000 are past it
       expect(boundaries).toEqual([500]);
     });
@@ -295,9 +303,9 @@ describe("stats.ts", () => {
       }
       logTestEvent("timer", 19997, timer("end", 20));
 
-      const events = getAllTestEvents();
+      const eventLog = buildEventLog();
       // 20 step boundaries, no end boundary (testSeconds rounds to 20.00)
-      expect(statsTesting.getTimerBoundaries(events)).toHaveLength(20);
+      expect(statsTesting.getTimerBoundaries(eventLog)).toHaveLength(20);
     });
 
     it("skips end boundary in time mode even when endMs %1000 >= 500ms", () => {
@@ -311,8 +319,8 @@ describe("stats.ts", () => {
       }
       logTestEvent("timer", 119994, timer("end", 120));
 
-      const events = getAllTestEvents();
-      const boundaries = statsTesting.getTimerBoundaries(events);
+      const eventLog = buildEventLog();
+      const boundaries = statsTesting.getTimerBoundaries(eventLog);
       // 120 step boundaries, no end boundary
       expect(boundaries).toHaveLength(120);
     });
@@ -327,8 +335,8 @@ describe("stats.ts", () => {
         }
         logTestEvent("timer", 29994, timer("end", 30));
 
-        const events = getAllTestEvents();
-        expect(statsTesting.getTimerBoundaries(events)).toHaveLength(30);
+        const eventLog = buildEventLog();
+        expect(statsTesting.getTimerBoundaries(eventLog)).toHaveLength(30);
       } finally {
         customTextLimit.mode = "words";
       }
@@ -357,8 +365,8 @@ describe("stats.ts", () => {
           }
           logTestEvent("timer", endMs, timer("end", fullSeconds));
 
-          const events = getAllTestEvents();
-          const boundaries = statsTesting.getTimerBoundaries(events);
+          const eventLog = buildEventLog();
+          const boundaries = statsTesting.getTimerBoundaries(eventLog);
           const roundedDuration = Math.round(endMs / 1000);
           expect(boundaries).toHaveLength(roundedDuration);
         });
@@ -371,14 +379,14 @@ describe("stats.ts", () => {
       logTestEvent("timer", 1000, timer("start", 0));
       logTestEvent("keydown", 1150, keyDown());
 
-      expect(getStartToFirstKeypressMs()).toBe(150);
+      expect(getStartToFirstKeypressMs(buildEventLog())).toBe(150);
     });
 
     it("returns 0 if keydown comes before start", () => {
       logTestEvent("keydown", 900, keyDown());
       logTestEvent("timer", 1000, timer("start", 0));
 
-      expect(getStartToFirstKeypressMs()).toBe(0);
+      expect(getStartToFirstKeypressMs(buildEventLog())).toBe(0);
     });
 
     it("returns 0 in zen mode", () => {
@@ -386,11 +394,11 @@ describe("stats.ts", () => {
       logTestEvent("timer", 1000, timer("start", 0));
       logTestEvent("keydown", 1150, keyDown());
 
-      expect(getStartToFirstKeypressMs()).toBe(0);
+      expect(getStartToFirstKeypressMs(buildEventLog())).toBe(0);
     });
 
     it("returns 0 if no events", () => {
-      expect(getStartToFirstKeypressMs()).toBe(0);
+      expect(getStartToFirstKeypressMs(buildEventLog())).toBe(0);
     });
   });
 
@@ -402,7 +410,7 @@ describe("stats.ts", () => {
       logTestEvent("keydown", 1800, keyDown());
       logTestEvent("timer", 2000, timer("end", 1));
 
-      expect(getLastKeypressToEndMs()).toBe(200);
+      expect(getLastKeypressToEndMs(buildEventLog())).toBe(200);
     });
 
     it("returns 0 in zen mode", () => {
@@ -411,7 +419,7 @@ describe("stats.ts", () => {
       logTestEvent("keydown", 1500, keyDown());
       logTestEvent("timer", 2000, timer("end", 1));
 
-      expect(getLastKeypressToEndMs()).toBe(0);
+      expect(getLastKeypressToEndMs(buildEventLog())).toBe(0);
     });
   });
 
@@ -421,12 +429,12 @@ describe("stats.ts", () => {
       logTestEvent("keydown", 1500, keyDown());
       logTestEvent("timer", 4000, timer("end", 3));
 
-      expect(getTestDurationMs()).toBe(3000);
+      expect(getTestDurationMs(buildEventLog())).toBe(3000);
     });
 
     it("returns 0 if no end event", () => {
       logTestEvent("timer", 1000, timer("start", 0));
-      expect(getTestDurationMs()).toBe(0);
+      expect(getTestDurationMs(buildEventLog())).toBe(0);
     });
   });
 
@@ -434,7 +442,7 @@ describe("stats.ts", () => {
     it("converts keypresses to WPM using real interval duration", () => {
       setupBasicTest();
 
-      const raw = getBurstHistory();
+      const raw = getBurstHistory(buildEventLog());
       // 3 keypresses in 1s = (3/5)*60 = 36 WPM
       expect(raw[0]).toBe(36);
       // 2 keypresses in 1s = (2/5)*60 = 24 WPM
@@ -454,7 +462,7 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2000, timer("end", 1));
 
-      const raw = getBurstHistory();
+      const raw = getBurstHistory(buildEventLog());
       expect(raw).toEqual([12]); // 1 keypress in 1s
     });
   });
@@ -470,13 +478,13 @@ describe("stats.ts", () => {
       logTestEvent("timer", 3000, timer("step", 2));
       logTestEvent("timer", 3000, timer("end", 2));
 
-      const errors = getErrorCountHistory();
+      const errors = getErrorCountHistory(buildEventLog());
       expect(errors).toEqual([1, 2]);
     });
 
     it("returns zeros when all correct", () => {
       setupBasicTest();
-      const errors = getErrorCountHistory();
+      const errors = getErrorCountHistory(buildEventLog());
       expect(errors).toEqual([0, 0, 0]);
     });
   });
@@ -494,7 +502,7 @@ describe("stats.ts", () => {
       logTestEvent("timer", 4000, timer("step", 3));
       logTestEvent("timer", 4000, timer("end", 3));
 
-      expect(getAfkDuration()).toBe(1);
+      expect(getAfkDuration(buildEventLog())).toBe(1);
     });
 
     it("returns 0 when all intervals have keydowns", () => {
@@ -507,7 +515,7 @@ describe("stats.ts", () => {
       logTestEvent("timer", 3000, timer("step", 2));
       logTestEvent("timer", 3000, timer("end", 2));
 
-      expect(getAfkDuration()).toBe(0);
+      expect(getAfkDuration(buildEventLog())).toBe(0);
     });
   });
 
@@ -609,7 +617,7 @@ describe("stats.ts", () => {
 
       logTestEvent("timer", 5000, timer("end", 4));
 
-      const history = getInputHistory();
+      const history = getInputHistory(buildEventLog());
       expect(history[0]).toBe("");
       expect(history[1]).toBe("");
     });
@@ -621,14 +629,14 @@ describe("stats.ts", () => {
       logTestEvent("input", 1200, input({ charIndex: 1 }));
       logTestEvent("input", 1300, input({ charIndex: 2, correct: false }));
 
-      const acc = getAccuracy();
+      const acc = getAccuracy(buildEventLog());
       expect(acc.correct).toBe(2);
       expect(acc.incorrect).toBe(1);
       expect(acc.percentage).toBeCloseTo(66.67, 1);
     });
 
     it("returns 0% for no events", () => {
-      const acc = getAccuracy();
+      const acc = getAccuracy(buildEventLog());
       expect(acc.percentage).toBe(0);
     });
 
@@ -640,7 +648,7 @@ describe("stats.ts", () => {
         inputType: "deleteContentBackward",
       } as InputEventData);
 
-      const acc = getAccuracy();
+      const acc = getAccuracy(buildEventLog());
       expect(acc.correct).toBe(1);
       expect(acc.incorrect).toBe(0);
     });
@@ -653,7 +661,7 @@ describe("stats.ts", () => {
         input({ charIndex: 1, correct: false, inputStopped: true }),
       );
 
-      const acc = getAccuracy();
+      const acc = getAccuracy(buildEventLog());
       expect(acc.correct).toBe(1);
       expect(acc.incorrect).toBe(1);
       expect(acc.percentage).toBe(50);
@@ -669,14 +677,14 @@ describe("stats.ts", () => {
       logTestEvent("keydown", 1250, keyDown());
       logTestEvent("keyup", 1300, keyUp());
 
-      const spacings = getKeypressSpacing();
+      const spacings = getKeypressSpacing(buildEventLog());
       expect(spacings).toEqual([100, 150]);
     });
 
     it("returns empty for single keydown", () => {
       logTestEvent("keydown", 1000, keyDown());
 
-      expect(getKeypressSpacing()).toEqual([]);
+      expect(getKeypressSpacing(buildEventLog())).toEqual([]);
     });
 
     it("clamps a pre-start first keydown so the timing invariant holds", () => {
@@ -696,11 +704,18 @@ describe("stats.ts", () => {
       logTestEvent("timer", 1000, timer("step", 1));
       logTestEvent("timer", 1000, timer("end", 1));
 
-      const sumSpacing = getKeypressSpacing().reduce((a, b) => a + b, 0);
+      const sumSpacing = getKeypressSpacing(buildEventLog()).reduce(
+        (a, b) => a + b,
+        0,
+      );
       const total =
-        getStartToFirstKeypressMs() + sumSpacing + getLastKeypressToEndMs();
+        getStartToFirstKeypressMs(buildEventLog()) +
+        sumSpacing +
+        getLastKeypressToEndMs(buildEventLog());
 
-      expect(Math.abs(getTestDurationMs() - total)).toBeLessThan(100);
+      expect(Math.abs(getTestDurationMs(buildEventLog()) - total)).toBeLessThan(
+        100,
+      );
     });
 
     it("cleanupData drops post-end keydowns so the timing invariant holds", () => {
@@ -725,11 +740,18 @@ describe("stats.ts", () => {
 
       cleanupData();
 
-      const sumSpacing = getKeypressSpacing().reduce((a, b) => a + b, 0);
+      const sumSpacing = getKeypressSpacing(buildEventLog()).reduce(
+        (a, b) => a + b,
+        0,
+      );
       const total =
-        getStartToFirstKeypressMs() + sumSpacing + getLastKeypressToEndMs();
+        getStartToFirstKeypressMs(buildEventLog()) +
+        sumSpacing +
+        getLastKeypressToEndMs(buildEventLog());
 
-      expect(Math.abs(getTestDurationMs() - total)).toBeLessThan(100);
+      expect(Math.abs(getTestDurationMs(buildEventLog()) - total)).toBeLessThan(
+        100,
+      );
     });
   });
 
@@ -741,7 +763,7 @@ describe("stats.ts", () => {
       logTestEvent("keyup", 1080, keyUp("KeyA"));
       logTestEvent("keyup", 1100, keyUp("KeyS"));
 
-      expect(getKeypressOverlap()).toBe(30);
+      expect(getKeypressOverlap(buildEventLog())).toBe(30);
     });
 
     it("returns 0 with no overlap", () => {
@@ -750,7 +772,7 @@ describe("stats.ts", () => {
       logTestEvent("keydown", 1100, keyDown("KeyS"));
       logTestEvent("keyup", 1150, keyUp("KeyS"));
 
-      expect(getKeypressOverlap()).toBe(0);
+      expect(getKeypressOverlap(buildEventLog())).toBe(0);
     });
   });
 
@@ -761,14 +783,14 @@ describe("stats.ts", () => {
       logTestEvent("keydown", 1100, keyDown("KeyS"));
       logTestEvent("keyup", 1200, keyUp("KeyS"));
 
-      const durations = getKeypressDurations();
+      const durations = getKeypressDurations(buildEventLog());
       expect(durations).toEqual([80, 100]);
     });
 
     it("returns 0 for keys without keyup", () => {
       logTestEvent("keydown", 1000, keyDown());
 
-      const durations = getKeypressDurations();
+      const durations = getKeypressDurations(buildEventLog());
       expect(durations).toEqual([0]);
     });
   });
@@ -777,7 +799,7 @@ describe("stats.ts", () => {
     it("counts insertText events per timer interval", () => {
       setupBasicTest();
 
-      const kps = getKeypressesPerSecond();
+      const kps = getKeypressesPerSecond(buildEventLog());
       expect(kps).toEqual([3, 2, 1]);
     });
 
@@ -792,12 +814,12 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2000, timer("end", 1));
 
-      expect(getKeypressesPerSecond()).toEqual([1]);
+      expect(getKeypressesPerSecond(buildEventLog())).toEqual([1]);
     });
 
     it("returns empty for no timer events", () => {
       logTestEvent("input", 1200, input());
-      expect(getKeypressesPerSecond()).toEqual([]);
+      expect(getKeypressesPerSecond(buildEventLog())).toEqual([]);
     });
 
     it("counts keypresses in last partial second when gap rounds to 0.5s", () => {
@@ -811,41 +833,53 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2496, timer("end", 1));
 
       // endMs=1496, 1496%1000=496ms → roundTo2(0.496)=0.5 → end boundary added → [1, 2]
-      expect(getKeypressesPerSecond()).toEqual([1, 2]);
+      expect(getKeypressesPerSecond(buildEventLog())).toEqual([1, 2]);
     });
   });
 
   describe("getTargetWord", () => {
     it("returns simulatedInput in zen mode", () => {
       (Config as { mode: string }).mode = "zen";
-      expect(statsTesting.getTargetWord(0, "anything", false)).toBe("anything");
+      expect(
+        statsTesting.getTargetWord(buildEventLog(), 0, "anything", false),
+      ).toBe("anything");
     });
 
     it("returns word without trailing space when it ends with newline", () => {
       TestWords.list.push("hello\n");
-      expect(statsTesting.getTargetWord(0, "hello", false)).toBe("hello\n");
+      expect(
+        statsTesting.getTargetWord(buildEventLog(), 0, "hello", false),
+      ).toBe("hello\n");
     });
 
     it("appends trailing space for non-last word", () => {
       TestWords.list.push("hello");
-      expect(statsTesting.getTargetWord(0, "hello", false)).toBe("hello ");
+      expect(
+        statsTesting.getTargetWord(buildEventLog(), 0, "hello", false),
+      ).toBe("hello ");
     });
 
     it("does not append trailing space for last word", () => {
       TestWords.list.push("hello");
-      expect(statsTesting.getTargetWord(0, "hello", true)).toBe("hello");
+      expect(
+        statsTesting.getTargetWord(buildEventLog(), 0, "hello", true),
+      ).toBe("hello");
     });
 
     it("does not append trailing space when nospace funbox is active", () => {
       TestWords.list.push("hello");
       (Config as { funbox: string[] }).funbox = ["nospace"];
-      expect(statsTesting.getTargetWord(0, "hello", false)).toBe("hello");
+      expect(
+        statsTesting.getTargetWord(buildEventLog(), 0, "hello", false),
+      ).toBe("hello");
     });
 
     it("does not append trailing space when underscore_spaces funbox is active", () => {
       TestWords.list.push("hello");
       (Config as { funbox: string[] }).funbox = ["underscore_spaces"];
-      expect(statsTesting.getTargetWord(0, "hello", false)).toBe("hello");
+      expect(
+        statsTesting.getTargetWord(buildEventLog(), 0, "hello", false),
+      ).toBe("hello");
     });
   });
 
@@ -863,7 +897,7 @@ describe("stats.ts", () => {
         );
       }
 
-      const chars = getChars();
+      const chars = getChars(buildEventLog());
       expect(chars.allCorrect).toBe(5);
       expect(chars.correctWord).toBe(5);
       expect(chars.incorrect).toBe(0);
@@ -887,7 +921,7 @@ describe("stats.ts", () => {
         input({ charIndex: 1, wordIndex: 0, data: "x", correct: false }),
       );
 
-      const chars = getChars();
+      const chars = getChars(buildEventLog());
       expect(chars.allCorrect).toBe(1);
       expect(chars.incorrect).toBe(1);
     });
@@ -913,7 +947,7 @@ describe("stats.ts", () => {
         input({ charIndex: 2, wordIndex: 0, data: "c" }),
       );
 
-      const chars = getChars();
+      const chars = getChars(buildEventLog());
       expect(chars.extra).toBe(1);
     });
 
@@ -955,7 +989,7 @@ describe("stats.ts", () => {
         input({ charIndex: 0, wordIndex: 1, data: "w" }),
       );
 
-      const chars = getChars();
+      const chars = getChars(buildEventLog());
       // word 0: "hel " vs "hello " → 3 correct, 1 incorrect, 2 missed
       // word 1: "w" vs "world" → 1 correct, 4 missed (words mode counts partial last word missed)
       expect(chars.missed).toBe(6);
@@ -979,7 +1013,7 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2000, timer("end", 1));
 
-      const wpm = getWpmHistory();
+      const wpm = getWpmHistory(buildEventLog());
       // 5 correct chars in 1s = (5/5)*60 = 60 WPM
       expect(wpm).toEqual([60]);
     });
@@ -1020,7 +1054,7 @@ describe("stats.ts", () => {
       logTestEvent("timer", 3000, timer("step", 2));
       logTestEvent("timer", 3000, timer("end", 2));
 
-      const wpm = getWpmHistory();
+      const wpm = getWpmHistory(buildEventLog());
       expect(wpm.length).toBe(2);
       // at 1s: "ab " fully correct = 3 correctWord chars → (3/5)*60 = 36
       expect(wpm[0]).toBe(36);
@@ -1058,7 +1092,7 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2000, timer("end", 1));
 
-      const wpm = getWpmHistory();
+      const wpm = getWpmHistory(buildEventLog());
       // both words fully correct → 4 correctWord chars in 1s = (4/5)*60 = 48
       expect(wpm).toEqual([48]);
     });
@@ -1089,11 +1123,155 @@ describe("stats.ts", () => {
       logTestEvent("timer", 2000, timer("step", 1));
       logTestEvent("timer", 2000, timer("end", 1));
 
-      const wpm = getWpmHistory();
+      const wpm = getWpmHistory(buildEventLog());
       // word 0: "hello\n" target matches input "hello\n" → 6 correctWord
       // word 1: "world" (last word) matches → 5 correctWord
       // 11 chars in 1s = (11/5)*60 = 132
       expect(wpm).toEqual([132]);
     });
   });
+
+  describe("inferActiveWordIndex", () => {
+    it("returns 0 when no word has input", () => {
+      const eventsPerWord = new Map();
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(0);
+    });
+
+    it("returns 0 when entries exist but none have input", () => {
+      // word events present but all input data is empty / inputValue=""
+      logTestEvent(
+        "input",
+        1000,
+        input({ wordIndex: 0, data: "", inputValue: "" }),
+      );
+      const eventsPerWord = getEventsPerWord(getAllTestEvents());
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(0);
+    });
+
+    it("returns max wordIndex when last word has no committed space", () => {
+      // word 0: "hi"
+      logTestEvent("input", 1000, input({ wordIndex: 0, data: "h" }));
+      logTestEvent(
+        "input",
+        1050,
+        input({ wordIndex: 0, charIndex: 1, data: "i" }),
+      );
+      // space commit on word 0
+      logTestEvent(
+        "input",
+        1100,
+        input({
+          wordIndex: 0,
+          charIndex: 2,
+          data: " ",
+          commitsWord: true,
+          inputValue: "hi ",
+        }),
+      );
+      // word 1: "yo" (no trailing space)
+      logTestEvent("input", 1200, input({ wordIndex: 1, data: "y" }));
+      logTestEvent(
+        "input",
+        1250,
+        input({ wordIndex: 1, charIndex: 1, data: "o" }),
+      );
+
+      const eventsPerWord = getEventsPerWord(getAllTestEvents());
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(1);
+    });
+
+    it("advances past last word when trailing space was committed", () => {
+      // word 0: "hi "
+      logTestEvent("input", 1000, input({ wordIndex: 0, data: "h" }));
+      logTestEvent(
+        "input",
+        1050,
+        input({ wordIndex: 0, charIndex: 1, data: "i" }),
+      );
+      logTestEvent(
+        "input",
+        1100,
+        input({
+          wordIndex: 0,
+          charIndex: 2,
+          data: " ",
+          commitsWord: true,
+          inputValue: "hi ",
+        }),
+      );
+
+      const eventsPerWord = getEventsPerWord(getAllTestEvents());
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(1);
+    });
+
+    it("does not advance when last event is a non-space insert", () => {
+      logTestEvent("input", 1000, input({ wordIndex: 0, data: "h" }));
+      logTestEvent(
+        "input",
+        1050,
+        input({ wordIndex: 0, charIndex: 1, data: "i" }),
+      );
+
+      const eventsPerWord = getEventsPerWord(getAllTestEvents());
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(0);
+    });
+
+    it("does not advance when last event is a backspace", () => {
+      logTestEvent("input", 1000, input({ wordIndex: 0, data: "h" }));
+      logTestEvent(
+        "input",
+        1050,
+        input({ wordIndex: 0, charIndex: 1, data: "i" }),
+      );
+      logTestEvent(
+        "input",
+        1100,
+        input({
+          wordIndex: 0,
+          charIndex: 1,
+          inputType: "deleteContentBackward",
+          data: "",
+          inputValue: "h",
+        }),
+      );
+
+      const eventsPerWord = getEventsPerWord(getAllTestEvents());
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(0);
+    });
+
+    it("picks max wordIndex across non-contiguous buckets (post-regression order)", () => {
+      // simulates a backspace that crosses back into word 0 AFTER word 1 events.
+      // Map insertion order is still 0, 1 (word 0 was set first), so the loop
+      // must compute true max by key, not by iteration position.
+      logTestEvent("input", 1000, input({ wordIndex: 0, data: "h" }));
+      logTestEvent(
+        "input",
+        1050,
+        input({
+          wordIndex: 0,
+          charIndex: 1,
+          data: " ",
+          commitsWord: true,
+          inputValue: "h ",
+        }),
+      );
+      logTestEvent("input", 1100, input({ wordIndex: 1, data: "y" }));
+      // backspace lands a destination event back into word 0
+      logTestEvent(
+        "input",
+        1200,
+        input({
+          wordIndex: 0,
+          charIndex: 1,
+          inputType: "deleteContentBackward",
+          data: "",
+          inputValue: "h",
+        }),
+      );
+
+      const eventsPerWord = getEventsPerWord(getAllTestEvents());
+      // word 1 has input "y" (no trailing space) → max is 1, no advance
+      expect(statsTesting.inferActiveWordIndex(eventsPerWord)).toBe(1);
+    });
+  });
 });
diff --git a/frontend/src/ts/commandline/lists.ts b/frontend/src/ts/commandline/lists.ts
index f579bb2a44a2..14a455c6441e 100644
--- a/frontend/src/ts/commandline/lists.ts
+++ b/frontend/src/ts/commandline/lists.ts
@@ -40,8 +40,7 @@ import {
   showFpsCounter,
 } from "../components/layout/overlays/FpsCounter";
 import { applyConfigFromJson } from "../config/lifecycle";
-import { getAllTestEvents } from "../test/events/data";
-import * as TestWords from "../test/test-words";
+import { buildEventLog } from "../test/events/data";
 
 const challengesPromise = JSONData.getChallengeList();
 challengesPromise
@@ -308,18 +307,13 @@ export const commands: CommandsSubgroup = {
     },
     {
       id: "copyResultData",
-      display: "Copy result data",
+      display: "Copy event log (result data)",
       alias: "stats events",
       icon: "fa-cog",
       visible: false,
       exec: async (): Promise<void> => {
         navigator.clipboard
-          .writeText(
-            JSON.stringify({
-              events: getAllTestEvents(),
-              words: TestWords.words.list,
-            }),
-          )
+          .writeText(JSON.stringify(buildEventLog()))
           .then(() => {
             showSuccessNotification("Copied to clipboard");
           })
diff --git a/frontend/src/ts/components/dev/DevTools.tsx b/frontend/src/ts/components/dev/DevTools.tsx
index 8e72594a021f..b3414013bda7 100644
--- a/frontend/src/ts/components/dev/DevTools.tsx
+++ b/frontend/src/ts/components/dev/DevTools.tsx
@@ -13,9 +13,9 @@ if (import.meta.env.DEV) {
       default: m.DevOptionsModal,
     })),
   );
-  const LazyTestDataPreviewModal = lazy(async () =>
-    import("../modals/TestDataPreviewModal").then((m) => ({
-      default: m.TestDataPreviewModal,
+  const LazyEventLogViewerModal = lazy(async () =>
+    import("../modals/EventLogViewerModal").then((m) => ({
+      default: m.EventLogViewerModal,
     })),
   );
 
@@ -38,7 +38,7 @@ if (import.meta.env.DEV) {
     <Suspense>
       <LazyTanstackDevtools />
       <LazyDevOptionsModal />
-      <LazyTestDataPreviewModal />
+      <LazyEventLogViewerModal />
       <LazySolidDevtoolsOverlay />
     </Suspense>
   );
diff --git a/frontend/src/ts/components/modals/DevOptionsModal.tsx b/frontend/src/ts/components/modals/DevOptionsModal.tsx
index 9548ea09a7fc..4f78c89a6367 100644
--- a/frontend/src/ts/components/modals/DevOptionsModal.tsx
+++ b/frontend/src/ts/components/modals/DevOptionsModal.tsx
@@ -168,8 +168,8 @@ export function DevOptionsModal(): JSXElement {
     },
     {
       icon: "fa-vials",
-      label: () => "Test Data Preview",
-      onClick: () => showModal("TestDataPreview"),
+      label: () => "Event Log Viewer",
+      onClick: () => showModal("EventLogViewer"),
     },
   ];
 
diff --git a/frontend/src/ts/components/modals/TestDataPreviewModal.tsx b/frontend/src/ts/components/modals/EventLogViewerModal.tsx
similarity index 96%
rename from frontend/src/ts/components/modals/TestDataPreviewModal.tsx
rename to frontend/src/ts/components/modals/EventLogViewerModal.tsx
index 9046446e489a..a9946ec8fe83 100644
--- a/frontend/src/ts/components/modals/TestDataPreviewModal.tsx
+++ b/frontend/src/ts/components/modals/EventLogViewerModal.tsx
@@ -10,22 +10,19 @@ import {
 } from "solid-js";
 
 import type {
+  EventLog,
   InputEventNoMs,
-  TestEvent,
+  TestEventNoMs,
   TestEventType,
 } from "../../test/events/types";
 
 import { hideModal } from "../../states/modals";
 import { getInputFromDom } from "../../test/events/helpers";
+import { EVENT_LOG_VERSION } from "../../test/events/types";
 import { cn } from "../../utils/cn";
 import { AnimatedModal } from "../common/AnimatedModal";
 import { Button } from "../common/Button";
 
-type TestContext = {
-  events: TestEvent[];
-  words: string[];
-};
-
 type Stage = "input" | "preview";
 
 const EVENT_TYPES: TestEventType[] = [
@@ -62,7 +59,7 @@ type TimelineSegment = {
 type RawSegment = Omit<TimelineSegment, "topPx">;
 
 function buildLanes(
-  events: TestEvent[],
+  events: TestEventNoMs[],
   visible: Set<TestEventType>,
 ): { segments: TimelineSegment[]; totalHeight: number } {
   const byType = new Map<TestEventType, RawSegment[]>();
@@ -183,34 +180,44 @@ function buildLanes(
   return { segments, totalHeight: Math.max(y, TIMELINE_TRACK_HEIGHT) };
 }
 
-function parseContext(raw: string): TestContext {
+function parseContext(raw: string): EventLog {
   const parsed = JSON.parse(raw) as unknown;
-  if (typeof parsed !== "object") {
-    throw new Error("Expected an object");
-  }
-  if (parsed === null) {
-    throw new Error("Expected an object, got null");
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("Expected an EventLog object");
   }
-  if (!("events" in parsed) || !("words" in parsed)) {
-    throw new Error("Expected { events: TestEvent[], words: string[] }");
+  if (
+    !("version" in parsed) ||
+    !("events" in parsed) ||
+    !("context" in parsed)
+  ) {
+    throw new Error(
+      `Expected EventLog { version: ${EVENT_LOG_VERSION}, events, context }`,
+    );
   }
-  if (typeof parsed.words === "string") {
-    parsed.words = parsed.words.split(" ");
+  if (parsed.version !== EVENT_LOG_VERSION) {
+    throw new Error(
+      `Unsupported EventLog version ${String(parsed.version)} (expected ${EVENT_LOG_VERSION})`,
+    );
   }
-  if (!Array.isArray((parsed as TestContext).events)) {
-    throw new Error("Expected { events: TestEvent[], words: string[] }");
+  if (!Array.isArray((parsed as EventLog).events)) {
+    throw new Error("EventLog.events must be an array");
   }
-  if (!Array.isArray((parsed as TestContext).words)) {
-    throw new Error("Expected { events: TestEvent[], words: string[] }");
+  const ctx = (parsed as EventLog).context as unknown;
+  if (
+    typeof ctx !== "object" ||
+    ctx === null ||
+    !Array.isArray((ctx as { targetWords?: unknown }).targetWords)
+  ) {
+    throw new Error("EventLog.context.targetWords must be a string array");
   }
-  return parsed as TestContext;
+  return parsed as EventLog;
 }
 
 function visualizeWhitespace(s: string): string {
   return s.replace(/ /g, "␣").replace(/\t/g, "→").replace(/\n/g, "↵");
 }
 
-function inputsPerWord(events: TestEvent[], wordCount: number): string[] {
+function inputsPerWord(events: TestEventNoMs[], wordCount: number): string[] {
   const buckets = new Map<number, InputEventNoMs[]>();
   for (const e of events) {
     if (e.type !== "input") continue;
@@ -223,10 +230,10 @@ function inputsPerWord(events: TestEvent[], wordCount: number): string[] {
   );
 }
 
-export function TestDataPreviewModal(): JSXElement {
+export function EventLogViewerModal(): JSXElement {
   const [stage, setStage] = createSignal<Stage>("input");
   const [raw, setRaw] = createSignal("");
-  const [ctx, setCtx] = createSignal<TestContext | null>(null);
+  const [ctx, setCtx] = createSignal<EventLog | null>(null);
   const [err, setErr] = createSignal<string | null>(null);
 
   const reset = (): void => {
@@ -249,8 +256,8 @@ export function TestDataPreviewModal(): JSXElement {
 
   return (
     <AnimatedModal
-      id="TestDataPreview"
-      title="Test Data Preview"
+      id="EventLogViewer"
+      title="Event Log Viewer"
       modalClass="max-w-full"
       beforeShow={reset}
     >
@@ -258,7 +265,7 @@ export function TestDataPreviewModal(): JSXElement {
         <div class="flex flex-col gap-4">
           <textarea
             class="bg-bg-secondary h-64 w-full rounded p-2 font-mono text-xs text-text"
-            placeholder='{"events": [...], "words": [...]}'
+            placeholder='{"version": 1, "events": [...], "context": {...}}'
             value={raw()}
             onInput={(e) => setRaw(e.currentTarget.value)}
             autocomplete="off"
@@ -269,7 +276,7 @@ export function TestDataPreviewModal(): JSXElement {
           <div class="flex justify-end gap-2">
             <Button
               variant="button"
-              onClick={() => hideModal("TestDataPreview")}
+              onClick={() => hideModal("EventLogViewer")}
               text="Cancel"
             />
             <Button variant="button" onClick={onShow} text="Show" />
@@ -278,7 +285,7 @@ export function TestDataPreviewModal(): JSXElement {
       </Show>
       <Show when={stage() === "preview" && ctx() !== null}>
         <PreviewContent
-          ctx={ctx() as TestContext}
+          ctx={ctx() as EventLog}
           onBack={() => setStage("input")}
         />
       </Show>
@@ -287,7 +294,7 @@ export function TestDataPreviewModal(): JSXElement {
 }
 
 function PreviewContent(props: {
-  ctx: TestContext;
+  ctx: EventLog;
   onBack: () => void;
 }): JSXElement {
   const maxMs = untrack(() =>
@@ -362,8 +369,8 @@ function PreviewContent(props: {
     if (!isSynced()) return { startEff: 0, slope: 1 };
     const sM = syncStartMark() as Mark;
     const eM = syncEndMark() as Mark;
-    const sE = syncStartEvent() as TestEvent;
-    const eE = syncEndEvent() as TestEvent;
+    const sE = syncStartEvent() as TestEventNoMs;
+    const eE = syncEndEvent() as TestEventNoMs;
     const a = sE.testMs;
     const b = eE.testMs;
     if (b === a) return { startEff: sM.videoMs, slope: 1 };
@@ -449,11 +456,11 @@ function PreviewContent(props: {
   );
 
   const finalInputs = untrack(() =>
-    inputsPerWord(props.ctx.events, props.ctx.words.length),
+    inputsPerWord(props.ctx.events, props.ctx.context.targetWords.length),
   );
 
   const liveInputs = createMemo(() =>
-    inputsPerWord(visibleEvents(), props.ctx.words.length),
+    inputsPerWord(visibleEvents(), props.ctx.context.targetWords.length),
   );
 
   const simulatedInput = createMemo(() =>
@@ -505,7 +512,7 @@ function PreviewContent(props: {
     let idx = -1;
     let best = -Infinity;
     for (let i = 0; i < events.length; i++) {
-      const ms = (events[i] as TestEvent).testMs;
+      const ms = (events[i] as TestEventNoMs).testMs;
       if (ms <= currentMs() && ms > best) {
         idx = i;
         best = ms;
@@ -1124,7 +1131,7 @@ function PreviewContent(props: {
               </tr>
             </thead>
             <tbody>
-              <For each={props.ctx.words}>
+              <For each={props.ctx.context.targetWords}>
                 {(word, i) => (
                   <tr
                     data-row={i()}
diff --git a/frontend/src/ts/states/modals.ts b/frontend/src/ts/states/modals.ts
index 9c8389cba168..ad559f52f514 100644
--- a/frontend/src/ts/states/modals.ts
+++ b/frontend/src/ts/states/modals.ts
@@ -7,7 +7,7 @@ export type ModalId =
   | "Commandline"
   | "DevOptions"
   | "DevInboxPicker"
-  | "TestDataPreview"
+  | "EventLogViewer"
   | "RegisterCaptcha"
   | "Alerts"
   | "SimpleModal"
diff --git a/frontend/src/ts/test/events/data.ts b/frontend/src/ts/test/events/data.ts
index ffd24f6a2a11..78d0fb852930 100644
--- a/frontend/src/ts/test/events/data.ts
+++ b/frontend/src/ts/test/events/data.ts
@@ -1,6 +1,8 @@
 import {
   CompositionTestEvent,
   CompositionTestEventData,
+  EVENT_LOG_VERSION,
+  EventLog,
   InputEvent,
   InputEventData,
   KeydownEvent,
@@ -16,7 +18,30 @@ import {
 import { keysToTrack } from "./helpers";
 import { Keycode } from "../../constants/keys";
 import { mean, roundTo2 } from "@monkeytype/util/numbers";
-import { resultCalculating } from "../test-state";
+import { bailedOut, koreanStatus, resultCalculating } from "../test-state";
+import * as TestWords from "../test-words";
+import { Config } from "../../config/store";
+import * as CustomText from "../../test/custom-text";
+import { getMode2 } from "../../utils/misc";
+import { isFunboxActiveWithProperty } from "../funbox/list";
+import { getCurrentQuote } from "../../states/test";
+
+export function buildEventLog(): EventLog {
+  return {
+    version: EVENT_LOG_VERSION,
+    events: getAllTestEvents(),
+    context: {
+      targetWords: [...TestWords.words.list],
+      mode: Config.mode,
+      mode2: getMode2(Config, getCurrentQuote()),
+      customTextLimitMode: CustomText.getLimit().mode,
+      customTextLimitValue: CustomText.getLimit().value,
+      isFunboxWithNospacePropertyActive: isFunboxActiveWithProperty("nospace"),
+      koreanStatus: koreanStatus,
+      bailedOut: bailedOut,
+    },
+  };
+}
 
 let keydownEvents: KeydownEvent[] = [];
 let keyupEvents: KeyupEvent[] = [];
@@ -323,34 +348,6 @@ export function getPressedKeys(): Map<
   return pressedKeys;
 }
 
-export function getEventsPerWord(
-  startMs?: number,
-  testMsLimit?: number,
-): Map<number, TestEventNoMs[]> {
-  let eventsPerWordIndex: Map<number, TestEventNoMs[]> = new Map();
-  const events = getAllTestEvents();
-  for (const event of events) {
-    if (!("wordIndex" in event.data)) {
-      continue;
-    }
-
-    if (startMs !== undefined && event.testMs < startMs) {
-      continue;
-    }
-
-    if (testMsLimit !== undefined && event.testMs > testMsLimit) {
-      break;
-    }
-
-    const wordIndex = event.data.wordIndex;
-
-    const existing = eventsPerWordIndex.get(wordIndex) ?? [];
-    existing.push(event);
-    eventsPerWordIndex.set(wordIndex, existing);
-  }
-  return eventsPerWordIndex;
-}
-
 export function forceReleaseAllKeys(): void {
   const keydownMsByCode = new Map<string, number>();
   for (const e of keydownEvents) keydownMsByCode.set(e.data.code, e.ms);
diff --git a/frontend/src/ts/test/events/helpers.ts b/frontend/src/ts/test/events/helpers.ts
index c6228ddae1c2..fecb45369005 100644
--- a/frontend/src/ts/test/events/helpers.ts
+++ b/frontend/src/ts/test/events/helpers.ts
@@ -184,3 +184,31 @@ export function findInputValueMismatches(
 
   return mismatches;
 }
+
+export function getEventsPerWord(
+  events: TestEventNoMs[],
+  startMs?: number,
+  testMsLimit?: number,
+): Map<number, TestEventNoMs[]> {
+  let eventsPerWordIndex: Map<number, TestEventNoMs[]> = new Map();
+  for (const event of events) {
+    if (!("wordIndex" in event.data)) {
+      continue;
+    }
+
+    if (startMs !== undefined && event.testMs < startMs) {
+      continue;
+    }
+
+    if (testMsLimit !== undefined && event.testMs > testMsLimit) {
+      break;
+    }
+
+    const wordIndex = event.data.wordIndex;
+
+    const existing = eventsPerWordIndex.get(wordIndex) ?? [];
+    existing.push(event);
+    eventsPerWordIndex.set(wordIndex, existing);
+  }
+  return eventsPerWordIndex;
+}
diff --git a/frontend/src/ts/test/events/stats.ts b/frontend/src/ts/test/events/stats.ts
index 9c325728a032..d5619051d4e4 100644
--- a/frontend/src/ts/test/events/stats.ts
+++ b/frontend/src/ts/test/events/stats.ts
@@ -1,17 +1,12 @@
-import { getAllTestEvents, getEventsPerWord } from "./data";
-import * as TestWords from "../../test/test-words";
 import { CharCounts, countChars } from "../../utils/strings";
-import * as CustomText from "../../test/custom-text";
-import { getInputFromDom } from "./helpers";
-import { activeWordIndex, bailedOut, koreanStatus } from "../test-state";
+import { getEventsPerWord, getInputFromDom } from "./helpers";
 import { calculateWpm } from "../../utils/numbers";
 import { roundTo2 } from "@monkeytype/util/numbers";
-import { TestEventNoMs } from "./types";
-import { Config } from "../../config/store";
-import { isFunboxActiveWithProperty } from "../funbox/list";
+import { EventLog, TestEventNoMs } from "./types";
 import Hangul from "hangul-js";
 
-function getTimerBoundaries(events: TestEventNoMs[]): number[] {
+function getTimerBoundaries(eventLog: EventLog): number[] {
+  const { events } = eventLog;
   const boundaries: number[] = [];
   let endMs: number | undefined;
 
@@ -25,8 +20,11 @@ function getTimerBoundaries(events: TestEventNoMs[]): number[] {
   }
 
   // in zen/bailout, cap to adjusted end to remove trailing afk seconds
-  if (endMs !== undefined && (Config.mode === "zen" || bailedOut)) {
-    const lkte = getRawLastKeypressToEndMs();
+  if (
+    endMs !== undefined &&
+    (eventLog.context.mode === "zen" || eventLog.context.bailedOut)
+  ) {
+    const lkte = getRawLastKeypressToEndMs(eventLog);
     if (lkte < 7000) {
       endMs -= lkte;
       // remove step boundaries past the adjusted end
@@ -47,9 +45,14 @@ function getTimerBoundaries(events: TestEventNoMs[]): number[] {
     // a different answer when the rounded seconds carry into the next integer
     // (e.g. endMs=19997: roundTo2(19.997)=20.00 → no bucket, but 997ms/1000
     // rounds to 0.5 → wrongly adds a bucket).
+
+    const { context } = eventLog;
     const isTimedTest =
-      Config.mode === "time" ||
-      (Config.mode === "custom" && CustomText.getLimit().mode === "time");
+      context.mode === "time" ||
+      (context.mode === "words" && context.mode2 === "0") ||
+      (context.mode === "custom" && context.customTextLimitMode === "time") ||
+      (context.mode === "custom" && context.customTextLimitValue === 0);
+
     const testSeconds = roundTo2(endMs / 1000);
     if (!isTimedTest && Math.round(testSeconds % 1) >= 0.5) {
       boundaries.push(endMs);
@@ -59,10 +62,10 @@ function getTimerBoundaries(events: TestEventNoMs[]): number[] {
   return boundaries;
 }
 
-export function getStartToFirstKeypressMs(): number {
-  if (Config.mode === "zen") return 0;
+export function getStartToFirstKeypressMs(eventLog: EventLog): number {
+  if (eventLog.context.mode === "zen") return 0;
 
-  const events = getAllTestEvents();
+  const { events } = eventLog;
 
   let firstKeypress: number | undefined;
   let start: number | undefined;
@@ -95,8 +98,8 @@ export function getStartToFirstKeypressMs(): number {
 
 // raw version is needed internally by getTestDurationMs to adjust
 // duration in zen/bailout — the public version returns 0 for zen
-function getRawLastKeypressToEndMs(): number {
-  const events = getAllTestEvents();
+function getRawLastKeypressToEndMs(eventLog: EventLog): number {
+  const { events } = eventLog;
 
   let lastKeypress: number | undefined;
   let end: number | undefined;
@@ -134,17 +137,20 @@ function getRawLastKeypressToEndMs(): number {
   return calc < 0 ? 0 : roundTo2(calc);
 }
 
-export function getLastKeypressToEndMs(): number {
-  if (Config.mode === "zen") return 0;
-  return getRawLastKeypressToEndMs();
+export function getLastKeypressToEndMs(eventLog: EventLog): number {
+  if (eventLog.context.mode === "zen") return 0;
+  return getRawLastKeypressToEndMs(eventLog);
 }
 
-function countPerInterval(predicate: (event: TestEventNoMs) => boolean): {
+function countPerInterval(
+  eventLog: EventLog,
+  predicate: (event: TestEventNoMs) => boolean,
+): {
   counts: number[];
   boundaries: number[];
 } {
-  const events = getAllTestEvents();
-  const boundaries = getTimerBoundaries(events);
+  const { events } = eventLog;
+  const boundaries = getTimerBoundaries(eventLog);
 
   const counts: number[] = [];
   let eventIndex = 0;
@@ -167,16 +173,18 @@ function countPerInterval(predicate: (event: TestEventNoMs) => boolean): {
   return { counts, boundaries };
 }
 
-export function getKeypressesPerSecond(): number[] {
+export function getKeypressesPerSecond(eventLog: EventLog): number[] {
   const { counts } = countPerInterval(
+    eventLog,
     (e) => e.type === "input" && e.data.inputType === "insertText",
   );
 
   return counts;
 }
 
-export function getBurstHistory(): number[] {
+export function getBurstHistory(eventLog: EventLog): number[] {
   const { counts, boundaries } = countPerInterval(
+    eventLog,
     (e) => e.type === "input" && e.data.inputType === "insertText",
   );
 
@@ -189,8 +197,8 @@ export function getBurstHistory(): number[] {
   });
 }
 
-export function getTestDurationMs(): number {
-  const events = getAllTestEvents();
+export function getTestDurationMs(eventLog: EventLog): number {
+  const { events } = eventLog;
 
   let end: number | undefined;
 
@@ -216,14 +224,14 @@ export function getTestDurationMs(): number {
     return 0;
   }
 
-  if (Config.mode === "zen" || bailedOut) {
-    const lkte = getRawLastKeypressToEndMs();
+  if (eventLog.context.mode === "zen" || eventLog.context.bailedOut) {
+    const lkte = getRawLastKeypressToEndMs(eventLog);
     if (lkte < 7000) {
       end -= lkte;
     }
   }
 
-  if (Config.mode !== "custom") {
+  if (eventLog.context.mode !== "custom") {
     end = roundTo2(end / 1000) * 1000;
   }
 
@@ -231,14 +239,15 @@ export function getTestDurationMs(): number {
 }
 
 function getTargetWord(
+  eventLog: EventLog,
   wordIndex: number,
   simulatedInput: string,
   lastWord: boolean,
 ): string {
-  if (Config.mode === "zen") {
+  if (eventLog.context.mode === "zen") {
     return simulatedInput;
   } else {
-    const word = TestWords.words.getText(wordIndex);
+    const word = eventLog.context.targetWords[wordIndex];
 
     if (word === undefined) {
       return "";
@@ -255,7 +264,7 @@ function getTargetWord(
       wordEnd = " ";
     }
 
-    if (isFunboxActiveWithProperty("nospace")) {
+    if (eventLog.context.isFunboxWithNospacePropertyActive) {
       wordEnd = "";
     }
 
@@ -264,18 +273,19 @@ function getTargetWord(
 }
 
 function countCharsForWordIndex(
+  eventLog: EventLog,
   wordIndex: number,
-  events: TestEventNoMs[],
+  wordEvents: TestEventNoMs[],
   lastWord: boolean,
   countPartial: boolean,
 ): CharCounts {
-  let simulatedInput = getInputFromDom(events);
-  if (koreanStatus) {
+  let simulatedInput = getInputFromDom(wordEvents);
+  if (eventLog.context.koreanStatus) {
     simulatedInput = Hangul.disassemble(simulatedInput).join("");
   }
 
-  let targetWord = getTargetWord(wordIndex, simulatedInput, lastWord);
-  if (koreanStatus) {
+  let targetWord = getTargetWord(eventLog, wordIndex, simulatedInput, lastWord);
+  if (eventLog.context.koreanStatus) {
     targetWord = Hangul.disassemble(targetWord).join("");
   }
 
@@ -307,14 +317,20 @@ function inferActiveWordIndex(
   return maxWordIndex;
 }
 
-export function getChars(): CharCounts {
+export function getChars(eventLog: EventLog): CharCounts {
+  const { events, context } = eventLog;
+  const { bailedOut } = context;
+
   const isTimedTest =
-    Config.mode === "time" ||
-    (Config.mode === "words" && Config.words === 0) ||
-    (Config.mode === "custom" && CustomText.getLimit().mode === "time");
-  const lastWordIndex = isTimedTest
-    ? activeWordIndex
-    : TestWords.words.list.length - 1;
+    context.mode === "time" ||
+    (context.mode === "words" && context.mode2 === "0") ||
+    (context.mode === "custom" && context.customTextLimitMode === "time") ||
+    (context.mode === "custom" && context.customTextLimitValue === 0);
+
+  const eventsPerWord = getEventsPerWord(events);
+  const lastWordIndex = inferActiveWordIndex(eventsPerWord);
+
+  const countPartial = isTimedTest || bailedOut;
 
   const acc: CharCounts = {
     allCorrect: 0,
@@ -324,9 +340,15 @@ export function getChars(): CharCounts {
     missed: 0,
   };
 
-  for (const [wordIndex, events] of getEventsPerWord()) {
+  for (const [wordIndex, wordEvents] of eventsPerWord) {
     const lastWord = wordIndex === lastWordIndex;
-    const c = countCharsForWordIndex(wordIndex, events, lastWord, isTimedTest);
+    const c = countCharsForWordIndex(
+      eventLog,
+      wordIndex,
+      wordEvents,
+      lastWord,
+      countPartial,
+    );
     acc.allCorrect += c.allCorrect;
     acc.correctWord += c.correctWord;
     acc.incorrect += c.incorrect;
@@ -339,8 +361,8 @@ export function getChars(): CharCounts {
   return acc;
 }
 
-export function getInputHistory(): string[] {
-  const eventsPerWordIndex = getEventsPerWord();
+export function getInputHistory(eventLog: EventLog): string[] {
+  const eventsPerWordIndex = getEventsPerWord(eventLog.events);
   const history: string[] = [];
 
   for (const [wordIndex, events] of eventsPerWordIndex) {
@@ -370,12 +392,12 @@ export function getInputHistory(): string[] {
   return history;
 }
 
-export function getAccuracy(): {
+export function getAccuracy(eventLog: EventLog): {
   correct: number;
   incorrect: number;
   percentage: number;
 } {
-  const events = getAllTestEvents();
+  const { events } = eventLog;
 
   let correct = 0;
   let incorrect = 0;
@@ -402,8 +424,8 @@ export function getAccuracy(): {
   };
 }
 
-export function getKeypressSpacing(): number[] {
-  const events = getAllTestEvents();
+export function getKeypressSpacing(eventLog: EventLog): number[] {
+  const { events } = eventLog;
 
   const spacings: number[] = [];
   let lastKeydownTime: number | undefined;
@@ -422,8 +444,8 @@ export function getKeypressSpacing(): number[] {
   return spacings;
 }
 
-export function getKeypressOverlap(): number {
-  const events = getAllTestEvents();
+export function getKeypressOverlap(eventLog: EventLog): number {
+  const { events } = eventLog;
 
   const keydownTimes: Map<
     string,
@@ -454,8 +476,9 @@ export function getKeypressOverlap(): number {
   return roundTo2(overlap);
 }
 
-export function getErrorCountHistory(): number[] {
+export function getErrorCountHistory(eventLog: EventLog): number[] {
   const { counts } = countPerInterval(
+    eventLog,
     (e) =>
       e.type === "input" &&
       e.data.inputType === "insertText" &&
@@ -464,9 +487,9 @@ export function getErrorCountHistory(): number[] {
   return counts;
 }
 
-export function getWpmHistory(): number[] {
-  const events = getAllTestEvents();
-  const boundaries = getTimerBoundaries(events);
+export function getWpmHistory(eventLog: EventLog): number[] {
+  const { events } = eventLog;
+  const boundaries = getTimerBoundaries(eventLog);
   if (boundaries.length === 0) return [];
 
   const eventsPerWord = new Map<number, TestEventNoMs[]>();
@@ -503,11 +526,13 @@ export function getWpmHistory(): number[] {
       if (wordEvents === undefined) continue;
       cachedIfNotLast.set(
         wordIndex,
-        countCharsForWordIndex(wordIndex, wordEvents, false, true).correctWord,
+        countCharsForWordIndex(eventLog, wordIndex, wordEvents, false, true)
+          .correctWord,
       );
       cachedIfLast.set(
         wordIndex,
-        countCharsForWordIndex(wordIndex, wordEvents, true, true).correctWord,
+        countCharsForWordIndex(eventLog, wordIndex, wordEvents, true, true)
+          .correctWord,
       );
     }
     dirty.clear();
@@ -529,9 +554,9 @@ export function getWpmHistory(): number[] {
   return wpmHistory;
 }
 
-export function getRawHistory(): number[] {
-  const events = getAllTestEvents();
-  const boundaries = getTimerBoundaries(events);
+export function getRawHistory(eventLog: EventLog): number[] {
+  const { events } = eventLog;
+  const boundaries = getTimerBoundaries(eventLog);
   if (boundaries.length === 0) return [];
 
   const eventsPerWord = new Map<number, TestEventNoMs[]>();
@@ -568,12 +593,14 @@ export function getRawHistory(): number[] {
       if (wordEvents === undefined) continue;
 
       const notLastCount = countCharsForWordIndex(
+        eventLog,
         wordIndex,
         wordEvents,
         false,
         true,
       );
       const lastCount = countCharsForWordIndex(
+        eventLog,
         wordIndex,
         wordEvents,
         true,
@@ -608,94 +635,16 @@ export function getRawHistory(): number[] {
   return rawHistory;
 }
 
-// export function getRawHistory(): number[] {
-//   const events = getAllTestEvents();
-//   const boundaries = getTimerBoundaries(events);
-//   if (boundaries.length === 0) return [];
-
-//   const eventsPerWord = new Map<number, TestEventNoMs[]>();
-//   const cachedIfLast = new Map<number, number>();
-//   const cachedIfNotLast = new Map<number, number>();
-//   const dirty = new Set<number>();
-//   const wpmHistory: number[] = [];
-
-//   let eventIdx = 0;
-
-//   for (const boundary of boundaries) {
-//     while (eventIdx < events.length) {
-//       const event = events[eventIdx];
-//       if (event === undefined || event.testMs > boundary) break;
-
-//       if ("wordIndex" in event.data) {
-//         const wordIndex = event.data.wordIndex;
-//         let list = eventsPerWord.get(wordIndex);
-//         if (list === undefined) {
-//           list = [];
-//           eventsPerWord.set(wordIndex, list);
-//         }
-//         list.push(event);
-//         dirty.add(wordIndex);
-//       }
-//       eventIdx++;
-//     }
-
-//     for (const wordIndex of dirty) {
-//       const wordEvents = eventsPerWord.get(wordIndex);
-//       if (wordEvents === undefined) continue;
-
-//       const input = getInputFromDom(wordEvents);
-//       if (input.length === 0) {
-//         cachedIfNotLast.set(wordIndex, 0);
-//         cachedIfLast.set(wordIndex, 0);
-//         continue;
-//       }
-
-//       const wordText =
-//         Config.mode === "zen" ? "" : (TestWords.words.getText(wordIndex) ?? "");
-
-//       const notLast = countChars(input, `${wordText} `, true);
-//       cachedIfNotLast.set(
-//         wordIndex,
-//         notLast.allCorrect + notLast.extra + notLast.incorrect,
-//       );
-
-//       const trimmed = input.trimEnd();
-//       const last = countChars(
-//         trimmed,
-//         Config.mode === "zen" ? trimmed : wordText,
-//         true,
-//       );
-//       cachedIfLast.set(
-//         wordIndex,
-//         last.allCorrect + last.extra + last.incorrect,
-//       );
-//     }
-//     dirty.clear();
-
-//     const lastWordIndex = inferActiveWordIndex(eventsPerWord);
-
-//     let totalCorrect = 0;
-//     for (const wordIndex of eventsPerWord.keys()) {
-//       const cache =
-//         wordIndex === lastWordIndex ? cachedIfLast : cachedIfNotLast;
-//       totalCorrect += cache.get(wordIndex) ?? 0;
-//     }
-
-//     wpmHistory.push(Math.round(calculateWpm(totalCorrect, boundary / 1000)));
-//   }
-
-//   return wpmHistory;
-// }
-
-export function getAfkDuration(): number {
+export function getAfkDuration(eventLog: EventLog): number {
   const { counts } = countPerInterval(
+    eventLog,
     (e) => e.type === "keydown" || e.type === "input",
   );
   return counts.reduce((total, c) => total + (c === 0 ? 1 : 0), 0);
 }
 
-export function getKeypressDurations(): number[] {
-  const events = getAllTestEvents();
+export function getKeypressDurations(eventLog: EventLog): number[] {
+  const { events } = eventLog;
 
   const keydownTimes: Map<
     string,
@@ -729,4 +678,5 @@ export function getKeypressDurations(): number[] {
 export const __testing = {
   getTimerBoundaries,
   getTargetWord,
+  inferActiveWordIndex,
 };
diff --git a/frontend/src/ts/test/events/types.ts b/frontend/src/ts/test/events/types.ts
index 011fac963aca..5095c3ea8353 100644
--- a/frontend/src/ts/test/events/types.ts
+++ b/frontend/src/ts/test/events/types.ts
@@ -1,8 +1,11 @@
+import { Config } from "@monkeytype/schemas/configs";
 import { Keycode } from "../../constants/keys";
 import {
   DeleteInputType,
   InsertInputType,
 } from "../../input/helpers/input-type";
+import { CustomTextLimitMode } from "@monkeytype/schemas/util";
+import { getMode2 } from "../../utils/misc";
 
 export type TestEventType =
   | "keydown"
@@ -120,3 +123,22 @@ export type CompositionTestEventData =
       data: string;
       wordIndex: number;
     };
+
+export type EventLogContext = {
+  targetWords: string[];
+  // isTimedTest: boolean;
+  mode: Config["mode"];
+  mode2: ReturnType<typeof getMode2>;
+  customTextLimitMode: CustomTextLimitMode;
+  customTextLimitValue: number;
+  bailedOut: boolean;
+  isFunboxWithNospacePropertyActive: boolean;
+  koreanStatus: boolean;
+};
+
+export const EVENT_LOG_VERSION = 1;
+export type EventLog = {
+  version: typeof EVENT_LOG_VERSION;
+  events: TestEventNoMs[];
+  context: EventLogContext;
+};
diff --git a/frontend/src/ts/test/test-logic.ts b/frontend/src/ts/test/test-logic.ts
index 7ab826b97d5f..7c6b3c70fc13 100644
--- a/frontend/src/ts/test/test-logic.ts
+++ b/frontend/src/ts/test/test-logic.ts
@@ -102,8 +102,8 @@ import {
   resetTestEvents,
   cleanupData,
   logEventsDataToTheConsoleTable,
-  getAllTestEvents,
   forceReleaseAllKeys,
+  buildEventLog,
 } from "./events/data";
 import {
   getKeypressDurations,
@@ -124,6 +124,7 @@ import {
 } from "./events/stats";
 import { calculateWpm } from "../utils/numbers";
 import { isDevEnvironment } from "../utils/env";
+import { EventLog } from "./events/types";
 
 let failReason = "";
 
@@ -927,7 +928,10 @@ function compareCompletedEvents(
   ce: Omit<CompletedEvent, "hash" | "uid">,
 ): void {
   const start = performance.now();
-  const ce2 = buildCompletedEvent2();
+
+  const eventLog = buildEventLog();
+
+  const ce2 = buildCompletedEvent2(eventLog);
   const end = performance.now();
 
   console.debug(
@@ -940,18 +944,26 @@ function compareCompletedEvents(
   const ceKeys = Object.keys(ce) as (keyof typeof ce)[];
   for (const key of ceKeys) {
     if (
+      key === "timestamp" ||
       key === "keyDuration" ||
       key === "keySpacing" ||
-      key === "afkDuration" ||
       key === "chartData"
     ) {
       continue;
     }
+    // if (
+    //   key === "keyDuration" ||
+    //   key === "keySpacing" ||
+    //   key === "afkDuration" ||
+    //   key === "chartData"
+    // ) {
+    //   continue;
+    // }
 
     let val1 = ce[key];
     let val2 = ce2[key];
 
-    //@ts-expect-error asdf
+    //@ts-expect-error temp
     if (key === "keyDuration" || key === "keySpacing") {
       const a = (val1 as number[]).map((v) => Numbers.roundTo2(v));
       const b = (val2 as number[]).map((v) => Numbers.roundTo2(v));
@@ -967,16 +979,20 @@ function compareCompletedEvents(
           if (a[i] !== b[i]) mismatchCount++;
         }
       }
-      if (mismatchCount === 0) {
-        console.debug(`Completed event match on key ${key}:`, a);
-      } else {
-        notMatching.push(`${key} (${mismatchCount}/${total} elements differ)`);
-        mismatchedKeys.push(key);
+      if (mismatchCount > 0) {
         console.error(
           `Completed event mismatch on key ${key}: ${mismatchCount}/${total} elements differ`,
           a,
           b,
         );
+        if (mismatchCount > 1) {
+          notMatching.push(
+            `${key} (${mismatchCount}/${total} elements differ)`,
+          );
+          mismatchedKeys.push(key);
+        }
+      } else {
+        console.debug(`Completed event match on key ${key}:`, a);
       }
       continue;
     }
@@ -1013,17 +1029,17 @@ function compareCompletedEvents(
       val2 = Numbers.roundTo2(val2 as number);
     }
 
-    if (key === "timestamp") {
-      continue;
-    }
+    // if (key === "timestamp") {
+    //   continue;
+    // }
 
-    if (key === "consistency") {
-      continue;
-    }
+    // if (key === "consistency") {
+    //   continue;
+    // }
 
-    if (key === "keyConsistency") {
-      continue;
-    }
+    // if (key === "keyConsistency") {
+    //   continue;
+    // }
 
     if (key === "wpm" || key === "rawWpm") {
       val1 = Numbers.roundTo2(val1 as number);
@@ -1070,7 +1086,7 @@ function compareCompletedEvents(
     //   };
     // }
 
-    //@ts-expect-error asdf
+    //@ts-expect-error temp
     if (key === "chartData") {
       const v1 = val1 as CompletedEvent["chartData"];
       const v2 = val2 as CompletedEvent["chartData"];
@@ -1134,8 +1150,8 @@ function compareCompletedEvents(
     } else if (typeof val1 === "number" && typeof val2 === "number") {
       const a = Numbers.roundTo2(val1);
       const b = Numbers.roundTo2(val2);
-      if (a !== b) {
-        const diff = Numbers.roundTo2(Math.abs(a - b));
+      const diff = Numbers.roundTo2(Math.abs(a - b));
+      if (a !== b && diff >= 0.5) {
         const dir = a > b ? "ce1 larger" : "ce2 larger";
         notMatching.push(`${key} (off by ${diff}, ${dir}, ${a} vs ${b})`);
         mismatchedKeys.push(key);
@@ -1154,7 +1170,7 @@ function compareCompletedEvents(
 
   {
     const a = TestInput.keypressCountHistory;
-    const b = getKeypressesPerSecond();
+    const b = getKeypressesPerSecond(eventLog);
     const aTotal = a.reduce((acc, val) => {
       if (val === undefined) return acc;
       return acc + val;
@@ -1196,7 +1212,7 @@ function compareCompletedEvents(
       if (val === undefined) return acc;
       return acc + val;
     }, 0);
-    const b = getKeypressesPerSecond().reduce((acc, val) => {
+    const b = getKeypressesPerSecond(eventLog).reduce((acc, val) => {
       if (val === undefined) return acc;
       return acc + val;
     }, 0);
@@ -1254,7 +1270,7 @@ function compareCompletedEvents(
 
   {
     const a = TestInput.rawHistory;
-    const b = getRawHistory();
+    const b = getRawHistory(eventLog);
     if (a.length === b.length && a.every((val, i) => val === b[i])) {
       console.debug(`Completed event match on rawHistory:`, a);
     } else {
@@ -1267,7 +1283,7 @@ function compareCompletedEvents(
   {
     if (ce.chartData !== "toolong") {
       const a = ce.chartData.wpm;
-      const b = getWpmHistory();
+      const b = getWpmHistory(eventLog);
       if (a.length === b.length && a.every((val, i) => val === b[i])) {
         console.debug(`Completed event match on chartData.wpm:`, a);
       } else {
@@ -1282,7 +1298,7 @@ function compareCompletedEvents(
     const a = getInputHistory().join(" ");
     const noSpace = isFunboxActiveWithProperty("nospace");
     if (!a.includes("\n") && !noSpace) {
-      const b = getEventsInputHistory().join("");
+      const b = getEventsInputHistory(eventLog).join("");
       if (a === b) {
         console.debug(`Completed event match on input history:`, a);
       } else {
@@ -1291,7 +1307,7 @@ function compareCompletedEvents(
         console.error(
           `Completed event mismatch on input history:`,
           getInputHistory(),
-          getEventsInputHistory(),
+          getEventsInputHistory(eventLog),
         );
       }
     }
@@ -1303,41 +1319,42 @@ function compareCompletedEvents(
     }
   } else {
     let ignoreMismatch = false;
-    if (
-      mismatchedKeys.includes("testDuration") &&
-      Math.abs(ce2.testDuration - ce.testDuration) <= 0.2
-    ) {
-      ignoreMismatch = true;
-      console.warn("Ignoring completed event mismatch on testDuration", {
-        ceTestDuration: ce.testDuration,
-        ce2TestDuration: ce2.testDuration,
-      });
-    }
-    if (mismatchedKeys.includes("keyOverlap")) {
-      ignoreMismatch = true;
-      console.warn("Ignoring completed event mismatch on keyOverlap", {
-        ceKeyOverlap: ce.keyOverlap,
-        ce2KeyOverlap: ce2.keyOverlap,
-      });
-    }
-    if (
-      mismatchedKeys.includes("afkDuration") &&
-      Math.abs(ce2.afkDuration - ce.afkDuration) <= 1
-    ) {
-      ignoreMismatch = true;
-      console.warn("Ignoring completed event mismatch on afkDuration", {
-        ceAfkDuration: ce.afkDuration,
-        ce2AfkDuration: ce2.afkDuration,
-      });
-    }
-    if (
-      mismatchedKeys.includes("chartData.wpm") &&
-      mismatchedKeys.length === 1
-    ) {
-      ignoreMismatch = true;
-    }
+    // if (
+    //   mismatchedKeys.includes("testDuration") &&
+    //   Math.abs(ce2.testDuration - ce.testDuration) <= 0.2
+    // ) {
+    //   ignoreMismatch = true;
+    //   console.warn("Ignoring completed event mismatch on testDuration", {
+    //     ceTestDuration: ce.testDuration,
+    //     ce2TestDuration: ce2.testDuration,
+    //   });
+    // }
+    // if (mismatchedKeys.includes("keyOverlap")) {
+    //   ignoreMismatch = true;
+    //   console.warn("Ignoring completed event mismatch on keyOverlap", {
+    //     ceKeyOverlap: ce.keyOverlap,
+    //     ce2KeyOverlap: ce2.keyOverlap,
+    //   });
+    // }
+    // if (
+    //   mismatchedKeys.includes("afkDuration") &&
+    //   Math.abs(ce2.afkDuration - ce.afkDuration) <= 1
+    // ) {
+    //   ignoreMismatch = true;
+    //   console.warn("Ignoring completed event mismatch on afkDuration", {
+    //     ceAfkDuration: ce.afkDuration,
+    //     ce2AfkDuration: ce2.afkDuration,
+    //   });
+    // }
 
-    if (Config.mode === "zen") {
+    // if (
+    //   mismatchedKeys.includes("chartData.wpm") &&
+    //   mismatchedKeys.length === 1
+    // ) {
+    //   ignoreMismatch = true;
+    // }
+
+    if (Config.mode !== "time" || (Config.time !== 15 && Config.time !== 60)) {
       ignoreMismatch = true;
     }
 
@@ -1369,11 +1386,8 @@ function compareCompletedEvents(
             difficulty: ce.difficulty,
             duration: ce.testDuration,
             funboxes: getActiveFunboxNames().join(","),
-            version: 23,
-            data: {
-              words: TestWords.words.list.join(" "),
-              events: getAllTestEvents(),
-            },
+            version: 28,
+            eventLog,
             // ce: ce as Record<string, unknown>,
             // ce2: ce2 as Record<string, unknown>,
           },
@@ -1387,8 +1401,10 @@ function compareCompletedEvents(
   console.debug("Completed event object2", ce2);
 }
 
-function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
-  const chars = getChars();
+function buildCompletedEvent2(
+  eventLog: EventLog,
+): Omit<CompletedEvent, "hash" | "uid"> {
+  const chars = getChars(eventLog);
 
   //tags
   const activeTagsIds: string[] = __nonReactive
@@ -1411,10 +1427,10 @@ function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
     };
   }
 
-  let duration = getTestDurationMs() / 1000;
+  let duration = getTestDurationMs(eventLog) / 1000;
 
-  const rawPerSecond = getBurstHistory();
-  const afkDuration = getAfkDuration();
+  const rawPerSecond = getBurstHistory(eventLog);
+  const afkDuration = getAfkDuration(eventLog);
   const stddev = Numbers.stdDev(rawPerSecond);
   const avg = Numbers.mean(rawPerSecond);
   let consistency = Numbers.roundTo2(Numbers.kogasa(stddev / avg));
@@ -1422,7 +1438,7 @@ function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
     consistency = 0;
   }
 
-  const keypressSpacing = getKeypressSpacing();
+  const keypressSpacing = getKeypressSpacing(eventLog);
 
   let keyConsistencyArray = [...keypressSpacing];
   if (keypressSpacing.length > 0) {
@@ -1438,7 +1454,7 @@ function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
     keyConsistency = 0;
   }
 
-  const wpmHistory = getWpmHistory();
+  const wpmHistory = getWpmHistory(eventLog);
   const wpmCons = Numbers.roundTo2(
     Numbers.kogasa(Numbers.stdDev(wpmHistory) / Numbers.mean(wpmHistory)),
   );
@@ -1447,7 +1463,7 @@ function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
   const chartData = {
     wpm: wpmHistory,
     burst: rawPerSecond,
-    err: getErrorCountHistory(),
+    err: getErrorCountHistory(eventLog),
   };
 
   const currentQuote = getCurrentQuote();
@@ -1458,11 +1474,11 @@ function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
     ),
     charStats: [chars.correctWord, chars.incorrect, chars.extra, chars.missed],
     charTotal: chars.allCorrect + chars.incorrect + chars.extra,
-    acc: Numbers.roundTo2(getAccuracy().percentage),
+    acc: Numbers.roundTo2(getAccuracy(eventLog).percentage),
     language: language,
     testDuration: duration,
-    lastKeyToEnd: getLastKeypressToEndMs(),
-    startToFirstKey: getStartToFirstKeypressMs(),
+    lastKeyToEnd: getLastKeypressToEndMs(eventLog),
+    startToFirstKey: getStartToFirstKeypressMs(eventLog),
     afkDuration: afkDuration,
     quoteLength: currentQuote?.group ?? -1,
     customText: customText,
@@ -1489,8 +1505,8 @@ function buildCompletedEvent2(): Omit<CompletedEvent, "hash" | "uid"> {
     chartData: chartData,
 
     keySpacing: keypressSpacing,
-    keyDuration: getKeypressDurations(),
-    keyOverlap: getKeypressOverlap(),
+    keyDuration: getKeypressDurations(eventLog),
+    keyOverlap: getKeypressOverlap(eventLog),
   } as Omit<CompletedEvent, "hash" | "uid">;
 
   if (completedEvent.mode !== "custom") delete completedEvent.customText;
diff --git a/packages/contracts/src/results.ts b/packages/contracts/src/results.ts
index 9ffebc3ce439..553dbdb4b486 100644
--- a/packages/contracts/src/results.ts
+++ b/packages/contracts/src/results.ts
@@ -75,10 +75,11 @@ export const ReportCompletedEventMismatchRequestSchema = z.object({
   difficulty: DifficultySchema.optional(),
   duration: z.number().max(200).optional(),
   funboxes: z.string().max(100).optional(),
-  version: z.literal(23),
-  data: z.object({
-    words: z.string().max(10000),
-    events: z.array(z.record(z.unknown())),
+  version: z.literal(28),
+  eventLog: z.object({
+    version: z.number(),
+    context: z.record(z.unknown()),
+    events: z.array(z.record(z.unknown())).max(10000),
   }),
   // ce: z.record(z.unknown()),
   // ce2: z.record(z.unknown()),