chrome-devtools-frontend 1.0.1376716 → 1.0.1380117

package/front_end/models/trace/handlers/MetaHandler.ts

@@ -6,8 +6,6 @@ import * as Platform from '../../../core/platform/platform.js';
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
-import {HandlerState} from './types.js';
-
 // We track the renderer processes we see in each frame on the way through the trace.
 const rendererProcessesByFrameId: FrameProcessData = new Map();
 
@@ -67,7 +65,6 @@ const eventPhasesOfInterestForTraceBounds = new Set([
   Types.Events.Phase.INSTANT,
 ]);
 
-let handlerState = HandlerState.UNINITIALIZED;
 // Tracks if the trace is a generic trace, which here means that it did not come from athe DevTools Performance Panel recording.
 // We assume a trace is generic, and mark it as not generic if we see any of:
 // - TracingStartedInPage
@@ -104,16 +101,6 @@ export function reset(): void {
   traceStartedTimeFromTracingStartedEvent = Types.Timing.MicroSeconds(-1);
 
   traceIsGeneric = true;
-
-  handlerState = HandlerState.UNINITIALIZED;
-}
-
-export function initialize(): void {
-  if (handlerState !== HandlerState.UNINITIALIZED) {
-    throw new Error('Meta Handler was not reset');
-  }
-
-  handlerState = HandlerState.INITIALIZED;
 }
 
 function updateRendererProcessByFrame(event: Types.Events.Event, frame: Types.Events.TraceFrame): void {
@@ -147,10 +134,6 @@ function updateRendererProcessByFrame(event: Types.Events.Event, frame: Types.Ev
 }
 
 export function handleEvent(event: Types.Events.Event): void {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Meta Handler is not initialized');
-  }
-
   if (traceIsGeneric && CHROME_WEB_TRACE_EVENTS.has(event.name as Types.Events.Name)) {
     traceIsGeneric = false;
   }
@@ -311,9 +294,8 @@ export function handleEvent(event: Types.Events.Event): void {
   // Track all navigation events. Note that there can be navigation start events
   // but where the documentLoaderURL is empty. As far as the trace rendering is
   // concerned, these events are noise so we filter them out here.
-  // (The filtering of empty URLs is done in the
-  // isNavigationStartWithURL check)
-  if (Types.Events.isNavigationStartWithURL(event) && event.args.data) {
+  // (The filtering of empty URLs is done in the isNavigationStart check)
+  if (Types.Events.isNavigationStart(event) && event.args.data) {
     const navigationId = event.args.data.navigationId;
     if (navigationsByNavigationId.has(navigationId)) {
       // We have only ever seen this situation once, in crbug.com/1503982, where the user ran:
@@ -336,10 +318,6 @@ export function handleEvent(event: Types.Events.Event): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Handler is not initialized');
-  }
-
   // We try to set the minimum time by finding the event with the smallest
   // timestamp. However, if we also got a timestamp from the
   // TracingStartedInBrowser event, we should always use that.
@@ -412,8 +390,6 @@ export async function finalize(): Promise<void> {
       mainFrameURL = firstMainFrameNav.args.data.documentLoaderURL;
     }
   }
-
-  handlerState = HandlerState.FINALIZED;
 }
 
 export type MetaHandlerData = {
@@ -464,10 +440,6 @@ export type FrameProcessData =
         Map<Types.Events.ProcessID, {frame: Types.Events.TraceFrame, window: Types.Timing.TraceWindowMicroSeconds}[]>>;
 
 export function data(): MetaHandlerData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('Meta Handler is not finalized');
-  }
-
   return {
     traceBounds: {...traceBounds},
     browserProcessId,

package/front_end/models/trace/handlers/NetworkRequestsHandler.test.ts

@@ -11,29 +11,9 @@ type DataArgsMap = Map<keyof DataArgs, DataArgs[keyof DataArgs]>;
 type DataArgsProcessedDataMap = Map<keyof DataArgsProcessedData, DataArgsProcessedData[keyof DataArgsProcessedData]>;
 
 describe('NetworkRequestsHandler', function() {
-  describe('error handling', () => {
-    it('throws if handleEvent is called before it is initialized', () => {
-      assert.throws(() => {
-        Trace.Handlers.ModelHandlers.NetworkRequests.handleEvent({} as Trace.Types.Events.Event);
-      }, 'Network Request handler is not initialized');
-    });
-
-    it('throws if finalize is called before initialize', async () => {
-      let thrown: Error|null = null;
-      try {
-        await Trace.Handlers.ModelHandlers.NetworkRequests.finalize();
-      } catch (e) {
-        thrown = e as Error;
-      }
-      assert.strictEqual(thrown?.message, 'Network Request handler is not initialized');
-    });
-  });
-
   describe('network requests calculations', () => {
     beforeEach(() => {
       Trace.Handlers.ModelHandlers.Meta.reset();
-      Trace.Handlers.ModelHandlers.Meta.initialize();
-      Trace.Handlers.ModelHandlers.NetworkRequests.initialize();
     });
 
     it('calculates network requests correctly', async function() {
@@ -200,8 +180,6 @@ describe('NetworkRequestsHandler', function() {
   describe('parses the change priority request', () => {
     beforeEach(() => {
       Trace.Handlers.ModelHandlers.Meta.reset();
-      Trace.Handlers.ModelHandlers.Meta.initialize();
-      Trace.Handlers.ModelHandlers.NetworkRequests.initialize();
     });
 
     it('changes priority of the resouce', async function() {
@@ -232,8 +210,6 @@ describe('NetworkRequestsHandler', function() {
   describe('redirects', () => {
     beforeEach(() => {
       Trace.Handlers.ModelHandlers.Meta.reset();
-      Trace.Handlers.ModelHandlers.Meta.initialize();
-      Trace.Handlers.ModelHandlers.NetworkRequests.initialize();
     });
 
     it('calculates redirects correctly (navigations)', async function() {
@@ -306,8 +282,6 @@ describe('NetworkRequestsHandler', function() {
   describe('initiators', () => {
     beforeEach(() => {
       Trace.Handlers.ModelHandlers.Meta.reset();
-      Trace.Handlers.ModelHandlers.Meta.initialize();
-      Trace.Handlers.ModelHandlers.NetworkRequests.initialize();
     });
 
     it('calculate the initiator by `initiator` field correctly', async function() {

package/front_end/models/trace/handlers/NetworkRequestsHandler.ts

@@ -8,7 +8,7 @@ import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
 import {data as metaHandlerData} from './MetaHandler.js';
-import {type HandlerName, HandlerState} from './types.js';
+import type {HandlerName} from './types.js';
 
 const MILLISECONDS_TO_MICROSECONDS = 1000;
 const SECONDS_TO_MICROSECONDS = 1000000;
@@ -103,8 +103,6 @@ function firstPositiveValueInList(entries: number[]): number {
   return 0;
 }
 
-let handlerState = HandlerState.UNINITIALIZED;
-
 export function reset(): void {
   requestsById.clear();
   requestsByOrigin.clear();
@@ -113,19 +111,9 @@ export function reset(): void {
   networkRequestEventByInitiatorUrl.clear();
   eventToInitiatorMap.clear();
   webSocketData.clear();
-
-  handlerState = HandlerState.UNINITIALIZED;
-}
-
-export function initialize(): void {
-  handlerState = HandlerState.INITIALIZED;
 }
 
 export function handleEvent(event: Types.Events.Event): void {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Network Request handler is not initialized');
-  }
-
   if (Types.Events.isResourceChangePriority(event)) {
     storeTraceEventWithRequestId(event.args.data.requestId, 'changePriority', event);
     return;
@@ -187,10 +175,6 @@ export function handleEvent(event: Types.Events.Event): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Network Request handler is not initialized');
-  }
-
   const {rendererProcessesByFrame} = metaHandlerData();
   for (const [requestId, request] of requestMap.entries()) {
     // If we have an incomplete set of events here, we choose to drop the network
@@ -271,6 +255,9 @@ export async function finalize(): Promise<void> {
       finalPriority = request.changePriority.args.data.priority;
     }
 
+    // Network timings are complicated.
+    // https://raw.githubusercontent.com/GoogleChrome/lighthouse/main/docs/Network-Timings.svg is generally correct, but.. less so for navigations/redirects/etc.
+
     // Start time
     // =======================
     // The time where the request started, which is either the first willSendRequest
@@ -504,15 +491,9 @@ export async function finalize(): Promise<void> {
     }
   }
   finalizeWebSocketData();
-
-  handlerState = HandlerState.FINALIZED;
 }
 
 export function data(): NetworkRequestData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('Network Request handler is not finalized');
-  }
-
   return {
     byId: requestsById,
     byOrigin: requestsByOrigin,

package/front_end/models/trace/handlers/PageFramesHandler.ts

@@ -39,6 +39,9 @@ export function handleEvent(event: Types.Events.Event): void {
   }
 }
 
+export async function finalize(): Promise<void> {
+}
+
 export interface PageFrameData {
   frames: Map<string, Types.Events.TraceFrame>;
 }

package/front_end/models/trace/handlers/RendererHandler.test.ts

@@ -663,7 +663,6 @@ describeWithEnvironment('RendererHandler', function() {
       ],
     ]);
 
-    Trace.Handlers.ModelHandlers.Samples.initialize();
     await Trace.Handlers.ModelHandlers.Samples.finalize();
     Trace.Handlers.ModelHandlers.Renderer.buildHierarchy(processes, {filter: {has: () => true}});
 
@@ -796,9 +795,6 @@ describeWithEnvironment('RendererHandler', function() {
       Trace.Handlers.ModelHandlers.Renderer.reset();
       Trace.Handlers.ModelHandlers.Meta.reset();
       Trace.Handlers.ModelHandlers.Samples.reset();
-      Trace.Handlers.ModelHandlers.Meta.initialize();
-      Trace.Handlers.ModelHandlers.Samples.initialize();
-      Trace.Handlers.ModelHandlers.Renderer.initialize();
 
       for (const event of traceEvents) {
         Trace.Handlers.ModelHandlers.Meta.handleEvent(event);

package/front_end/models/trace/handlers/RendererHandler.ts

@@ -9,7 +9,7 @@ import * as Types from '../types/types.js';
 import {data as auctionWorkletsData} from './AuctionWorkletsHandler.js';
 import {data as metaHandlerData, type FrameProcessData} from './MetaHandler.js';
 import {data as samplesHandlerData} from './SamplesHandler.js';
-import {type HandlerName, HandlerState} from './types.js';
+import type {HandlerName} from './types.js';
 
 /**
  * This handler builds the hierarchy of trace events and profile calls
@@ -37,7 +37,6 @@ let allTraceEntries: Types.Events.Event[] = [];
 
 const completeEventStack: (Types.Events.SyntheticComplete)[] = [];
 
-let handlerState = HandlerState.UNINITIALIZED;
 let config: Types.Configuration.Configuration = Types.Configuration.defaults();
 
 const makeRendererProcess = (): RendererProcess => ({
@@ -71,22 +70,9 @@ export function reset(): void {
   allTraceEntries.length = 0;
   completeEventStack.length = 0;
   compositorTileWorkers.length = 0;
-  handlerState = HandlerState.UNINITIALIZED;
-}
-
-export function initialize(): void {
-  if (handlerState !== HandlerState.UNINITIALIZED) {
-    throw new Error('Renderer Handler was not reset');
-  }
-
-  handlerState = HandlerState.INITIALIZED;
 }
 
 export function handleEvent(event: Types.Events.Event): void {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Renderer Handler is not initialized');
-  }
-
   if (Types.Events.isThreadName(event) && event.args.name?.startsWith('CompositorTileWorker')) {
     compositorTileWorkers.push({
       pid: event.pid,
@@ -115,24 +101,15 @@ export function handleEvent(event: Types.Events.Event): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Renderer Handler is not initialized');
-  }
-
   const {mainFrameId, rendererProcessesByFrame, threadsInProcess} = metaHandlerData();
   assignMeta(processes, mainFrameId, rendererProcessesByFrame, threadsInProcess);
   sanitizeProcesses(processes);
   buildHierarchy(processes);
   sanitizeThreads(processes);
   Helpers.Trace.sortTraceEventsInPlace(allTraceEntries);
-  handlerState = HandlerState.FINALIZED;
 }
 
 export function data(): RendererHandlerData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('Renderer Handler is not finalized');
-  }
-
   return {
     processes: new Map(processes),
     compositorTileWorkers: new Map(gatherCompositorThreads()),

package/front_end/models/trace/handlers/SamplesHandler.test.ts

@@ -14,9 +14,6 @@ async function handleEventsFromTraceFile(context: Mocha.Context|Mocha.Suite|null
   Trace.Handlers.ModelHandlers.Meta.reset();
   Trace.Handlers.ModelHandlers.Samples.reset();
 
-  Trace.Handlers.ModelHandlers.Meta.initialize();
-  Trace.Handlers.ModelHandlers.Samples.initialize();
-
   for (const event of traceEvents) {
     Trace.Handlers.ModelHandlers.Meta.handleEvent(event);
     Trace.Handlers.ModelHandlers.Samples.handleEvent(event);
@@ -141,8 +138,6 @@ describeWithEnvironment('SamplesHandler', function() {
       ];
       Trace.Handlers.ModelHandlers.Samples.reset();
 
-      Trace.Handlers.ModelHandlers.Samples.initialize();
-
       for (const event of [mockProfileEvent, ...mockChunks]) {
         Trace.Handlers.ModelHandlers.Samples.handleEvent(event);
       }

package/front_end/models/trace/handlers/SamplesHandler.ts

@@ -8,8 +8,6 @@ import * as CPUProfile from '../../cpu_profile/cpu_profile.js';
 import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
-import {HandlerState} from './types.js';
-
 const events = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.Complete[]>>();
 
 const profilesInProcess = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, ProfileData>>();
@@ -26,8 +24,6 @@ const entryToNode = new Map<Types.Events.Event, Helpers.TreeHelpers.TraceEntryNo
 // events matched by thread id.
 const preprocessedData = new Map<Types.Events.ProcessID, Map<Types.Events.ProfileID, PreprocessedData>>();
 
-let handlerState = HandlerState.UNINITIALIZED;
-
 function buildProfileCalls(): void {
   for (const [processId, profiles] of preprocessedData) {
     for (const [profileId, preProcessedData] of profiles) {
@@ -110,22 +106,9 @@ export function reset(): void {
   preprocessedData.clear();
   profilesInProcess.clear();
   entryToNode.clear();
-  handlerState = HandlerState.UNINITIALIZED;
-}
-
-export function initialize(): void {
-  if (handlerState !== HandlerState.UNINITIALIZED) {
-    throw new Error('Samples Handler was not reset');
-  }
-
-  handlerState = HandlerState.INITIALIZED;
 }
 
 export function handleEvent(event: Types.Events.Event): void {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Samples Handler is not initialized');
-  }
-
   /**
    * A fake trace event created to support CDP.Profiler.Profiles in the
    * trace engine.
@@ -201,19 +184,10 @@ export function handleEvent(event: Types.Events.Event): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Samples Handler is not initialized');
-  }
   buildProfileCalls();
-
-  handlerState = HandlerState.FINALIZED;
 }
 
 export function data(): SamplesHandlerData {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('Samples Handler is not finalized');
-  }
-
   return {
     profilesInProcess,
     entryToNode,

package/front_end/models/trace/handlers/ScreenshotsHandler.test.ts

@@ -28,7 +28,6 @@ describe('ScreenshotsHandler', function() {
     // and later we will pass events to the meta handler, otherwise the
     // screenshots handler will fail.
     Trace.Handlers.ModelHandlers.Meta.reset();
-    Trace.Handlers.ModelHandlers.Meta.initialize();
 
     Trace.Handlers.ModelHandlers.Screenshots.reset();
   });

package/front_end/models/trace/handlers/SelectorStatsHandler.ts

@@ -29,6 +29,9 @@ export function handleEvent(event: Types.Events.Event): void {
   }
 }
 
+export async function finalize(): Promise<void> {
+}
+
 export interface SelectorStatsData {
   dataForUpdateLayoutEvent: Map<Types.Events.UpdateLayoutTree, {
     timings: Types.Events.SelectorTiming[],

package/front_end/models/trace/handlers/ServerTimingsHandler.ts

@@ -7,19 +7,12 @@ import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
 import {data as networkData} from './NetworkRequestsHandler.js';
-import {type HandlerName, HandlerState} from './types.js';
+import type {HandlerName} from './types.js';
 
 const serverTimings: Types.Events.SyntheticServerTiming[] = [];
 
-let handlerState = HandlerState.UNINITIALIZED;
-
 export function reset(): void {
   serverTimings.length = 0;
-  handlerState = HandlerState.UNINITIALIZED;
-}
-
-export function initialize(): void {
-  handlerState = HandlerState.INITIALIZED;
 }
 
 export function handleEvent(_event: Types.Events.Event): void {
@@ -27,12 +20,8 @@ export function handleEvent(_event: Types.Events.Event): void {
 }
 
 export async function finalize(): Promise<void> {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Server Timings handler is not initialized');
-  }
   extractServerTimings();
   Helpers.Trace.sortTraceEventsInPlace(serverTimings);
-  handlerState = HandlerState.FINALIZED;
 }
 
 const RESPONSE_START_METRIC_NAME = 'response-start';
@@ -124,10 +113,6 @@ function createSyntheticServerTiming(
 }
 
 export function data(): {serverTimings: Types.Events.SyntheticServerTiming[]} {
-  if (handlerState !== HandlerState.FINALIZED) {
-    throw new Error('Server Timing handler is not finalized');
-  }
-
   return {
     serverTimings,
   };

package/front_end/models/trace/handlers/Threads.test.ts

@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as TimelineModel from '../../../models/timeline_model/timeline_model.js';
 import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 import * as Trace from '../trace.js';
@@ -40,7 +39,7 @@ describeWithEnvironment('Handler Threads helper', function() {
     // it takes the CDP Profile and wraps it in fake trace events, before then
     // passing that through to the new engine.
     const rawEvents = await TraceLoader.rawCPUProfile(this, 'node-fibonacci-website.cpuprofile.gz');
-    const events = TimelineModel.TimelineJSProfile.TimelineJSProfileProcessor.createFakeTraceFromCpuProfile(
+    const events = Trace.Extras.TimelineJSProfile.TimelineJSProfileProcessor.createFakeTraceFromCpuProfile(
         rawEvents,
         Trace.Types.Events.ThreadID(1),
     );

package/front_end/models/trace/handlers/UserInteractionsHandler.test.ts

@@ -8,7 +8,6 @@ import * as Trace from '../trace.js';
 async function processTrace(context: Mocha.Suite|Mocha.Context|null, path: string): Promise<void> {
   const traceEvents = await TraceLoader.rawEvents(context, path);
   Trace.Handlers.ModelHandlers.Meta.reset();
-  Trace.Handlers.ModelHandlers.Meta.initialize();
   for (const event of traceEvents) {
     Trace.Handlers.ModelHandlers.Meta.handleEvent(event);
     Trace.Handlers.ModelHandlers.UserInteractions.handleEvent(event);
@@ -19,7 +18,6 @@ async function processTrace(context: Mocha.Suite|Mocha.Context|null, path: strin
 
 beforeEach(() => {
   Trace.Handlers.ModelHandlers.Meta.reset();
-  Trace.Handlers.ModelHandlers.Meta.initialize();
 });
 
 describe('UserInteractionsHandler', function() {
@@ -43,23 +41,6 @@ describe('UserInteractionsHandler', function() {
     return event as unknown as Trace.Types.Events.SyntheticInteractionPair;
   }
 
-  describe('error handling', () => {
-    it('throws if not initialized', async () => {
-      Trace.Handlers.ModelHandlers.Meta.reset();
-      Trace.Handlers.ModelHandlers.Meta.initialize();
-
-      // Finalize the handler by calling data and then finalize on it.
-      Trace.Handlers.ModelHandlers.UserInteractions.data();
-      await Trace.Handlers.ModelHandlers.Meta.finalize();
-      await Trace.Handlers.ModelHandlers.UserInteractions.finalize();
-
-      assert.throws(() => {
-        const fakeEvent = {} as Trace.Types.Events.Event;
-        Trace.Handlers.ModelHandlers.UserInteractions.handleEvent(fakeEvent);
-      }, 'Handler is not initialized');
-    });
-  });
-
   it('returns all user interactions', async function() {
     const traceEvents = await TraceLoader.rawEvents(this, 'slow-interaction-button-click.json.gz');
     for (const event of traceEvents) {
@@ -67,11 +48,7 @@ describe('UserInteractionsHandler', function() {
     }
 
     const data = Trace.Handlers.ModelHandlers.UserInteractions.data();
-    const clicks = data.allEvents.filter(event => {
-      if (!event.args.data) {
-        return false;
-      }
-
+    const clicks = data.allEvents.filter(Trace.Types.Events.isEventTimingStart).filter(event => {
       return event.args.data.type === 'click';
     });
 
@@ -184,8 +161,8 @@ describe('UserInteractionsHandler', function() {
   it('detects correct events for a click and keydown interaction', async () => {
     await processTrace(this, 'slow-interaction-keydown.json.gz');
     const data = Trace.Handlers.ModelHandlers.UserInteractions.data();
-    const foundInteractions =
-        data.allEvents.filter(e => e.args.data && e.args.data.duration > 1 && e.args.data.interactionId);
+    const foundInteractions = data.allEvents.filter(Trace.Types.Events.isEventTimingStart)
+                                  .filter(e => e.args.data && e.args.data.duration > 1 && e.args.data.interactionId);
     // We expect there to be 3 interactions:
     // User clicks on input:
     // 1.pointerdown, 2. pointerup, 3. click
@@ -276,7 +253,7 @@ describe('UserInteractionsHandler', function() {
           },
         },
       },
-    ] as unknown as Trace.Types.Events.EventTiming[];
+    ] as unknown as Trace.Types.Events.EventTimingBeginOrEnd[];
     Trace.Handlers.ModelHandlers.UserInteractions.reset();
     for (const event of events) {
       Trace.Handlers.ModelHandlers.UserInteractions.handleEvent(event);

package/front_end/models/trace/handlers/UserInteractionsHandler.ts

@@ -7,7 +7,7 @@ import * as Types from '../types/types.js';
 
 import {data as metaHandlerData} from './MetaHandler.js';
 import {ScoreClassification} from './PageLoadMetricsHandler.js';
-import {type HandlerName, HandlerState} from './types.js';
+import type {HandlerName} from './types.js';
 
 // This handler serves two purposes. It generates a list of events that are
 // used to show user clicks in the timeline. It is also used to gather
@@ -16,7 +16,7 @@ import {type HandlerName, HandlerState} from './types.js';
 
 // We don't need to know which process / thread these events occurred in,
 // because they are effectively global, so we just track all that we find.
-const allEvents: Types.Events.EventTiming[] = [];
+const allEvents: Types.Events.EventTimingBeginOrEnd[] = [];
 
 const beginCommitCompositorFrameEvents: Types.Events.BeginCommitCompositorFrame[] = [];
 const parseMetaViewportEvents: Types.Events.ParseMetaViewport[] = [];
@@ -28,7 +28,7 @@ const INP_MEDIUM_TIMING = Helpers.Timing.millisecondsToMicroseconds(Types.Timing
 
 export interface UserInteractionsData {
   /** All the user events we found in the trace */
-  allEvents: readonly Types.Events.EventTiming[];
+  allEvents: readonly Types.Events.EventTimingBeginOrEnd[];
   /** All the BeginCommitCompositorFrame events we found in the trace */
   beginCommitCompositorFrameEvents: readonly Types.Events.BeginCommitCompositorFrame[];
   /** All the ParseMetaViewport events we found in the trace */
@@ -64,7 +64,6 @@ const interactionEvents: Types.Events.SyntheticInteractionPair[] = [];
 const interactionEventsWithNoNesting: Types.Events.SyntheticInteractionPair[] = [];
 const eventTimingEndEventsById = new Map<string, Types.Events.EventTimingEnd>();
 const eventTimingStartEventsForInteractions: Types.Events.EventTimingBegin[] = [];
-let handlerState = HandlerState.UNINITIALIZED;
 
 export function reset(): void {
   allEvents.length = 0;
@@ -75,14 +74,9 @@ export function reset(): void {
   eventTimingEndEventsById.clear();
   interactionEventsWithNoNesting.length = 0;
   longestInteractionEvent = null;
-  handlerState = HandlerState.INITIALIZED;
 }
 
 export function handleEvent(event: Types.Events.Event): void {
-  if (handlerState !== HandlerState.INITIALIZED) {
-    throw new Error('Handler is not initialized');
-  }
-
   if (Types.Events.isBeginCommitCompositorFrame(event)) {
     beginCommitCompositorFrameEvents.push(event);
     return;
@@ -279,18 +273,16 @@ export async function finalize(): Promise<void> {
       // If we cannot find an end event, bail and drop this event.
       continue;
     }
-    if (!interactionStartEvent.args.data?.type || !interactionStartEvent.args.data?.interactionId) {
-      // A valid interaction event that we care about has to have a type (e.g.
-      // pointerdown, keyup).
-      //
-      // We also need to ensure it has an interactionId. We already checked
-      // this in the handleEvent() function, but we do it here also to satisfy
-      // TypeScript.
+    const {type, interactionId, timeStamp, processingStart, processingEnd} = interactionStartEvent.args.data;
+    if (!type || !interactionId || !timeStamp || !processingStart || !processingEnd) {
+      // A valid interaction event that we care about has to have a type (e.g. pointerdown, keyup).
+      // We also need to ensure it has an interactionId and various timings. There are edge cases where these aren't included in the trace event.
       continue;
     }
 
-    // In the future we will add microsecond timestamps to the trace events,
-    // but until then we can use the millisecond precision values that are in
+    // In the future we will add microsecond timestamps to the trace events…
+    // (See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/timing/window_performance.cc;l=900-901;drc=b503c262e425eae59ced4a80d59d176ed07152c7 )
+    // …but until then we can use the millisecond precision values that are in
     // the trace event. To adjust them to be relative to the event.ts and the
     // trace timestamps, for both processingStart and processingEnd we subtract
     // the event timestamp (NOT event.ts, but the timeStamp millisecond value
@@ -299,17 +291,17 @@ export async function finalize(): Promise<void> {
     // that is relative to event.ts, and can be used when drawing boxes.
     // There is some inaccuracy here as we are converting milliseconds to microseconds, but it is good enough until the backend emits more accurate numbers.
     const processingStartRelativeToTraceTime = Types.Timing.MicroSeconds(
-        Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.processingStart) -
-            Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.timeStamp) +
-            interactionStartEvent.ts,
+        Helpers.Timing.millisecondsToMicroseconds(processingStart) -
+            Helpers.Timing.millisecondsToMicroseconds(timeStamp) + interactionStartEvent.ts,
     );
 
     const processingEndRelativeToTraceTime = Types.Timing.MicroSeconds(
-        (Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.processingEnd) -
-         Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.timeStamp)) +
+        (Helpers.Timing.millisecondsToMicroseconds(processingEnd) -
+         Helpers.Timing.millisecondsToMicroseconds(timeStamp)) +
         interactionStartEvent.ts);
 
-    const frameId = interactionStartEvent.args.frame ?? interactionStartEvent.args.data.frame;
+    // Ultimate frameId fallback only needed for TSC, see comments in the type.
+    const frameId = interactionStartEvent.args.frame ?? interactionStartEvent.args.data.frame ?? '';
     const navigation = Helpers.Trace.getNavigationForTraceEvent(interactionStartEvent, frameId, navigationsByFrameId);
     const navigationId = navigation?.args.data?.navigationId;
     const interactionEvent =
@@ -345,7 +337,6 @@ export async function finalize(): Promise<void> {
     interactionEvents.push(interactionEvent);
   }
 
-  handlerState = HandlerState.FINALIZED;
   interactionEventsWithNoNesting.push(...removeNestedInteractions(interactionEvents));
 
   // Pick the longest interactions from the set that were not nested, as we