From 02f4df818f145cbcd67b09a5c26767f21da6344f Mon Sep 17 00:00:00 2001
From: Brian Vaughn <bvaughn@fb.com>
Date: Thu, 13 Jan 2022 14:55:54 -0500
Subject: [PATCH] Refactored how React/DevTools log Timeline performance data
 (#23102)

Until now, DEV and PROFILING builds of React recorded Timeline profiling data using the User Timing API. This commit changes things so that React records this data by calling methods on the DevTools hook. (For now, DevTools still records that data using the User Timing API, to match previous behavior.)

This commit is large but most of it is just moving things around:

* New methods have been added to the DevTools hook (in "backend/profilingHooks") for recording the Timeline performance events.
* Reconciler's "ReactFiberDevToolsHook" has been updated to call these new methods (when they're present).
* User Timing method calls in "SchedulingProfiler" have been moved to DevTools "backend/profilingHooks" (to match previous behavior, for now).
* The old reconciler tests, "SchedulingProfiler-test" and "SchedulingProfilerLabels-test", have been moved into DevTools "TimelineProfiler-test" to ensure behavior didn't change unexpectedly.
* Two new methods have been added to the injected renderer interface: injectProfilingHooks() and getLaneLabelMap().

Relates to #22529.
---
 .../src/__tests__/TimelineProfiler-test.js    | 1124 ++++++++++
 .../src/__tests__/preprocessData-test.js      | 1929 +++++++++++++++++
 .../src/__tests__/setupTests.js               |    4 +
 .../src/__tests__/utils.js                    |    8 +
 .../src/backend/profilingHooks.js             |  364 ++++
 .../src/backend/renderer.js                   |   13 +
 .../src/backend/types.js                      |   54 +-
 packages/react-devtools-shared/src/hook.js    |    3 +-
 .../__tests__/preprocessData-test.internal.js | 1915 ----------------
 .../src/ReactFiberBeginWork.new.js            |    4 +-
 .../src/ReactFiberBeginWork.old.js            |    4 +-
 .../src/ReactFiberClassComponent.new.js       |    5 +-
 .../src/ReactFiberClassComponent.old.js       |    5 +-
 .../src/ReactFiberCommitWork.new.js           |    6 +-
 .../src/ReactFiberCommitWork.old.js           |    6 +-
 .../src/ReactFiberDevToolsHook.new.js         |  324 ++-
 .../src/ReactFiberDevToolsHook.old.js         |  324 ++-
 .../src/ReactFiberHooks.new.js                |    2 +-
 .../src/ReactFiberHooks.old.js                |    2 +-
 .../src/ReactFiberReconciler.new.js           |    7 +-
 .../src/ReactFiberReconciler.old.js           |    7 +-
 .../src/ReactFiberWorkLoop.new.js             |   28 +-
 .../src/ReactFiberWorkLoop.old.js             |   28 +-
 .../src/SchedulingProfiler.js                 |  395 ----
 .../__tests__/ReactUpdaters-test.internal.js  |   26 +
 .../SchedulingProfiler-test.internal.js       |  998 ---------
 .../SchedulingProfilerLabels-test.internal.js |  216 --
 scripts/jest/matchers/profilerMatchers.js     |    0
 28 files changed, 4208 insertions(+), 3593 deletions(-)
 create mode 100644 packages/react-devtools-shared/src/__tests__/TimelineProfiler-test.js
 create mode 100644 packages/react-devtools-shared/src/__tests__/preprocessData-test.js
 create mode 100644 packages/react-devtools-shared/src/backend/profilingHooks.js
 delete mode 100644 packages/react-devtools-timeline/src/import-worker/__tests__/preprocessData-test.internal.js
 delete mode 100644 packages/react-reconciler/src/SchedulingProfiler.js
 delete mode 100644 packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js
 delete mode 100644 packages/react-reconciler/src/__tests__/SchedulingProfilerLabels-test.internal.js
 delete mode 100644 scripts/jest/matchers/profilerMatchers.js

diff --git a/packages/react-devtools-shared/src/__tests__/TimelineProfiler-test.js b/packages/react-devtools-shared/src/__tests__/TimelineProfiler-test.js
new file mode 100644
index 0000000000000..1a369acca27bd
--- /dev/null
+++ b/packages/react-devtools-shared/src/__tests__/TimelineProfiler-test.js
@@ -0,0 +1,1124 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+'use strict';
+
+describe('Timeline profiler', () => {
+  let React;
+  let ReactDOM;
+  let Scheduler;
+  let renderHelper;
+  let renderRootHelper;
+  let unmountFns;
+  let utils;
+
+  let clearedMarks;
+  let featureDetectionMarkName = null;
+  let marks;
+  let setPerformanceMock;
+
+  function createUserTimingPolyfill() {
+    featureDetectionMarkName = null;
+
+    clearedMarks = [];
+    marks = [];
+
+    // Remove file-system specific bits or version-specific bits of information from the module range marks.
+    function filterMarkData(markName) {
+      if (markName.startsWith('--react-internal-module-start')) {
+        return `${markName.substr(0, 29)}-<filtered-file-system-path>`;
+      } else if (markName.startsWith('--react-internal-module-stop')) {
+        return `${markName.substr(0, 28)}-<filtered-file-system-path>`;
+      } else if (markName.startsWith('--react-version')) {
+        return `${markName.substr(0, 15)}-<filtered-version>`;
+      } else {
+        return markName;
+      }
+    }
+
+    // This is not a true polyfill, but it gives us enough to capture marks.
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
+    return {
+      clearMarks(markName) {
+        markName = filterMarkData(markName);
+
+        clearedMarks.push(markName);
+        marks = marks.filter(mark => mark !== markName);
+      },
+      mark(markName, markOptions) {
+        markName = filterMarkData(markName);
+
+        if (featureDetectionMarkName === null) {
+          featureDetectionMarkName = markName;
+        }
+
+        marks.push(markName);
+
+        if (markOptions != null) {
+          // This is triggers the feature detection.
+          markOptions.startTime++;
+        }
+      },
+    };
+  }
+
+  function clearPendingMarks() {
+    clearedMarks.splice(0);
+  }
+
+  function dispatchAndSetCurrentEvent(element, event) {
+    try {
+      window.event = event;
+      element.dispatchEvent(event);
+    } finally {
+      window.event = undefined;
+    }
+  }
+
+  beforeEach(() => {
+    utils = require('./utils');
+    utils.beforeEachProfiling();
+
+    unmountFns = [];
+    renderHelper = element => {
+      const unmountFn = utils.legacyRender(element);
+      unmountFns.push(unmountFn);
+      return unmountFn;
+    };
+    renderRootHelper = element => {
+      const container = document.createElement('div');
+      const root = ReactDOM.createRoot(container);
+      root.render(element);
+      const unmountFn = () => root.unmount();
+      unmountFns.push(unmountFn);
+      return unmountFn;
+    };
+
+    React = require('react');
+    ReactDOM = require('react-dom');
+    Scheduler = require('scheduler');
+
+    setPerformanceMock = require('react-devtools-shared/src/backend/profilingHooks')
+      .setPerformanceMock_ONLY_FOR_TESTING;
+    setPerformanceMock(createUserTimingPolyfill());
+  });
+
+  afterEach(() => {
+    // Verify all logged marks also get cleared.
+    expect(marks).toHaveLength(0);
+
+    unmountFns.forEach(unmountFn => unmountFn());
+
+    setPerformanceMock(null);
+  });
+
+  it('should mark sync render without suspends or state updates', () => {
+    renderHelper(<div />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-1",
+        "--render-start-1",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-1",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark concurrent render without suspends or state updates', () => {
+    renderRootHelper(<div />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark render yields', async () => {
+    function Bar() {
+      Scheduler.unstable_yieldValue('Bar');
+      return null;
+    }
+
+    function Foo() {
+      Scheduler.unstable_yieldValue('Foo');
+      return <Bar />;
+    }
+
+    React.startTransition(() => {
+      renderRootHelper(<Foo />);
+    });
+
+    // Do one step of work.
+    expect(Scheduler).toFlushAndYieldThrough(['Foo']);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-64",
+        "--render-start-64",
+        "--component-render-start-Foo",
+        "--component-render-stop",
+        "--render-yield",
+      ]
+    `);
+  });
+
+  it('should mark sync render with suspense that resolves', async () => {
+    const fakeSuspensePromise = Promise.resolve(true);
+    function Example() {
+      throw fakeSuspensePromise;
+    }
+
+    renderHelper(
+      <React.Suspense fallback={null}>
+        <Example />
+      </React.Suspense>,
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-1",
+        "--render-start-1",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--suspense-suspend-0-Example-mount-1-",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-1",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    await fakeSuspensePromise;
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--suspense-resolved-0-Example",
+        ]
+    `);
+  });
+
+  it('should mark sync render with suspense that rejects', async () => {
+    const fakeSuspensePromise = Promise.reject(new Error('error'));
+    function Example() {
+      throw fakeSuspensePromise;
+    }
+
+    renderHelper(
+      <React.Suspense fallback={null}>
+        <Example />
+      </React.Suspense>,
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-1",
+        "--render-start-1",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--suspense-suspend-0-Example-mount-1-",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-1",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    await expect(fakeSuspensePromise).rejects.toThrow();
+    expect(clearedMarks).toContain(`--suspense-rejected-0-Example`);
+  });
+
+  it('should mark concurrent render with suspense that resolves', async () => {
+    const fakeSuspensePromise = Promise.resolve(true);
+    function Example() {
+      throw fakeSuspensePromise;
+    }
+
+    renderRootHelper(
+      <React.Suspense fallback={null}>
+        <Example />
+      </React.Suspense>,
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--suspense-suspend-0-Example-mount-16-",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    await fakeSuspensePromise;
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--suspense-resolved-0-Example",
+      ]
+    `);
+  });
+
+  it('should mark concurrent render with suspense that rejects', async () => {
+    const fakeSuspensePromise = Promise.reject(new Error('error'));
+    function Example() {
+      throw fakeSuspensePromise;
+    }
+
+    renderRootHelper(
+      <React.Suspense fallback={null}>
+        <Example />
+      </React.Suspense>,
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--suspense-suspend-0-Example-mount-16-",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    await expect(fakeSuspensePromise).rejects.toThrow();
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--suspense-rejected-0-Example",
+        ]
+    `);
+  });
+
+  it('should mark cascading class component state updates', () => {
+    class Example extends React.Component {
+      state = {didMount: false};
+      componentDidMount() {
+        this.setState({didMount: true});
+      }
+      render() {
+        return null;
+      }
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--schedule-state-update-1-Example",
+        "--layout-effects-stop",
+        "--render-start-1",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--commit-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark cascading class component force updates', () => {
+    class Example extends React.Component {
+      componentDidMount() {
+        this.forceUpdate();
+      }
+      render() {
+        return null;
+      }
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-render-16",
+        ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--schedule-forced-update-1-Example",
+        "--layout-effects-stop",
+        "--render-start-1",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--commit-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark render phase state updates for class component', () => {
+    class Example extends React.Component {
+      state = {didRender: false};
+      render() {
+        if (this.state.didRender === false) {
+          this.setState({didRender: true});
+        }
+        return null;
+      }
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-render-16",
+        ]
+    `);
+
+    clearPendingMarks();
+
+    let errorMessage;
+    spyOn(console, 'error').and.callFake(message => {
+      errorMessage = message;
+    });
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(console.error).toHaveBeenCalledTimes(1);
+    expect(errorMessage).toContain(
+      'Cannot update during an existing state transition',
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--schedule-state-update-16-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark render phase force updates for class component', () => {
+    class Example extends React.Component {
+      state = {didRender: false};
+      render() {
+        if (this.state.didRender === false) {
+          this.forceUpdate(() => this.setState({didRender: true}));
+        }
+        return null;
+      }
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-render-16",
+        ]
+    `);
+
+    clearPendingMarks();
+
+    let errorMessage;
+    spyOn(console, 'error').and.callFake(message => {
+      errorMessage = message;
+    });
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(console.error).toHaveBeenCalledTimes(1);
+    expect(errorMessage).toContain(
+      'Cannot update during an existing state transition',
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--schedule-forced-update-16-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark cascading layout updates', () => {
+    function Example() {
+      const [didMount, setDidMount] = React.useState(false);
+      React.useLayoutEffect(() => {
+        setDidMount(true);
+      }, []);
+      return didMount;
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-render-16",
+        ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--component-layout-effect-mount-start-Example",
+        "--schedule-state-update-1-Example",
+        "--component-layout-effect-mount-stop",
+        "--layout-effects-stop",
+        "--render-start-1",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--commit-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  // This test is coupled to lane implementation details, so I'm disabling it in
+  // the new fork until it stabilizes so we don't have to repeatedly update it.
+  it('should mark cascading passive updates', () => {
+    function Example() {
+      const [didMount, setDidMount] = React.useState(false);
+      React.useEffect(() => {
+        setDidMount(true);
+      }, []);
+      return didMount;
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(Scheduler).toFlushAndYield([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+        "--passive-effects-start-16",
+        "--component-passive-effect-mount-start-Example",
+        "--schedule-state-update-16-Example",
+        "--component-passive-effect-mount-stop",
+        "--passive-effects-stop",
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark render phase updates', () => {
+    function Example() {
+      const [didRender, setDidRender] = React.useState(false);
+      if (!didRender) {
+        setDidRender(true);
+      }
+      return didRender;
+    }
+
+    renderRootHelper(<Example />);
+
+    expect(Scheduler).toFlushAndYield([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+        "--render-start-16",
+        "--component-render-start-Example",
+        "--schedule-state-update-16-Example",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark sync render that throws', async () => {
+    spyOn(console, 'error');
+
+    class ErrorBoundary extends React.Component {
+      state = {error: null};
+      componentDidCatch(error) {
+        this.setState({error});
+      }
+      render() {
+        if (this.state.error) {
+          return null;
+        }
+        return this.props.children;
+      }
+    }
+
+    function ExampleThatThrows() {
+      throw Error('Expected error');
+    }
+
+    renderHelper(
+      <ErrorBoundary>
+        <ExampleThatThrows />
+      </ErrorBoundary>,
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-1",
+        "--render-start-1",
+        "--component-render-start-ErrorBoundary",
+        "--component-render-stop",
+        "--component-render-start-ExampleThatThrows",
+        "--component-render-start-ExampleThatThrows",
+        "--component-render-stop",
+        "--error-ExampleThatThrows-mount-Expected error",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-1",
+        "--schedule-state-update-1-ErrorBoundary",
+        "--layout-effects-stop",
+        "--commit-stop",
+        "--render-start-1",
+        "--component-render-start-ErrorBoundary",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark concurrent render that throws', async () => {
+    spyOn(console, 'error');
+
+    class ErrorBoundary extends React.Component {
+      state = {error: null};
+      componentDidCatch(error) {
+        this.setState({error});
+      }
+      render() {
+        if (this.state.error) {
+          return null;
+        }
+        return this.props.children;
+      }
+    }
+
+    function ExampleThatThrows() {
+      // eslint-disable-next-line no-throw-literal
+      throw 'Expected error';
+    }
+
+    renderRootHelper(
+      <ErrorBoundary>
+        <ExampleThatThrows />
+      </ErrorBoundary>,
+    );
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-render-16",
+        ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushUntilNextPaint([]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--render-start-16",
+        "--component-render-start-ErrorBoundary",
+        "--component-render-stop",
+        "--component-render-start-ExampleThatThrows",
+        "--component-render-start-ExampleThatThrows",
+        "--component-render-stop",
+        "--error-ExampleThatThrows-mount-Expected error",
+        "--render-stop",
+        "--render-start-16",
+        "--component-render-start-ErrorBoundary",
+        "--component-render-stop",
+        "--component-render-start-ExampleThatThrows",
+        "--component-render-start-ExampleThatThrows",
+        "--component-render-stop",
+        "--error-ExampleThatThrows-mount-Expected error",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--schedule-state-update-1-ErrorBoundary",
+        "--layout-effects-stop",
+        "--render-start-1",
+        "--component-render-start-ErrorBoundary",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--commit-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  it('should mark passive and layout effects', async () => {
+    function ComponentWithEffects() {
+      React.useLayoutEffect(() => {
+        Scheduler.unstable_yieldValue('layout 1 mount');
+        return () => {
+          Scheduler.unstable_yieldValue('layout 1 unmount');
+        };
+      }, []);
+
+      React.useEffect(() => {
+        Scheduler.unstable_yieldValue('passive 1 mount');
+        return () => {
+          Scheduler.unstable_yieldValue('passive 1 unmount');
+        };
+      }, []);
+
+      React.useLayoutEffect(() => {
+        Scheduler.unstable_yieldValue('layout 2 mount');
+        return () => {
+          Scheduler.unstable_yieldValue('layout 2 unmount');
+        };
+      }, []);
+
+      React.useEffect(() => {
+        Scheduler.unstable_yieldValue('passive 2 mount');
+        return () => {
+          Scheduler.unstable_yieldValue('passive 2 unmount');
+        };
+      }, []);
+
+      React.useEffect(() => {
+        Scheduler.unstable_yieldValue('passive 3 mount');
+        return () => {
+          Scheduler.unstable_yieldValue('passive 3 unmount');
+        };
+      }, []);
+
+      return null;
+    }
+
+    const unmount = renderRootHelper(<ComponentWithEffects />);
+
+    expect(Scheduler).toFlushUntilNextPaint([
+      'layout 1 mount',
+      'layout 2 mount',
+    ]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-16",
+        "--render-start-16",
+        "--component-render-start-ComponentWithEffects",
+        "--component-render-stop",
+        "--render-stop",
+        "--commit-start-16",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--layout-effects-start-16",
+        "--component-layout-effect-mount-start-ComponentWithEffects",
+        "--component-layout-effect-mount-stop",
+        "--component-layout-effect-mount-start-ComponentWithEffects",
+        "--component-layout-effect-mount-stop",
+        "--layout-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushAndYield([
+      'passive 1 mount',
+      'passive 2 mount',
+      'passive 3 mount',
+    ]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--passive-effects-start-16",
+        "--component-passive-effect-mount-start-ComponentWithEffects",
+        "--component-passive-effect-mount-stop",
+        "--component-passive-effect-mount-start-ComponentWithEffects",
+        "--component-passive-effect-mount-stop",
+        "--component-passive-effect-mount-start-ComponentWithEffects",
+        "--component-passive-effect-mount-stop",
+        "--passive-effects-stop",
+      ]
+    `);
+
+    clearPendingMarks();
+
+    expect(Scheduler).toFlushAndYield([]);
+
+    unmount();
+
+    expect(Scheduler).toHaveYielded([
+      'layout 1 unmount',
+      'layout 2 unmount',
+      'passive 1 unmount',
+      'passive 2 unmount',
+      'passive 3 unmount',
+    ]);
+
+    expect(clearedMarks).toMatchInlineSnapshot(`
+      Array [
+        "--schedule-render-1",
+        "--render-start-1",
+        "--render-stop",
+        "--commit-start-1",
+        "--react-version-<filtered-version>",
+        "--profiler-version-1",
+        "--react-internal-module-start-<filtered-file-system-path>",
+        "--react-internal-module-stop-<filtered-file-system-path>",
+        "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+        "--component-layout-effect-unmount-start-ComponentWithEffects",
+        "--component-layout-effect-unmount-stop",
+        "--component-layout-effect-unmount-start-ComponentWithEffects",
+        "--component-layout-effect-unmount-stop",
+        "--layout-effects-start-1",
+        "--layout-effects-stop",
+        "--passive-effects-start-1",
+        "--component-passive-effect-unmount-start-ComponentWithEffects",
+        "--component-passive-effect-unmount-stop",
+        "--component-passive-effect-unmount-start-ComponentWithEffects",
+        "--component-passive-effect-unmount-stop",
+        "--component-passive-effect-unmount-start-ComponentWithEffects",
+        "--component-passive-effect-unmount-stop",
+        "--passive-effects-stop",
+        "--commit-stop",
+      ]
+    `);
+  });
+
+  describe('lane labels', () => {
+    it('regression test SyncLane', () => {
+      renderHelper(<div />);
+
+      expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-render-1",
+          "--render-start-1",
+          "--render-stop",
+          "--commit-start-1",
+          "--react-version-<filtered-version>",
+          "--profiler-version-1",
+          "--react-internal-module-start-<filtered-file-system-path>",
+          "--react-internal-module-stop-<filtered-file-system-path>",
+          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+          "--layout-effects-start-1",
+          "--layout-effects-stop",
+          "--commit-stop",
+        ]
+      `);
+    });
+
+    it('regression test DefaultLane', () => {
+      renderRootHelper(<div />);
+      expect(clearedMarks).toMatchInlineSnapshot(`
+          Array [
+            "--schedule-render-16",
+          ]
+      `);
+    });
+
+    it('regression test InputDiscreteLane', async () => {
+      const targetRef = React.createRef(null);
+
+      function App() {
+        const [count, setCount] = React.useState(0);
+        const handleClick = () => {
+          setCount(count + 1);
+        };
+        return <button ref={targetRef} onClick={handleClick} />;
+      }
+
+      renderRootHelper(<App />);
+      expect(Scheduler).toFlushAndYield([]);
+
+      clearedMarks.splice(0);
+
+      targetRef.current.click();
+
+      // Wait a frame, for React to process the "click" update.
+      await Promise.resolve();
+
+      expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-state-update-1-App",
+          "--render-start-1",
+          "--component-render-start-App",
+          "--component-render-stop",
+          "--render-stop",
+          "--commit-start-1",
+          "--react-version-<filtered-version>",
+          "--profiler-version-1",
+          "--react-internal-module-start-<filtered-file-system-path>",
+          "--react-internal-module-stop-<filtered-file-system-path>",
+          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+          "--layout-effects-start-1",
+          "--layout-effects-stop",
+          "--commit-stop",
+        ]
+      `);
+    });
+
+    it('regression test InputContinuousLane', async () => {
+      const targetRef = React.createRef(null);
+
+      function App() {
+        const [count, setCount] = React.useState(0);
+        const handleMouseOver = () => setCount(count + 1);
+        return <div ref={targetRef} onMouseOver={handleMouseOver} />;
+      }
+
+      renderRootHelper(<App />);
+      expect(Scheduler).toFlushAndYield([]);
+
+      clearedMarks.splice(0);
+
+      const event = document.createEvent('MouseEvents');
+      event.initEvent('mouseover', true, true);
+      dispatchAndSetCurrentEvent(targetRef.current, event);
+
+      expect(Scheduler).toFlushAndYield([]);
+
+      expect(clearedMarks).toMatchInlineSnapshot(`
+        Array [
+          "--schedule-state-update-4-App",
+          "--render-start-4",
+          "--component-render-start-App",
+          "--component-render-stop",
+          "--render-stop",
+          "--commit-start-4",
+          "--react-version-<filtered-version>",
+          "--profiler-version-1",
+          "--react-internal-module-start-<filtered-file-system-path>",
+          "--react-internal-module-stop-<filtered-file-system-path>",
+          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
+          "--layout-effects-start-4",
+          "--layout-effects-stop",
+          "--commit-stop",
+        ]
+      `);
+    });
+  });
+});
diff --git a/packages/react-devtools-shared/src/__tests__/preprocessData-test.js b/packages/react-devtools-shared/src/__tests__/preprocessData-test.js
new file mode 100644
index 0000000000000..b513db2e7e78d
--- /dev/null
+++ b/packages/react-devtools-shared/src/__tests__/preprocessData-test.js
@@ -0,0 +1,1929 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+'use strict';
+
+describe('Timeline profiler', () => {
+  let React;
+  let ReactDOM;
+  let Scheduler;
+  let utils;
+
+  let clearedMarks;
+  let featureDetectionMarkName = null;
+  let marks;
+  let setPerformanceMock;
+
+  function createUserTimingPolyfill() {
+    featureDetectionMarkName = null;
+
+    clearedMarks = [];
+    marks = [];
+
+    // Remove file-system specific bits or version-specific bits of information from the module range marks.
+    function filterMarkData(markName) {
+      if (markName.startsWith('--react-internal-module-start')) {
+        return `${markName.substr(0, 29)}-<filtered-file-system-path>`;
+      } else if (markName.startsWith('--react-internal-module-stop')) {
+        return `${markName.substr(0, 28)}-<filtered-file-system-path>`;
+      } else if (markName.startsWith('--react-version')) {
+        return `${markName.substr(0, 15)}-0.0.0`;
+      } else {
+        return markName;
+      }
+    }
+
+    // This is not a true polyfill, but it gives us enough to capture marks.
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
+    return {
+      clearMarks(markName) {
+        markName = filterMarkData(markName);
+
+        clearedMarks.push(markName);
+        marks = marks.filter(mark => mark !== markName);
+      },
+      mark(markName, markOptions) {
+        markName = filterMarkData(markName);
+
+        if (featureDetectionMarkName === null) {
+          featureDetectionMarkName = markName;
+        }
+
+        marks.push(markName);
+
+        if (markOptions != null) {
+          // This is triggers the feature detection.
+          markOptions.startTime++;
+        }
+      },
+    };
+  }
+
+  function clearPendingMarks() {
+    clearedMarks.splice(0);
+  }
+
+  beforeEach(() => {
+    utils = require('./utils');
+    utils.beforeEachProfiling();
+
+    React = require('react');
+    ReactDOM = require('react-dom');
+    Scheduler = require('scheduler');
+
+    setPerformanceMock = require('react-devtools-shared/src/backend/profilingHooks')
+      .setPerformanceMock_ONLY_FOR_TESTING;
+    setPerformanceMock(createUserTimingPolyfill());
+
+    global.IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  afterEach(() => {
+    // Verify all logged marks also get cleared.
+    expect(marks).toHaveLength(0);
+
+    setPerformanceMock(null);
+  });
+
+  describe('getLanesFromTransportDecimalBitmask', () => {
+    let getLanesFromTransportDecimalBitmask;
+
+    beforeEach(() => {
+      getLanesFromTransportDecimalBitmask = require('react-devtools-timeline/src/import-worker/preprocessData')
+        .getLanesFromTransportDecimalBitmask;
+    });
+
+    it('should return array of lane numbers from bitmask string', () => {
+      expect(getLanesFromTransportDecimalBitmask('1')).toEqual([0]);
+      expect(getLanesFromTransportDecimalBitmask('512')).toEqual([9]);
+      expect(getLanesFromTransportDecimalBitmask('3')).toEqual([0, 1]);
+      expect(getLanesFromTransportDecimalBitmask('1234')).toEqual([
+        1,
+        4,
+        6,
+        7,
+        10,
+      ]); // 2 + 16 + 64 + 128 + 1024
+      expect(
+        getLanesFromTransportDecimalBitmask('1073741824'), // 0b1000000000000000000000000000000
+      ).toEqual([30]);
+      expect(
+        getLanesFromTransportDecimalBitmask('2147483647'), // 0b1111111111111111111111111111111
+      ).toEqual(Array.from(Array(31).keys()));
+    });
+
+    it('should return empty array if laneBitmaskString is not a bitmask', () => {
+      expect(getLanesFromTransportDecimalBitmask('')).toEqual([]);
+      expect(getLanesFromTransportDecimalBitmask('hello')).toEqual([]);
+      expect(getLanesFromTransportDecimalBitmask('-1')).toEqual([]);
+      expect(getLanesFromTransportDecimalBitmask('-0')).toEqual([]);
+    });
+
+    it('should ignore lanes outside REACT_TOTAL_NUM_LANES', () => {
+      const REACT_TOTAL_NUM_LANES = require('react-devtools-timeline/src/constants')
+        .REACT_TOTAL_NUM_LANES;
+
+      // Sanity check; this test may need to be updated when the no. of fiber lanes are changed.
+      expect(REACT_TOTAL_NUM_LANES).toBe(31);
+
+      expect(
+        getLanesFromTransportDecimalBitmask(
+          '4294967297', // 2^32 + 1
+        ),
+      ).toEqual([0]);
+    });
+  });
+
+  describe('preprocessData', () => {
+    let preprocessData;
+
+    beforeEach(() => {
+      preprocessData = require('react-devtools-timeline/src/import-worker/preprocessData')
+        .default;
+    });
+
+    // These should be dynamic to mimic a real profile,
+    // but reprooducible between test runs.
+    let pid = 0;
+    let tid = 0;
+    let startTime = 0;
+
+    function createUserTimingEntry(data) {
+      return {
+        pid: ++pid,
+        tid: ++tid,
+        ts: ++startTime,
+        ...data,
+      };
+    }
+
+    function createProfilerVersionEntry() {
+      const SCHEDULING_PROFILER_VERSION = require('react-devtools-timeline/src/constants')
+        .SCHEDULING_PROFILER_VERSION;
+      return createUserTimingEntry({
+        cat: 'blink.user_timing',
+        name: '--profiler-version-' + SCHEDULING_PROFILER_VERSION,
+      });
+    }
+
+    function createReactVersionEntry() {
+      return createUserTimingEntry({
+        cat: 'blink.user_timing',
+        name: '--react-version-0.0.0',
+      });
+    }
+
+    function createLaneLabelsEntry() {
+      return createUserTimingEntry({
+        cat: 'blink.user_timing',
+        name:
+          '--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen',
+      });
+    }
+
+    function createNativeEventEntry(type, duration) {
+      return createUserTimingEntry({
+        cat: 'devtools.timeline',
+        name: 'EventDispatch',
+        args: {data: {type}},
+        dur: duration,
+        tdur: duration,
+      });
+    }
+
+    function creactCpuProfilerSample() {
+      return createUserTimingEntry({
+        args: {data: {startTime: ++startTime}},
+        cat: 'disabled-by-default-v8.cpu_profiler',
+        id: '0x1',
+        name: 'Profile',
+        ph: 'P',
+      });
+    }
+
+    function createBoilerplateEntries() {
+      return [
+        createProfilerVersionEntry(),
+        createReactVersionEntry(),
+        createLaneLabelsEntry(),
+      ];
+    }
+
+    function createUserTimingData(sampleMarks) {
+      const cpuProfilerSample = creactCpuProfilerSample();
+
+      const randomSample = createUserTimingEntry({
+        dur: 100,
+        tdur: 200,
+        ph: 'X',
+        cat: 'disabled-by-default-devtools.timeline',
+        name: 'RunTask',
+        args: {},
+      });
+
+      const userTimingData = [cpuProfilerSample, randomSample];
+
+      sampleMarks.forEach(markName => {
+        userTimingData.push({
+          pid: ++pid,
+          tid: ++tid,
+          ts: ++startTime,
+          args: {data: {}},
+          cat: 'blink.user_timing',
+          name: markName,
+          ph: 'R',
+        });
+      });
+
+      return userTimingData;
+    }
+
+    beforeEach(() => {
+      tid = 0;
+      pid = 0;
+      startTime = 0;
+    });
+
+    it('should throw given an empty timeline', async () => {
+      await expect(async () => preprocessData([])).rejects.toThrow();
+    });
+
+    it('should throw given a timeline with no Profile event', async () => {
+      const randomSample = createUserTimingEntry({
+        dur: 100,
+        tdur: 200,
+        ph: 'X',
+        cat: 'disabled-by-default-devtools.timeline',
+        name: 'RunTask',
+        args: {},
+      });
+
+      await expect(async () =>
+        preprocessData([randomSample]),
+      ).rejects.toThrow();
+    });
+
+    it('should throw given a timeline without an explicit profiler version mark nor any other React marks', async () => {
+      const cpuProfilerSample = creactCpuProfilerSample();
+
+      await expect(
+        async () => await preprocessData([cpuProfilerSample]),
+      ).rejects.toThrow(
+        'Please provide profiling data from an React application',
+      );
+    });
+
+    it('should throw given a timeline with React scheduling marks, but without an explicit profiler version mark', async () => {
+      const cpuProfilerSample = creactCpuProfilerSample();
+      const scheduleRenderSample = createUserTimingEntry({
+        cat: 'blink.user_timing',
+        name: '--schedule-render-512-',
+      });
+      const samples = [cpuProfilerSample, scheduleRenderSample];
+
+      await expect(async () => await preprocessData(samples)).rejects.toThrow(
+        'This version of profiling data is not supported',
+      );
+    });
+
+    it('should return empty data given a timeline with no React scheduling profiling marks', async () => {
+      const cpuProfilerSample = creactCpuProfilerSample();
+      const randomSample = createUserTimingEntry({
+        dur: 100,
+        tdur: 200,
+        ph: 'X',
+        cat: 'disabled-by-default-devtools.timeline',
+        name: 'RunTask',
+        args: {},
+      });
+
+      const data = await preprocessData([
+        ...createBoilerplateEntries(),
+        cpuProfilerSample,
+        randomSample,
+      ]);
+      expect(data).toMatchInlineSnapshot(`
+      Object {
+        "batchUIDToMeasuresMap": Map {},
+        "componentMeasures": Array [],
+        "duration": 0.005,
+        "flamechart": Array [],
+        "internalModuleSourceToRanges": Map {},
+        "laneToLabelMap": Map {
+          0 => "Sync",
+          1 => "InputContinuousHydration",
+          2 => "InputContinuous",
+          3 => "DefaultHydration",
+          4 => "Default",
+          5 => "TransitionHydration",
+          6 => "Transition",
+          7 => "Transition",
+          8 => "Transition",
+          9 => "Transition",
+          10 => "Transition",
+          11 => "Transition",
+          12 => "Transition",
+          13 => "Transition",
+          14 => "Transition",
+          15 => "Transition",
+          16 => "Transition",
+          17 => "Transition",
+          18 => "Transition",
+          19 => "Transition",
+          20 => "Transition",
+          21 => "Transition",
+          22 => "Retry",
+          23 => "Retry",
+          24 => "Retry",
+          25 => "Retry",
+          26 => "Retry",
+          27 => "SelectiveHydration",
+          28 => "IdleHydration",
+          29 => "Idle",
+          30 => "Offscreen",
+        },
+        "laneToReactMeasureMap": Map {
+          0 => Array [],
+          1 => Array [],
+          2 => Array [],
+          3 => Array [],
+          4 => Array [],
+          5 => Array [],
+          6 => Array [],
+          7 => Array [],
+          8 => Array [],
+          9 => Array [],
+          10 => Array [],
+          11 => Array [],
+          12 => Array [],
+          13 => Array [],
+          14 => Array [],
+          15 => Array [],
+          16 => Array [],
+          17 => Array [],
+          18 => Array [],
+          19 => Array [],
+          20 => Array [],
+          21 => Array [],
+          22 => Array [],
+          23 => Array [],
+          24 => Array [],
+          25 => Array [],
+          26 => Array [],
+          27 => Array [],
+          28 => Array [],
+          29 => Array [],
+          30 => Array [],
+        },
+        "nativeEvents": Array [],
+        "networkMeasures": Array [],
+        "otherUserTimingMarks": Array [],
+        "reactVersion": "0.0.0",
+        "schedulingEvents": Array [],
+        "snapshotHeight": 0,
+        "snapshots": Array [],
+        "startTime": 1,
+        "suspenseEvents": Array [],
+        "thrownErrors": Array [],
+      }
+    `);
+    });
+
+    it('should process legacy data format (before lane labels were added)', async () => {
+      const cpuProfilerSample = creactCpuProfilerSample();
+
+      // Data below is hard-coded based on an older profile sample.
+      // Should be fine since this is explicitly a legacy-format test.
+      const data = await preprocessData([
+        ...createBoilerplateEntries(),
+        cpuProfilerSample,
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--schedule-render-512-',
+        }),
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--render-start-512',
+        }),
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--render-stop',
+        }),
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--commit-start-512',
+        }),
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--layout-effects-start-512',
+        }),
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--layout-effects-stop',
+        }),
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--commit-stop',
+        }),
+      ]);
+      expect(data).toMatchInlineSnapshot(`
+      Object {
+        "batchUIDToMeasuresMap": Map {
+          0 => Array [
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.004999999999999999,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.006,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.001,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.006,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.002999999999999999,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.008,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 1,
+              "duration": 0.0010000000000000009,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.009,
+              "type": "layout-effects",
+            },
+          ],
+        },
+        "componentMeasures": Array [],
+        "duration": 0.011,
+        "flamechart": Array [],
+        "internalModuleSourceToRanges": Map {},
+        "laneToLabelMap": Map {
+          0 => "Sync",
+          1 => "InputContinuousHydration",
+          2 => "InputContinuous",
+          3 => "DefaultHydration",
+          4 => "Default",
+          5 => "TransitionHydration",
+          6 => "Transition",
+          7 => "Transition",
+          8 => "Transition",
+          9 => "Transition",
+          10 => "Transition",
+          11 => "Transition",
+          12 => "Transition",
+          13 => "Transition",
+          14 => "Transition",
+          15 => "Transition",
+          16 => "Transition",
+          17 => "Transition",
+          18 => "Transition",
+          19 => "Transition",
+          20 => "Transition",
+          21 => "Transition",
+          22 => "Retry",
+          23 => "Retry",
+          24 => "Retry",
+          25 => "Retry",
+          26 => "Retry",
+          27 => "SelectiveHydration",
+          28 => "IdleHydration",
+          29 => "Idle",
+          30 => "Offscreen",
+        },
+        "laneToReactMeasureMap": Map {
+          0 => Array [],
+          1 => Array [],
+          2 => Array [],
+          3 => Array [],
+          4 => Array [],
+          5 => Array [],
+          6 => Array [],
+          7 => Array [],
+          8 => Array [],
+          9 => Array [
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.004999999999999999,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.006,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.001,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.006,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.002999999999999999,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.008,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 1,
+              "duration": 0.0010000000000000009,
+              "lanes": Array [
+                9,
+              ],
+              "timestamp": 0.009,
+              "type": "layout-effects",
+            },
+          ],
+          10 => Array [],
+          11 => Array [],
+          12 => Array [],
+          13 => Array [],
+          14 => Array [],
+          15 => Array [],
+          16 => Array [],
+          17 => Array [],
+          18 => Array [],
+          19 => Array [],
+          20 => Array [],
+          21 => Array [],
+          22 => Array [],
+          23 => Array [],
+          24 => Array [],
+          25 => Array [],
+          26 => Array [],
+          27 => Array [],
+          28 => Array [],
+          29 => Array [],
+          30 => Array [],
+        },
+        "nativeEvents": Array [],
+        "networkMeasures": Array [],
+        "otherUserTimingMarks": Array [],
+        "reactVersion": "0.0.0",
+        "schedulingEvents": Array [
+          Object {
+            "lanes": Array [
+              9,
+            ],
+            "timestamp": 0.005,
+            "type": "schedule-render",
+            "warning": null,
+          },
+        ],
+        "snapshotHeight": 0,
+        "snapshots": Array [],
+        "startTime": 1,
+        "suspenseEvents": Array [],
+        "thrownErrors": Array [],
+      }
+    `);
+    });
+
+    it('should process a sample legacy render sequence', async () => {
+      utils.legacyRender(<div />, document.createElement('div'));
+
+      const data = await preprocessData([
+        ...createBoilerplateEntries(),
+        ...createUserTimingData(clearedMarks),
+      ]);
+      expect(data).toMatchInlineSnapshot(`
+      Object {
+        "batchUIDToMeasuresMap": Map {
+          0 => Array [
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.01,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.004,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.001,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.004,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.008,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.006,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 1,
+              "duration": 0.0009999999999999992,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.012,
+              "type": "layout-effects",
+            },
+          ],
+        },
+        "componentMeasures": Array [],
+        "duration": 0.014,
+        "flamechart": Array [],
+        "internalModuleSourceToRanges": Map {
+          undefined => Array [
+            Array [
+              Object {
+                "functionName": "<filtered-file-system-path>",
+              },
+              Object {
+                "functionName": "dule-stop-<filtered-file-system-path>",
+              },
+            ],
+          ],
+        },
+        "laneToLabelMap": Map {
+          0 => "Sync",
+          1 => "InputContinuousHydration",
+          2 => "InputContinuous",
+          3 => "DefaultHydration",
+          4 => "Default",
+          5 => "TransitionHydration",
+          6 => "Transition",
+          7 => "Transition",
+          8 => "Transition",
+          9 => "Transition",
+          10 => "Transition",
+          11 => "Transition",
+          12 => "Transition",
+          13 => "Transition",
+          14 => "Transition",
+          15 => "Transition",
+          16 => "Transition",
+          17 => "Transition",
+          18 => "Transition",
+          19 => "Transition",
+          20 => "Transition",
+          21 => "Transition",
+          22 => "Retry",
+          23 => "Retry",
+          24 => "Retry",
+          25 => "Retry",
+          26 => "Retry",
+          27 => "SelectiveHydration",
+          28 => "IdleHydration",
+          29 => "Idle",
+          30 => "Offscreen",
+        },
+        "laneToReactMeasureMap": Map {
+          0 => Array [
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.01,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.004,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.001,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.004,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.008,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.006,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 1,
+              "duration": 0.0009999999999999992,
+              "lanes": Array [
+                0,
+              ],
+              "timestamp": 0.012,
+              "type": "layout-effects",
+            },
+          ],
+          1 => Array [],
+          2 => Array [],
+          3 => Array [],
+          4 => Array [],
+          5 => Array [],
+          6 => Array [],
+          7 => Array [],
+          8 => Array [],
+          9 => Array [],
+          10 => Array [],
+          11 => Array [],
+          12 => Array [],
+          13 => Array [],
+          14 => Array [],
+          15 => Array [],
+          16 => Array [],
+          17 => Array [],
+          18 => Array [],
+          19 => Array [],
+          20 => Array [],
+          21 => Array [],
+          22 => Array [],
+          23 => Array [],
+          24 => Array [],
+          25 => Array [],
+          26 => Array [],
+          27 => Array [],
+          28 => Array [],
+          29 => Array [],
+          30 => Array [],
+        },
+        "nativeEvents": Array [],
+        "networkMeasures": Array [],
+        "otherUserTimingMarks": Array [],
+        "reactVersion": "0.0.0",
+        "schedulingEvents": Array [
+          Object {
+            "lanes": Array [
+              0,
+            ],
+            "timestamp": 0.003,
+            "type": "schedule-render",
+            "warning": null,
+          },
+        ],
+        "snapshotHeight": 0,
+        "snapshots": Array [],
+        "startTime": 4,
+        "suspenseEvents": Array [],
+        "thrownErrors": Array [],
+      }
+    `);
+    });
+
+    it('should process a sample createRoot render sequence', async () => {
+      function App() {
+        const [didMount, setDidMount] = React.useState(false);
+        React.useEffect(() => {
+          if (!didMount) {
+            setDidMount(true);
+          }
+        });
+        return true;
+      }
+
+      const root = ReactDOM.createRoot(document.createElement('div'));
+      utils.act(() => root.render(<App />));
+
+      const data = await preprocessData([
+        ...createBoilerplateEntries(),
+        ...createUserTimingData(clearedMarks),
+      ]);
+      expect(data).toMatchInlineSnapshot(`
+      Object {
+        "batchUIDToMeasuresMap": Map {
+          0 => Array [
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.012,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.004,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.003,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.004,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.008,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.008,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 1,
+              "duration": 0.0009999999999999992,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.014,
+              "type": "layout-effects",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.004,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.017,
+              "type": "passive-effects",
+            },
+          ],
+          1 => Array [
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.012000000000000004,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.022,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.0030000000000000027,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.022,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.008000000000000004,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.026,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 1,
+              "duration": 0.0010000000000000009,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.032,
+              "type": "layout-effects",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.0029999999999999957,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.035,
+              "type": "passive-effects",
+            },
+          ],
+        },
+        "componentMeasures": Array [
+          Object {
+            "componentName": "App",
+            "duration": 0.001,
+            "timestamp": 0.005,
+            "type": "render",
+            "warning": null,
+          },
+          Object {
+            "componentName": "App",
+            "duration": 0.0020000000000000018,
+            "timestamp": 0.018,
+            "type": "passive-effect-mount",
+            "warning": null,
+          },
+          Object {
+            "componentName": "App",
+            "duration": 0.0010000000000000009,
+            "timestamp": 0.023,
+            "type": "render",
+            "warning": null,
+          },
+          Object {
+            "componentName": "App",
+            "duration": 0.0010000000000000009,
+            "timestamp": 0.036,
+            "type": "passive-effect-mount",
+            "warning": null,
+          },
+        ],
+        "duration": 0.038,
+        "flamechart": Array [],
+        "internalModuleSourceToRanges": Map {
+          undefined => Array [
+            Array [
+              Object {
+                "functionName": "<filtered-file-system-path>",
+              },
+              Object {
+                "functionName": "dule-stop-<filtered-file-system-path>",
+              },
+            ],
+          ],
+        },
+        "laneToLabelMap": Map {
+          0 => "Sync",
+          1 => "InputContinuousHydration",
+          2 => "InputContinuous",
+          3 => "DefaultHydration",
+          4 => "Default",
+          5 => "TransitionHydration",
+          6 => "Transition",
+          7 => "Transition",
+          8 => "Transition",
+          9 => "Transition",
+          10 => "Transition",
+          11 => "Transition",
+          12 => "Transition",
+          13 => "Transition",
+          14 => "Transition",
+          15 => "Transition",
+          16 => "Transition",
+          17 => "Transition",
+          18 => "Transition",
+          19 => "Transition",
+          20 => "Transition",
+          21 => "Transition",
+          22 => "Retry",
+          23 => "Retry",
+          24 => "Retry",
+          25 => "Retry",
+          26 => "Retry",
+          27 => "SelectiveHydration",
+          28 => "IdleHydration",
+          29 => "Idle",
+          30 => "Offscreen",
+        },
+        "laneToReactMeasureMap": Map {
+          0 => Array [],
+          1 => Array [],
+          2 => Array [],
+          3 => Array [],
+          4 => Array [
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.012,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.004,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.003,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.004,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.008,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.008,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 1,
+              "duration": 0.0009999999999999992,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.014,
+              "type": "layout-effects",
+            },
+            Object {
+              "batchUID": 0,
+              "depth": 0,
+              "duration": 0.004,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.017,
+              "type": "passive-effects",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.012000000000000004,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.022,
+              "type": "render-idle",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.0030000000000000027,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.022,
+              "type": "render",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.008000000000000004,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.026,
+              "type": "commit",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 1,
+              "duration": 0.0010000000000000009,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.032,
+              "type": "layout-effects",
+            },
+            Object {
+              "batchUID": 1,
+              "depth": 0,
+              "duration": 0.0029999999999999957,
+              "lanes": Array [
+                4,
+              ],
+              "timestamp": 0.035,
+              "type": "passive-effects",
+            },
+          ],
+          5 => Array [],
+          6 => Array [],
+          7 => Array [],
+          8 => Array [],
+          9 => Array [],
+          10 => Array [],
+          11 => Array [],
+          12 => Array [],
+          13 => Array [],
+          14 => Array [],
+          15 => Array [],
+          16 => Array [],
+          17 => Array [],
+          18 => Array [],
+          19 => Array [],
+          20 => Array [],
+          21 => Array [],
+          22 => Array [],
+          23 => Array [],
+          24 => Array [],
+          25 => Array [],
+          26 => Array [],
+          27 => Array [],
+          28 => Array [],
+          29 => Array [],
+          30 => Array [],
+        },
+        "nativeEvents": Array [],
+        "networkMeasures": Array [],
+        "otherUserTimingMarks": Array [],
+        "reactVersion": "0.0.0",
+        "schedulingEvents": Array [
+          Object {
+            "lanes": Array [
+              4,
+            ],
+            "timestamp": 0.003,
+            "type": "schedule-render",
+            "warning": null,
+          },
+          Object {
+            "componentName": "App",
+            "lanes": Array [
+              4,
+            ],
+            "timestamp": 0.019,
+            "type": "schedule-state-update",
+            "warning": null,
+          },
+        ],
+        "snapshotHeight": 0,
+        "snapshots": Array [],
+        "startTime": 4,
+        "suspenseEvents": Array [],
+        "thrownErrors": Array [],
+      }
+    `);
+    });
+
+    it('should error if events and measures are incomplete', async () => {
+      const container = document.createElement('div');
+      utils.legacyRender(<div />, container);
+
+      const invalidMarks = clearedMarks.filter(
+        mark => !mark.includes('render-stop'),
+      );
+      const invalidUserTimingData = createUserTimingData(invalidMarks);
+
+      const error = spyOn(console, 'error');
+      preprocessData([...createBoilerplateEntries(), ...invalidUserTimingData]);
+      expect(error).toHaveBeenCalled();
+    });
+
+    it('should error if work is completed without being started', async () => {
+      const container = document.createElement('div');
+      utils.legacyRender(<div />, container);
+
+      const invalidMarks = clearedMarks.filter(
+        mark => !mark.includes('render-start'),
+      );
+      const invalidUserTimingData = createUserTimingData(invalidMarks);
+
+      const error = spyOn(console, 'error');
+      preprocessData([...createBoilerplateEntries(), ...invalidUserTimingData]);
+      expect(error).toHaveBeenCalled();
+    });
+
+    it('should populate other user timing marks', async () => {
+      const userTimingData = createUserTimingData([]);
+      userTimingData.push(
+        createUserTimingEntry({
+          args: {},
+          cat: 'blink.user_timing',
+          id: '0xcdf75f7c',
+          name: 'VCWithoutImage: root',
+          ph: 'n',
+          scope: 'blink.user_timing',
+        }),
+      );
+      userTimingData.push(
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: '--a-mark-that-looks-like-one-of-ours',
+          ph: 'R',
+        }),
+      );
+      userTimingData.push(
+        createUserTimingEntry({
+          cat: 'blink.user_timing',
+          name: 'Some other mark',
+          ph: 'R',
+        }),
+      );
+
+      const data = await preprocessData([
+        ...createBoilerplateEntries(),
+        ...userTimingData,
+      ]);
+      expect(data.otherUserTimingMarks).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "name": "VCWithoutImage: root",
+          "timestamp": 0.003,
+        },
+        Object {
+          "name": "--a-mark-that-looks-like-one-of-ours",
+          "timestamp": 0.004,
+        },
+        Object {
+          "name": "Some other mark",
+          "timestamp": 0.005,
+        },
+      ]
+    `);
+    });
+
+    it('should include a suspended resource "displayName" if one is set', async () => {
+      let promise = null;
+      let resolvedValue = null;
+      function readValue(value) {
+        if (resolvedValue !== null) {
+          return resolvedValue;
+        } else if (promise === null) {
+          promise = Promise.resolve(true).then(() => {
+            resolvedValue = value;
+          });
+          promise.displayName = 'Testing displayName';
+        }
+        throw promise;
+      }
+
+      function Component() {
+        const value = readValue(123);
+        return value;
+      }
+
+      const testMarks = [creactCpuProfilerSample()];
+
+      const root = ReactDOM.createRoot(document.createElement('div'));
+      utils.act(() =>
+        root.render(
+          <React.Suspense fallback="Loading...">
+            <Component />
+          </React.Suspense>,
+        ),
+      );
+
+      testMarks.push(...createUserTimingData(clearedMarks));
+
+      let data;
+      await utils.actAsync(async () => {
+        data = await preprocessData(testMarks);
+      });
+      expect(data.suspenseEvents).toHaveLength(1);
+      expect(data.suspenseEvents[0].promiseName).toBe('Testing displayName');
+    });
+
+    describe('warnings', () => {
+      describe('long event handlers', () => {
+        it('should not warn when React scedules a (sync) update inside of a short event handler', async () => {
+          function App() {
+            return null;
+          }
+
+          const testMarks = [
+            creactCpuProfilerSample(),
+            ...createBoilerplateEntries(),
+            createNativeEventEntry('click', 5),
+          ];
+
+          clearPendingMarks();
+
+          utils.legacyRender(<App />, document.createElement('div'));
+
+          testMarks.push(...createUserTimingData(clearedMarks));
+
+          const data = await preprocessData(testMarks);
+          const event = data.nativeEvents.find(({type}) => type === 'click');
+          expect(event.warning).toBe(null);
+        });
+
+        it('should not warn about long events if the cause was non-React JavaScript', async () => {
+          function App() {
+            return null;
+          }
+
+          const testMarks = [
+            creactCpuProfilerSample(),
+            ...createBoilerplateEntries(),
+            createNativeEventEntry('click', 25000),
+          ];
+
+          startTime += 2000;
+
+          clearPendingMarks();
+
+          utils.legacyRender(<App />, document.createElement('div'));
+
+          testMarks.push(...createUserTimingData(clearedMarks));
+
+          const data = await preprocessData(testMarks);
+          const event = data.nativeEvents.find(({type}) => type === 'click');
+          expect(event.warning).toBe(null);
+        });
+
+        it('should warn when React scedules a long (sync) update inside of an event', async () => {
+          function App() {
+            return null;
+          }
+
+          const testMarks = [
+            creactCpuProfilerSample(),
+            ...createBoilerplateEntries(),
+            createNativeEventEntry('click', 25000),
+          ];
+
+          clearPendingMarks();
+
+          utils.legacyRender(<App />, document.createElement('div'));
+
+          clearedMarks.forEach(markName => {
+            if (markName === '--render-stop') {
+              // Fake a long running render
+              startTime += 20000;
+            }
+
+            testMarks.push({
+              pid: ++pid,
+              tid: ++tid,
+              ts: ++startTime,
+              args: {data: {}},
+              cat: 'blink.user_timing',
+              name: markName,
+              ph: 'R',
+            });
+          });
+
+          const data = await preprocessData(testMarks);
+          const event = data.nativeEvents.find(({type}) => type === 'click');
+          expect(event.warning).toMatchInlineSnapshot(
+            `"An event handler scheduled a big update with React. Consider using the Transition API to defer some of this work."`,
+          );
+        });
+
+        it('should not warn when React finishes a previously long (async) update with a short (sync) update inside of an event', async () => {
+          function Yield({id, value}) {
+            Scheduler.unstable_yieldValue(`${id}:${value}`);
+            return null;
+          }
+
+          const testMarks = [
+            creactCpuProfilerSample(),
+            ...createBoilerplateEntries(),
+          ];
+
+          // Advance the clock by some arbitrary amount.
+          startTime += 50000;
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+
+          // Temporarily turn off the act environment, since we're intentionally using Scheduler instead.
+          global.IS_REACT_ACT_ENVIRONMENT = false;
+          React.startTransition(() => {
+            // Start rendering an async update (but don't finish).
+            root.render(
+              <>
+                <Yield id="A" value={1} />
+                <Yield id="B" value={1} />
+              </>,
+            );
+            expect(Scheduler).toFlushAndYieldThrough(['A:1']);
+
+            testMarks.push(...createUserTimingData(clearedMarks));
+            clearPendingMarks();
+
+            // Advance the clock some more to make the pending React update seem long.
+            startTime += 20000;
+
+            // Fake a long "click" event in the middle
+            // and schedule a sync update that will also flush the previous work.
+            testMarks.push(createNativeEventEntry('click', 25000));
+            ReactDOM.flushSync(() => {
+              root.render(
+                <>
+                  <Yield id="A" value={2} />
+                  <Yield id="B" value={2} />
+                </>,
+              );
+            });
+          });
+
+          expect(Scheduler).toHaveYielded(['A:2', 'B:2']);
+
+          testMarks.push(...createUserTimingData(clearedMarks));
+
+          const data = await preprocessData(testMarks);
+          const event = data.nativeEvents.find(({type}) => type === 'click');
+          expect(event.warning).toBe(null);
+        });
+      });
+
+      describe('nested updates', () => {
+        it('should not warn about short nested (state) updates during layout effects', async () => {
+          function Component() {
+            const [didMount, setDidMount] = React.useState(false);
+            Scheduler.unstable_yieldValue(
+              `Component ${didMount ? 'update' : 'mount'}`,
+            );
+            React.useLayoutEffect(() => {
+              setDidMount(true);
+            }, []);
+            return didMount;
+          }
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() => {
+            root.render(<Component />);
+          });
+
+          expect(Scheduler).toHaveYielded([
+            'Component mount',
+            'Component update',
+          ]);
+
+          const data = await preprocessData([
+            ...createBoilerplateEntries(),
+            ...createUserTimingData(clearedMarks),
+          ]);
+
+          const event = data.schedulingEvents.find(
+            ({type}) => type === 'schedule-state-update',
+          );
+          expect(event.warning).toBe(null);
+        });
+
+        it('should not warn about short (forced) updates during layout effects', async () => {
+          class Component extends React.Component {
+            _didMount: boolean = false;
+            componentDidMount() {
+              this._didMount = true;
+              this.forceUpdate();
+            }
+            render() {
+              Scheduler.unstable_yieldValue(
+                `Component ${this._didMount ? 'update' : 'mount'}`,
+              );
+              return null;
+            }
+          }
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() => {
+            root.render(<Component />);
+          });
+
+          expect(Scheduler).toHaveYielded([
+            'Component mount',
+            'Component update',
+          ]);
+
+          const data = await preprocessData([
+            ...createBoilerplateEntries(),
+            ...createUserTimingData(clearedMarks),
+          ]);
+
+          const event = data.schedulingEvents.find(
+            ({type}) => type === 'schedule-force-update',
+          );
+          expect(event.warning).toBe(null);
+        });
+
+        it('should warn about long nested (state) updates during layout effects', async () => {
+          function Component() {
+            const [didMount, setDidMount] = React.useState(false);
+            Scheduler.unstable_yieldValue(
+              `Component ${didMount ? 'update' : 'mount'}`,
+            );
+            // Fake a long render
+            startTime += 20000;
+            React.useLayoutEffect(() => {
+              setDidMount(true);
+            }, []);
+            return didMount;
+          }
+
+          const cpuProfilerSample = creactCpuProfilerSample();
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() => {
+            root.render(<Component />);
+          });
+
+          expect(Scheduler).toHaveYielded([
+            'Component mount',
+            'Component update',
+          ]);
+
+          const testMarks = [];
+          clearedMarks.forEach(markName => {
+            if (markName === '--component-render-start-Component') {
+              // Fake a long running render
+              startTime += 20000;
+            }
+
+            testMarks.push({
+              pid: ++pid,
+              tid: ++tid,
+              ts: ++startTime,
+              args: {data: {}},
+              cat: 'blink.user_timing',
+              name: markName,
+              ph: 'R',
+            });
+          });
+
+          const data = await preprocessData([
+            cpuProfilerSample,
+            ...createBoilerplateEntries(),
+            ...testMarks,
+          ]);
+
+          const event = data.schedulingEvents.find(
+            ({type}) => type === 'schedule-state-update',
+          );
+          expect(event.warning).toMatchInlineSnapshot(
+            `"A big nested update was scheduled during layout. Nested updates require React to re-render synchronously before the browser can paint. Consider delaying this update by moving it to a passive effect (useEffect)."`,
+          );
+        });
+
+        it('should warn about long nested (forced) updates during layout effects', async () => {
+          class Component extends React.Component {
+            _didMount: boolean = false;
+            componentDidMount() {
+              this._didMount = true;
+              this.forceUpdate();
+            }
+            render() {
+              Scheduler.unstable_yieldValue(
+                `Component ${this._didMount ? 'update' : 'mount'}`,
+              );
+              return null;
+            }
+          }
+
+          const cpuProfilerSample = creactCpuProfilerSample();
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() => {
+            root.render(<Component />);
+          });
+
+          expect(Scheduler).toHaveYielded([
+            'Component mount',
+            'Component update',
+          ]);
+
+          const testMarks = [];
+          clearedMarks.forEach(markName => {
+            if (markName === '--component-render-start-Component') {
+              // Fake a long running render
+              startTime += 20000;
+            }
+
+            testMarks.push({
+              pid: ++pid,
+              tid: ++tid,
+              ts: ++startTime,
+              args: {data: {}},
+              cat: 'blink.user_timing',
+              name: markName,
+              ph: 'R',
+            });
+          });
+
+          const data = await preprocessData([
+            cpuProfilerSample,
+            ...createBoilerplateEntries(),
+            ...testMarks,
+          ]);
+
+          const event = data.schedulingEvents.find(
+            ({type}) => type === 'schedule-force-update',
+          );
+          expect(event.warning).toMatchInlineSnapshot(
+            `"A big nested update was scheduled during layout. Nested updates require React to re-render synchronously before the browser can paint. Consider delaying this update by moving it to a passive effect (useEffect)."`,
+          );
+        });
+
+        it('should not warn about transition updates scheduled during commit phase', async () => {
+          function Component() {
+            const [value, setValue] = React.useState(0);
+            // eslint-disable-next-line no-unused-vars
+            const [isPending, startTransition] = React.useTransition();
+
+            Scheduler.unstable_yieldValue(
+              `Component rendered with value ${value}`,
+            );
+
+            // Fake a long render
+            if (value !== 0) {
+              Scheduler.unstable_yieldValue('Long render');
+              startTime += 20000;
+            }
+
+            React.useLayoutEffect(() => {
+              startTransition(() => {
+                setValue(1);
+              });
+            }, []);
+
+            return value;
+          }
+
+          const cpuProfilerSample = creactCpuProfilerSample();
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() => {
+            root.render(<Component />);
+          });
+
+          expect(Scheduler).toHaveYielded([
+            'Component rendered with value 0',
+            'Component rendered with value 0',
+            'Component rendered with value 1',
+            'Long render',
+          ]);
+
+          const testMarks = [];
+          clearedMarks.forEach(markName => {
+            if (markName === '--component-render-start-Component') {
+              // Fake a long running render
+              startTime += 20000;
+            }
+
+            testMarks.push({
+              pid: ++pid,
+              tid: ++tid,
+              ts: ++startTime,
+              args: {data: {}},
+              cat: 'blink.user_timing',
+              name: markName,
+              ph: 'R',
+            });
+          });
+
+          const data = await preprocessData([
+            cpuProfilerSample,
+            ...createBoilerplateEntries(),
+            ...testMarks,
+          ]);
+
+          data.schedulingEvents.forEach(event => {
+            expect(event.warning).toBeNull();
+          });
+        });
+
+        it('should not warn about deferred value updates scheduled during commit phase', async () => {
+          function Component() {
+            const [value, setValue] = React.useState(0);
+            const deferredValue = React.useDeferredValue(value);
+
+            Scheduler.unstable_yieldValue(
+              `Component rendered with value ${value} and deferredValue ${deferredValue}`,
+            );
+
+            // Fake a long render
+            if (deferredValue !== 0) {
+              Scheduler.unstable_yieldValue('Long render');
+              startTime += 20000;
+            }
+
+            React.useLayoutEffect(() => {
+              setValue(1);
+            }, []);
+
+            return value + deferredValue;
+          }
+
+          const cpuProfilerSample = creactCpuProfilerSample();
+
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() => {
+            root.render(<Component />);
+          });
+
+          expect(Scheduler).toHaveYielded([
+            'Component rendered with value 0 and deferredValue 0',
+            'Component rendered with value 1 and deferredValue 0',
+            'Component rendered with value 1 and deferredValue 1',
+            'Long render',
+          ]);
+
+          const testMarks = [];
+          clearedMarks.forEach(markName => {
+            if (markName === '--component-render-start-Component') {
+              // Fake a long running render
+              startTime += 20000;
+            }
+
+            testMarks.push({
+              pid: ++pid,
+              tid: ++tid,
+              ts: ++startTime,
+              args: {data: {}},
+              cat: 'blink.user_timing',
+              name: markName,
+              ph: 'R',
+            });
+          });
+
+          const data = await preprocessData([
+            cpuProfilerSample,
+            ...createBoilerplateEntries(),
+            ...testMarks,
+          ]);
+
+          data.schedulingEvents.forEach(event => {
+            expect(event.warning).toBeNull();
+          });
+        });
+      });
+
+      describe('errors thrown while rendering', () => {
+        it('shoult parse Errors thrown during render', async () => {
+          spyOn(console, 'error');
+
+          class ErrorBoundary extends React.Component {
+            state = {error: null};
+            componentDidCatch(error) {
+              this.setState({error});
+            }
+            render() {
+              if (this.state.error) {
+                return null;
+              }
+              return this.props.children;
+            }
+          }
+
+          function ExampleThatThrows() {
+            throw Error('Expected error');
+          }
+
+          const testMarks = [creactCpuProfilerSample()];
+
+          // Mount and commit the app
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() =>
+            root.render(
+              <ErrorBoundary>
+                <ExampleThatThrows />
+              </ErrorBoundary>,
+            ),
+          );
+
+          testMarks.push(...createUserTimingData(clearedMarks));
+
+          const data = await preprocessData(testMarks);
+          expect(data.thrownErrors).toHaveLength(2);
+          expect(data.thrownErrors[0].message).toMatchInlineSnapshot(
+            '"Expected error"',
+          );
+        });
+      });
+
+      describe('suspend during an update', () => {
+        // This also tests an edge case where the a component suspends while profiling
+        // before the first commit is logged (so the lane-to-labels map will not yet exist).
+        it('should warn about suspending during an udpate', async () => {
+          let promise = null;
+          let resolvedValue = null;
+          function readValue(value) {
+            if (resolvedValue !== null) {
+              return resolvedValue;
+            } else if (promise === null) {
+              promise = Promise.resolve(true).then(() => {
+                resolvedValue = value;
+              });
+            }
+            throw promise;
+          }
+
+          function Component({shouldSuspend}) {
+            Scheduler.unstable_yieldValue(`Component ${shouldSuspend}`);
+            if (shouldSuspend) {
+              readValue(123);
+            }
+            return null;
+          }
+
+          // Mount and commit the app
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() =>
+            root.render(
+              <React.Suspense fallback="Loading...">
+                <Component shouldSuspend={false} />
+              </React.Suspense>,
+            ),
+          );
+
+          clearPendingMarks();
+
+          const testMarks = [creactCpuProfilerSample()];
+
+          // Start profiling and suspend during a render.
+          utils.act(() =>
+            root.render(
+              <React.Suspense fallback="Loading...">
+                <Component shouldSuspend={true} />
+              </React.Suspense>,
+            ),
+          );
+
+          testMarks.push(...createUserTimingData(clearedMarks));
+
+          let data;
+          await utils.actAsync(async () => {
+            data = await preprocessData(testMarks);
+          });
+          expect(data.suspenseEvents).toHaveLength(1);
+          expect(data.suspenseEvents[0].warning).toMatchInlineSnapshot(
+            `"A component suspended during an update which caused a fallback to be shown. Consider using the Transition API to avoid hiding components after they've been mounted."`,
+          );
+        });
+
+        it('should not warn about suspending during an transition', async () => {
+          let promise = null;
+          let resolvedValue = null;
+          function readValue(value) {
+            if (resolvedValue !== null) {
+              return resolvedValue;
+            } else if (promise === null) {
+              promise = Promise.resolve(true).then(() => {
+                resolvedValue = value;
+              });
+            }
+            throw promise;
+          }
+
+          function Component({shouldSuspend}) {
+            Scheduler.unstable_yieldValue(`Component ${shouldSuspend}`);
+            if (shouldSuspend) {
+              readValue(123);
+            }
+            return null;
+          }
+
+          // Mount and commit the app
+          const root = ReactDOM.createRoot(document.createElement('div'));
+          utils.act(() =>
+            root.render(
+              <React.Suspense fallback="Loading...">
+                <Component shouldSuspend={false} />
+              </React.Suspense>,
+            ),
+          );
+
+          const testMarks = [creactCpuProfilerSample()];
+
+          // Start profiling and suspend during a render.
+          await utils.actAsync(async () =>
+            React.startTransition(() =>
+              root.render(
+                <React.Suspense fallback="Loading...">
+                  <Component shouldSuspend={true} />
+                </React.Suspense>,
+              ),
+            ),
+          );
+
+          testMarks.push(...createUserTimingData(clearedMarks));
+
+          let data;
+          await utils.actAsync(async () => {
+            data = await preprocessData(testMarks);
+          });
+          expect(data.suspenseEvents).toHaveLength(1);
+          expect(data.suspenseEvents[0].warning).toBe(null);
+        });
+      });
+    });
+
+    // TODO: Add test for snapshot base64 parsing
+
+    // TODO: Add test for flamechart parsing
+  });
+});
diff --git a/packages/react-devtools-shared/src/__tests__/setupTests.js b/packages/react-devtools-shared/src/__tests__/setupTests.js
index 4224bde3b97d1..c2ce9184adc90 100644
--- a/packages/react-devtools-shared/src/__tests__/setupTests.js
+++ b/packages/react-devtools-shared/src/__tests__/setupTests.js
@@ -162,3 +162,7 @@ env.afterEach(() => {
   // so that we don't disconnect the ReactCurrentDispatcher ref.
   jest.resetModules();
 });
+
+expect.extend({
+  ...require('../../../../scripts/jest/matchers/schedulerTestMatchers'),
+});
diff --git a/packages/react-devtools-shared/src/__tests__/utils.js b/packages/react-devtools-shared/src/__tests__/utils.js
index 10a96598d573e..03228ea594a0a 100644
--- a/packages/react-devtools-shared/src/__tests__/utils.js
+++ b/packages/react-devtools-shared/src/__tests__/utils.js
@@ -163,6 +163,10 @@ export function getRendererID(): number {
 }
 
 export function legacyRender(elements, container) {
+  if (container == null) {
+    container = document.createElement('div');
+  }
+
   const ReactDOM = require('react-dom');
   withErrorsOrWarningsIgnored(
     ['ReactDOM.render is no longer supported in React 18'],
@@ -170,6 +174,10 @@ export function legacyRender(elements, container) {
       ReactDOM.render(elements, container);
     },
   );
+
+  return () => {
+    ReactDOM.unmountComponentAtNode(container);
+  };
 }
 
 export function requireTestRenderer(): ReactTestRenderer {
diff --git a/packages/react-devtools-shared/src/backend/profilingHooks.js b/packages/react-devtools-shared/src/backend/profilingHooks.js
new file mode 100644
index 0000000000000..9544b72511f6a
--- /dev/null
+++ b/packages/react-devtools-shared/src/backend/profilingHooks.js
@@ -0,0 +1,364 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+import type {
+  Lane,
+  Lanes,
+  DevToolsProfilingHooks,
+} from 'react-devtools-shared/src/backend/types';
+import type {Fiber} from 'react-reconciler/src/ReactInternalTypes';
+import type {Wakeable} from 'shared/ReactTypes';
+
+import isArray from 'shared/isArray';
+import {SCHEDULING_PROFILER_VERSION} from 'react-devtools-timeline/src/constants';
+
+let performanceTarget: Performance | null = null;
+
+// If performance exists and supports the subset of the User Timing API that we require.
+let supportsUserTiming =
+  typeof performance !== 'undefined' &&
+  typeof performance.mark === 'function' &&
+  typeof performance.clearMarks === 'function';
+
+let supportsUserTimingV3 = false;
+if (supportsUserTiming) {
+  const CHECK_V3_MARK = '__v3';
+  const markOptions = {};
+  // $FlowFixMe: Ignore Flow complaining about needing a value
+  Object.defineProperty(markOptions, 'startTime', {
+    get: function() {
+      supportsUserTimingV3 = true;
+      return 0;
+    },
+    set: function() {},
+  });
+
+  try {
+    // $FlowFixMe: Flow expects the User Timing level 2 API.
+    performance.mark(CHECK_V3_MARK, markOptions);
+  } catch (error) {
+    // Ignore
+  } finally {
+    performance.clearMarks(CHECK_V3_MARK);
+  }
+}
+
+if (supportsUserTimingV3) {
+  performanceTarget = performance;
+}
+
+// Mocking the Performance Object (and User Timing APIs) for testing is fragile.
+// This API allows tests to directly override the User Timing APIs.
+export function setPerformanceMock_ONLY_FOR_TESTING(
+  performanceMock: Performance | null,
+) {
+  performanceTarget = performanceMock;
+  supportsUserTiming = performanceMock !== null;
+  supportsUserTimingV3 = performanceMock !== null;
+}
+
+function markAndClear(markName) {
+  // This method won't be called unless these functions are defined, so we can skip the extra typeof check.
+  ((performanceTarget: any): Performance).mark(markName);
+  ((performanceTarget: any): Performance).clearMarks(markName);
+}
+
+export function createProfilingHooks({
+  getDisplayNameForFiber,
+  getLaneLabelMap,
+  reactVersion,
+}: {|
+  getDisplayNameForFiber: (fiber: Fiber) => string | null,
+  getLaneLabelMap?: () => Map<Lane, string>,
+  reactVersion: string,
+|}): DevToolsProfilingHooks {
+  function markMetadata() {
+    markAndClear(`--react-version-${reactVersion}`);
+    markAndClear(`--profiler-version-${SCHEDULING_PROFILER_VERSION}`);
+
+    /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+    if (
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges ===
+        'function'
+    ) {
+      // Ask the DevTools hook for module ranges that may have been reported by the current renderer(s).
+      const ranges = __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges();
+
+      // This check would not be required,
+      // except that it's possible for things to override __REACT_DEVTOOLS_GLOBAL_HOOK__.
+      if (isArray(ranges)) {
+        for (let i = 0; i < ranges.length; i++) {
+          const range = ranges[i];
+          if (isArray(range) && range.length === 2) {
+            const [startStackFrame, stopStackFrame] = ranges[i];
+
+            markAndClear(`--react-internal-module-start-${startStackFrame}`);
+            markAndClear(`--react-internal-module-stop-${stopStackFrame}`);
+          }
+        }
+      }
+    }
+
+    if (typeof getLaneLabelMap === 'function') {
+      const map = getLaneLabelMap();
+      const labels = Array.from(map.values()).join(',');
+      markAndClear(`--react-lane-labels-${labels}`);
+    }
+  }
+
+  function markCommitStarted(lanes: Lanes): void {
+    if (supportsUserTimingV3) {
+      markAndClear(`--commit-start-${lanes}`);
+
+      // Certain types of metadata should be logged infrequently.
+      // Normally we would log this during module init,
+      // but there's no guarantee a user is profiling at that time.
+      // Commits happen infrequently (less than renders or state updates)
+      // so we log this extra information along with a commit.
+      // It will likely be logged more than once but that's okay.
+      //
+      // TODO (timeline) Only log this once, when profiling starts.
+      // For the first phase– refactoring– we'll match the previous behavior.
+      markMetadata();
+    }
+  }
+
+  function markCommitStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--commit-stop');
+    }
+  }
+
+  function markComponentRenderStarted(fiber: Fiber): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--component-render-start-${componentName}`);
+    }
+  }
+
+  function markComponentRenderStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--component-render-stop');
+    }
+  }
+
+  function markComponentPassiveEffectMountStarted(fiber: Fiber): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--component-passive-effect-mount-start-${componentName}`);
+    }
+  }
+
+  function markComponentPassiveEffectMountStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--component-passive-effect-mount-stop');
+    }
+  }
+
+  function markComponentPassiveEffectUnmountStarted(fiber: Fiber): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--component-passive-effect-unmount-start-${componentName}`);
+    }
+  }
+
+  function markComponentPassiveEffectUnmountStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--component-passive-effect-unmount-stop');
+    }
+  }
+
+  function markComponentLayoutEffectMountStarted(fiber: Fiber): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--component-layout-effect-mount-start-${componentName}`);
+    }
+  }
+
+  function markComponentLayoutEffectMountStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--component-layout-effect-mount-stop');
+    }
+  }
+
+  function markComponentLayoutEffectUnmountStarted(fiber: Fiber): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--component-layout-effect-unmount-start-${componentName}`);
+    }
+  }
+
+  function markComponentLayoutEffectUnmountStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--component-layout-effect-unmount-stop');
+    }
+  }
+
+  function markComponentErrored(
+    fiber: Fiber,
+    thrownValue: mixed,
+    lanes: Lanes,
+  ): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      const phase = fiber.alternate === null ? 'mount' : 'update';
+
+      let message = '';
+      if (
+        thrownValue !== null &&
+        typeof thrownValue === 'object' &&
+        typeof thrownValue.message === 'string'
+      ) {
+        message = thrownValue.message;
+      } else if (typeof thrownValue === 'string') {
+        message = thrownValue;
+      }
+
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--error-${componentName}-${phase}-${message}`);
+    }
+  }
+
+  const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+
+  // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
+  const wakeableIDs: WeakMap<Wakeable, number> = new PossiblyWeakMap();
+  let wakeableID: number = 0;
+  function getWakeableID(wakeable: Wakeable): number {
+    if (!wakeableIDs.has(wakeable)) {
+      wakeableIDs.set(wakeable, wakeableID++);
+    }
+    return ((wakeableIDs.get(wakeable): any): number);
+  }
+
+  function markComponentSuspended(
+    fiber: Fiber,
+    wakeable: Wakeable,
+    lanes: Lanes,
+  ): void {
+    if (supportsUserTimingV3) {
+      const eventType = wakeableIDs.has(wakeable) ? 'resuspend' : 'suspend';
+      const id = getWakeableID(wakeable);
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      const phase = fiber.alternate === null ? 'mount' : 'update';
+
+      // Following the non-standard fn.displayName convention,
+      // frameworks like Relay may also annotate Promises with a displayName,
+      // describing what operation/data the thrown Promise is related to.
+      // When this is available we should pass it along to the Timeline.
+      const displayName = (wakeable: any).displayName || '';
+
+      // TODO (timeline) Record and cache component stack
+      markAndClear(
+        `--suspense-${eventType}-${id}-${componentName}-${phase}-${lanes}-${displayName}`,
+      );
+      wakeable.then(
+        () => markAndClear(`--suspense-resolved-${id}-${componentName}`),
+        () => markAndClear(`--suspense-rejected-${id}-${componentName}`),
+      );
+    }
+  }
+
+  function markLayoutEffectsStarted(lanes: Lanes): void {
+    if (supportsUserTimingV3) {
+      markAndClear(`--layout-effects-start-${lanes}`);
+    }
+  }
+
+  function markLayoutEffectsStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--layout-effects-stop');
+    }
+  }
+
+  function markPassiveEffectsStarted(lanes: Lanes): void {
+    if (supportsUserTimingV3) {
+      markAndClear(`--passive-effects-start-${lanes}`);
+    }
+  }
+
+  function markPassiveEffectsStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--passive-effects-stop');
+    }
+  }
+
+  function markRenderStarted(lanes: Lanes): void {
+    if (supportsUserTimingV3) {
+      markAndClear(`--render-start-${lanes}`);
+    }
+  }
+
+  function markRenderYielded(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--render-yield');
+    }
+  }
+
+  function markRenderStopped(): void {
+    if (supportsUserTimingV3) {
+      markAndClear('--render-stop');
+    }
+  }
+
+  function markRenderScheduled(lane: Lane): void {
+    if (supportsUserTimingV3) {
+      markAndClear(`--schedule-render-${lane}`);
+    }
+  }
+
+  function markForceUpdateScheduled(fiber: Fiber, lane: Lane): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--schedule-forced-update-${lane}-${componentName}`);
+    }
+  }
+
+  function markStateUpdateScheduled(fiber: Fiber, lane: Lane): void {
+    if (supportsUserTimingV3) {
+      const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+      // TODO (timeline) Record and cache component stack
+      markAndClear(`--schedule-state-update-${lane}-${componentName}`);
+    }
+  }
+
+  return {
+    markCommitStarted,
+    markCommitStopped,
+    markComponentRenderStarted,
+    markComponentRenderStopped,
+    markComponentPassiveEffectMountStarted,
+    markComponentPassiveEffectMountStopped,
+    markComponentPassiveEffectUnmountStarted,
+    markComponentPassiveEffectUnmountStopped,
+    markComponentLayoutEffectMountStarted,
+    markComponentLayoutEffectMountStopped,
+    markComponentLayoutEffectUnmountStarted,
+    markComponentLayoutEffectUnmountStopped,
+    markComponentErrored,
+    markComponentSuspended,
+    markLayoutEffectsStarted,
+    markLayoutEffectsStopped,
+    markPassiveEffectsStarted,
+    markPassiveEffectsStopped,
+    markRenderStarted,
+    markRenderYielded,
+    markRenderStopped,
+    markRenderScheduled,
+    markForceUpdateScheduled,
+    markStateUpdateScheduled,
+  };
+}
diff --git a/packages/react-devtools-shared/src/backend/renderer.js b/packages/react-devtools-shared/src/backend/renderer.js
index 631521791a549..daa4d4e1030c3 100644
--- a/packages/react-devtools-shared/src/backend/renderer.js
+++ b/packages/react-devtools-shared/src/backend/renderer.js
@@ -92,6 +92,7 @@ import is from 'shared/objectIs';
 import isArray from 'shared/isArray';
 import hasOwnProperty from 'shared/hasOwnProperty';
 import {getStyleXData} from './StyleX/utils';
+import {createProfilingHooks} from './profilingHooks';
 
 import type {Fiber} from 'react-reconciler/src/ReactInternalTypes';
 import type {
@@ -590,6 +591,8 @@ export function attach(
   } = ReactPriorityLevels;
 
   const {
+    getLaneLabelMap,
+    injectProfilingHooks,
     overrideHookState,
     overrideHookStateDeletePath,
     overrideHookStateRenamePath,
@@ -624,6 +627,16 @@ export function attach(
     };
   }
 
+  if (typeof injectProfilingHooks === 'function') {
+    injectProfilingHooks(
+      createProfilingHooks({
+        getDisplayNameForFiber,
+        getLaneLabelMap,
+        reactVersion: version,
+      }),
+    );
+  }
+
   // Tracks Fibers with recently changed number of error/warning messages.
   // These collections store the Fiber rather than the ID,
   // in order to avoid generating an ID for Fibers that never get mounted
diff --git a/packages/react-devtools-shared/src/backend/types.js b/packages/react-devtools-shared/src/backend/types.js
index 3318c8b6a965e..b751882396955 100644
--- a/packages/react-devtools-shared/src/backend/types.js
+++ b/packages/react-devtools-shared/src/backend/types.js
@@ -7,7 +7,7 @@
  * @flow
  */
 
-import type {ReactContext} from 'shared/ReactTypes';
+import type {ReactContext, Wakeable} from 'shared/ReactTypes';
 import type {Source} from 'shared/ReactElementType';
 import type {Fiber} from 'react-reconciler/src/ReactInternalTypes';
 import type {
@@ -87,6 +87,9 @@ export type ReactProviderType<T> = {
   ...
 };
 
+export type Lane = number;
+export type Lanes = number;
+
 export type ReactRenderer = {
   findFiberByHostInstance: (hostInstance: NativeType) => ?Fiber,
   version: string,
@@ -147,6 +150,9 @@ export type ReactRenderer = {
   setErrorHandler?: ?(shouldError: (fiber: Object) => ?boolean) => void,
   // Intentionally opaque type to avoid coupling DevTools to different Fast Refresh versions.
   scheduleRefresh?: Function,
+  // 18.0+
+  injectProfilingHooks?: (profilingHooks: DevToolsProfilingHooks) => void,
+  getLaneLabelMap?: () => Map<Lane, string>,
   ...
 };
 
@@ -390,11 +396,56 @@ export type RendererInterface = {
   ) => void,
   unpatchConsoleForStrictMode: () => void,
   updateComponentFilters: (componentFilters: Array<ComponentFilter>) => void,
+
+  // Timeline profiler interface
+
   ...
 };
 
 export type Handler = (data: any) => void;
 
+// Renderers use these APIs to report profiling data to DevTools at runtime.
+// They get passed from the DevTools backend to the reconciler during injection.
+export type DevToolsProfilingHooks = {|
+  // Scheduling methods:
+  markRenderScheduled: (lane: Lane) => void,
+  markStateUpdateScheduled: (fiber: Fiber, lane: Lane) => void,
+  markForceUpdateScheduled: (fiber: Fiber, lane: Lane) => void,
+
+  // Work loop level methods:
+  markRenderStarted: (lanes: Lanes) => void,
+  markRenderYielded: () => void,
+  markRenderStopped: () => void,
+  markCommitStarted: (lanes: Lanes) => void,
+  markCommitStopped: () => void,
+  markLayoutEffectsStarted: (lanes: Lanes) => void,
+  markLayoutEffectsStopped: () => void,
+  markPassiveEffectsStarted: (lanes: Lanes) => void,
+  markPassiveEffectsStopped: () => void,
+
+  // Fiber level methods:
+  markComponentRenderStarted: (fiber: Fiber) => void,
+  markComponentRenderStopped: () => void,
+  markComponentErrored: (
+    fiber: Fiber,
+    thrownValue: mixed,
+    lanes: Lanes,
+  ) => void,
+  markComponentSuspended: (
+    fiber: Fiber,
+    wakeable: Wakeable,
+    lanes: Lanes,
+  ) => void,
+  markComponentLayoutEffectMountStarted: (fiber: Fiber) => void,
+  markComponentLayoutEffectMountStopped: () => void,
+  markComponentLayoutEffectUnmountStarted: (fiber: Fiber) => void,
+  markComponentLayoutEffectUnmountStopped: () => void,
+  markComponentPassiveEffectMountStarted: (fiber: Fiber) => void,
+  markComponentPassiveEffectMountStopped: () => void,
+  markComponentPassiveEffectUnmountStarted: (fiber: Fiber) => void,
+  markComponentPassiveEffectUnmountStopped: () => void,
+|};
+
 export type DevToolsHook = {
   listeners: {[key: string]: Array<Handler>, ...},
   rendererInterfaces: Map<RendererID, RendererInterface>,
@@ -431,5 +482,6 @@ export type DevToolsHook = {
 
   // Testing
   dangerous_setTargetConsoleForTesting?: (fakeConsole: Object) => void,
+
   ...
 };
diff --git a/packages/react-devtools-shared/src/hook.js b/packages/react-devtools-shared/src/hook.js
index e265212e31c42..5844074863bf5 100644
--- a/packages/react-devtools-shared/src/hook.js
+++ b/packages/react-devtools-shared/src/hook.js
@@ -9,14 +9,13 @@
  */
 
 import type {BrowserTheme} from 'react-devtools-shared/src/devtools/views/DevTools';
+import type {DevToolsHook} from 'react-devtools-shared/src/backend/types';
 
 import {
   patch as patchConsole,
   registerRenderer as registerRendererWithConsole,
 } from './backend/console';
 
-import type {DevToolsHook} from 'react-devtools-shared/src/backend/types';
-
 declare var window: any;
 
 export function installHook(target: any): DevToolsHook | null {
diff --git a/packages/react-devtools-timeline/src/import-worker/__tests__/preprocessData-test.internal.js b/packages/react-devtools-timeline/src/import-worker/__tests__/preprocessData-test.internal.js
deleted file mode 100644
index f902ddc57e14e..0000000000000
--- a/packages/react-devtools-timeline/src/import-worker/__tests__/preprocessData-test.internal.js
+++ /dev/null
@@ -1,1915 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-'use strict';
-
-import {getLaneLabels} from 'react-reconciler/src/SchedulingProfiler';
-import preprocessData, {
-  getLanesFromTransportDecimalBitmask,
-} from '../preprocessData';
-import {
-  REACT_TOTAL_NUM_LANES,
-  SCHEDULING_PROFILER_VERSION,
-} from '../../constants';
-import REACT_VERSION from 'shared/ReactVersion';
-
-describe('getLanesFromTransportDecimalBitmask', () => {
-  it('should return array of lane numbers from bitmask string', () => {
-    expect(getLanesFromTransportDecimalBitmask('1')).toEqual([0]);
-    expect(getLanesFromTransportDecimalBitmask('512')).toEqual([9]);
-    expect(getLanesFromTransportDecimalBitmask('3')).toEqual([0, 1]);
-    expect(getLanesFromTransportDecimalBitmask('1234')).toEqual([
-      1,
-      4,
-      6,
-      7,
-      10,
-    ]); // 2 + 16 + 64 + 128 + 1024
-    expect(
-      getLanesFromTransportDecimalBitmask('1073741824'), // 0b1000000000000000000000000000000
-    ).toEqual([30]);
-    expect(
-      getLanesFromTransportDecimalBitmask('2147483647'), // 0b1111111111111111111111111111111
-    ).toEqual(Array.from(Array(31).keys()));
-  });
-
-  it('should return empty array if laneBitmaskString is not a bitmask', () => {
-    expect(getLanesFromTransportDecimalBitmask('')).toEqual([]);
-    expect(getLanesFromTransportDecimalBitmask('hello')).toEqual([]);
-    expect(getLanesFromTransportDecimalBitmask('-1')).toEqual([]);
-    expect(getLanesFromTransportDecimalBitmask('-0')).toEqual([]);
-  });
-
-  it('should ignore lanes outside REACT_TOTAL_NUM_LANES', () => {
-    // Sanity check; this test may need to be updated when the no. of fiber
-    // lanes are changed.
-    expect(REACT_TOTAL_NUM_LANES).toBe(31);
-
-    expect(
-      getLanesFromTransportDecimalBitmask(
-        '4294967297', // 2^32 + 1
-      ),
-    ).toEqual([0]);
-  });
-});
-
-describe('preprocessData', () => {
-  let React;
-  let ReactDOM;
-  let Scheduler;
-
-  let act;
-  let clearedMarks;
-  let featureDetectionMarkName = null;
-  let marks;
-
-  function polyfillJSDomUserTiming() {
-    featureDetectionMarkName = null;
-
-    clearedMarks = [];
-    marks = [];
-
-    // This is not a true polyfill, but it gives us enough to capture marks.
-    // Reference: https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
-
-    // JSDom already implements global.performance and it can't be overridden.
-    // However it only supports now() and timeOrigin() so we need to "upgrade it" in place.
-
-    if (!global.performance) {
-      global.performance = {};
-    }
-
-    global.performance.clearMarks = function clearMarks(markName) {
-      clearedMarks.push(markName);
-      marks = marks.filter(mark => mark !== markName);
-    };
-
-    global.performance.mark = function mark(markName, markOptions) {
-      if (featureDetectionMarkName === null) {
-        featureDetectionMarkName = markName;
-      }
-      marks.push(markName);
-      if (markOptions != null) {
-        // This is triggers the feature detection.
-        markOptions.startTime++;
-      }
-    };
-  }
-
-  // These should be dynamic to mimic a real profile,
-  // but reprooducible between test runs.
-  let pid = 0;
-  let tid = 0;
-  let startTime = 0;
-
-  function createUserTimingEntry(data) {
-    return {
-      pid: ++pid,
-      tid: ++tid,
-      ts: ++startTime,
-      ...data,
-    };
-  }
-
-  function createProfilerVersionEntry() {
-    return createUserTimingEntry({
-      cat: 'blink.user_timing',
-      name: '--profiler-version-' + SCHEDULING_PROFILER_VERSION,
-    });
-  }
-
-  function createReactVersionEntry() {
-    return createUserTimingEntry({
-      cat: 'blink.user_timing',
-      name: '--react-version-' + REACT_VERSION,
-    });
-  }
-
-  function createLaneLabelsEntry() {
-    return createUserTimingEntry({
-      cat: 'blink.user_timing',
-      name: '--react-lane-labels-' + getLaneLabels().join(','),
-    });
-  }
-
-  function createNativeEventEntry(type, duration) {
-    return createUserTimingEntry({
-      cat: 'devtools.timeline',
-      name: 'EventDispatch',
-      args: {data: {type}},
-      dur: duration,
-      tdur: duration,
-    });
-  }
-
-  function creactCpuProfilerSample() {
-    return createUserTimingEntry({
-      args: {data: {startTime: ++startTime}},
-      cat: 'disabled-by-default-v8.cpu_profiler',
-      id: '0x1',
-      name: 'Profile',
-      ph: 'P',
-    });
-  }
-
-  function createBoilerplateEntries() {
-    return [
-      createProfilerVersionEntry(),
-      createReactVersionEntry(),
-      createLaneLabelsEntry(),
-    ];
-  }
-
-  function createUserTimingData(sampleMarks) {
-    const cpuProfilerSample = creactCpuProfilerSample();
-
-    const randomSample = createUserTimingEntry({
-      dur: 100,
-      tdur: 200,
-      ph: 'X',
-      cat: 'disabled-by-default-devtools.timeline',
-      name: 'RunTask',
-      args: {},
-    });
-
-    const userTimingData = [cpuProfilerSample, randomSample];
-
-    sampleMarks.forEach(markName => {
-      userTimingData.push({
-        pid: ++pid,
-        tid: ++tid,
-        ts: ++startTime,
-        args: {data: {}},
-        cat: 'blink.user_timing',
-        name: markName,
-        ph: 'R',
-      });
-    });
-
-    return userTimingData;
-  }
-
-  beforeEach(() => {
-    jest.resetModules();
-
-    polyfillJSDomUserTiming();
-
-    React = require('react');
-    ReactDOM = require('react-dom');
-    Scheduler = require('scheduler');
-
-    const TestUtils = require('react-dom/test-utils');
-    act = TestUtils.act;
-
-    tid = 0;
-    pid = 0;
-    startTime = 0;
-
-    global.IS_REACT_ACT_ENVIRONMENT = true;
-  });
-
-  afterEach(() => {
-    // Verify all logged marks also get cleared.
-    expect(marks).toHaveLength(0);
-
-    delete global.performance;
-  });
-
-  it('should throw given an empty timeline', async () => {
-    await expect(async () => preprocessData([])).rejects.toThrow();
-  });
-
-  it('should throw given a timeline with no Profile event', async () => {
-    const randomSample = createUserTimingEntry({
-      dur: 100,
-      tdur: 200,
-      ph: 'X',
-      cat: 'disabled-by-default-devtools.timeline',
-      name: 'RunTask',
-      args: {},
-    });
-
-    await expect(async () => preprocessData([randomSample])).rejects.toThrow();
-  });
-
-  it('should throw given a timeline without an explicit profiler version mark nor any other React marks', async () => {
-    const cpuProfilerSample = creactCpuProfilerSample();
-
-    await expect(
-      async () => await preprocessData([cpuProfilerSample]),
-    ).rejects.toThrow(
-      'Please provide profiling data from an React application',
-    );
-  });
-
-  it('should throw given a timeline with React scheduling marks, but without an explicit profiler version mark', async () => {
-    const cpuProfilerSample = creactCpuProfilerSample();
-    const scheduleRenderSample = createUserTimingEntry({
-      cat: 'blink.user_timing',
-      name: '--schedule-render-512-',
-    });
-    const samples = [cpuProfilerSample, scheduleRenderSample];
-
-    await expect(async () => await preprocessData(samples)).rejects.toThrow(
-      'This version of profiling data is not supported',
-    );
-  });
-
-  it('should return empty data given a timeline with no React scheduling profiling marks', async () => {
-    const cpuProfilerSample = creactCpuProfilerSample();
-    const randomSample = createUserTimingEntry({
-      dur: 100,
-      tdur: 200,
-      ph: 'X',
-      cat: 'disabled-by-default-devtools.timeline',
-      name: 'RunTask',
-      args: {},
-    });
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      const data = await preprocessData([
-        ...createBoilerplateEntries(),
-        cpuProfilerSample,
-        randomSample,
-      ]);
-      expect(data).toMatchInlineSnapshot(`
-        Object {
-          "batchUIDToMeasuresMap": Map {},
-          "componentMeasures": Array [],
-          "duration": 0.005,
-          "flamechart": Array [],
-          "internalModuleSourceToRanges": Map {},
-          "laneToLabelMap": Map {
-            0 => "Sync",
-            1 => "InputContinuousHydration",
-            2 => "InputContinuous",
-            3 => "DefaultHydration",
-            4 => "Default",
-            5 => "TransitionHydration",
-            6 => "Transition",
-            7 => "Transition",
-            8 => "Transition",
-            9 => "Transition",
-            10 => "Transition",
-            11 => "Transition",
-            12 => "Transition",
-            13 => "Transition",
-            14 => "Transition",
-            15 => "Transition",
-            16 => "Transition",
-            17 => "Transition",
-            18 => "Transition",
-            19 => "Transition",
-            20 => "Transition",
-            21 => "Transition",
-            22 => "Retry",
-            23 => "Retry",
-            24 => "Retry",
-            25 => "Retry",
-            26 => "Retry",
-            27 => "SelectiveHydration",
-            28 => "IdleHydration",
-            29 => "Idle",
-            30 => "Offscreen",
-          },
-          "laneToReactMeasureMap": Map {
-            0 => Array [],
-            1 => Array [],
-            2 => Array [],
-            3 => Array [],
-            4 => Array [],
-            5 => Array [],
-            6 => Array [],
-            7 => Array [],
-            8 => Array [],
-            9 => Array [],
-            10 => Array [],
-            11 => Array [],
-            12 => Array [],
-            13 => Array [],
-            14 => Array [],
-            15 => Array [],
-            16 => Array [],
-            17 => Array [],
-            18 => Array [],
-            19 => Array [],
-            20 => Array [],
-            21 => Array [],
-            22 => Array [],
-            23 => Array [],
-            24 => Array [],
-            25 => Array [],
-            26 => Array [],
-            27 => Array [],
-            28 => Array [],
-            29 => Array [],
-            30 => Array [],
-          },
-          "nativeEvents": Array [],
-          "networkMeasures": Array [],
-          "otherUserTimingMarks": Array [],
-          "reactVersion": "17.0.3",
-          "schedulingEvents": Array [],
-          "snapshotHeight": 0,
-          "snapshots": Array [],
-          "startTime": 1,
-          "suspenseEvents": Array [],
-          "thrownErrors": Array [],
-        }
-      `);
-    }
-  });
-
-  it('should process legacy data format (before lane labels were added)', async () => {
-    const cpuProfilerSample = creactCpuProfilerSample();
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      // Data below is hard-coded based on an older profile sample.
-      // Should be fine since this is explicitly a legacy-format test.
-      const data = await preprocessData([
-        ...createBoilerplateEntries(),
-        cpuProfilerSample,
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--schedule-render-512-',
-        }),
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--render-start-512',
-        }),
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--render-stop',
-        }),
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--commit-start-512',
-        }),
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--layout-effects-start-512',
-        }),
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--layout-effects-stop',
-        }),
-        createUserTimingEntry({
-          cat: 'blink.user_timing',
-          name: '--commit-stop',
-        }),
-      ]);
-      expect(data).toMatchInlineSnapshot(`
-        Object {
-          "batchUIDToMeasuresMap": Map {
-            0 => Array [
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.004999999999999999,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.006,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.001,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.006,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.002999999999999999,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.008,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 1,
-                "duration": 0.0010000000000000009,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.009,
-                "type": "layout-effects",
-              },
-            ],
-          },
-          "componentMeasures": Array [],
-          "duration": 0.011,
-          "flamechart": Array [],
-          "internalModuleSourceToRanges": Map {},
-          "laneToLabelMap": Map {
-            0 => "Sync",
-            1 => "InputContinuousHydration",
-            2 => "InputContinuous",
-            3 => "DefaultHydration",
-            4 => "Default",
-            5 => "TransitionHydration",
-            6 => "Transition",
-            7 => "Transition",
-            8 => "Transition",
-            9 => "Transition",
-            10 => "Transition",
-            11 => "Transition",
-            12 => "Transition",
-            13 => "Transition",
-            14 => "Transition",
-            15 => "Transition",
-            16 => "Transition",
-            17 => "Transition",
-            18 => "Transition",
-            19 => "Transition",
-            20 => "Transition",
-            21 => "Transition",
-            22 => "Retry",
-            23 => "Retry",
-            24 => "Retry",
-            25 => "Retry",
-            26 => "Retry",
-            27 => "SelectiveHydration",
-            28 => "IdleHydration",
-            29 => "Idle",
-            30 => "Offscreen",
-          },
-          "laneToReactMeasureMap": Map {
-            0 => Array [],
-            1 => Array [],
-            2 => Array [],
-            3 => Array [],
-            4 => Array [],
-            5 => Array [],
-            6 => Array [],
-            7 => Array [],
-            8 => Array [],
-            9 => Array [
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.004999999999999999,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.006,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.001,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.006,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.002999999999999999,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.008,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 1,
-                "duration": 0.0010000000000000009,
-                "lanes": Array [
-                  9,
-                ],
-                "timestamp": 0.009,
-                "type": "layout-effects",
-              },
-            ],
-            10 => Array [],
-            11 => Array [],
-            12 => Array [],
-            13 => Array [],
-            14 => Array [],
-            15 => Array [],
-            16 => Array [],
-            17 => Array [],
-            18 => Array [],
-            19 => Array [],
-            20 => Array [],
-            21 => Array [],
-            22 => Array [],
-            23 => Array [],
-            24 => Array [],
-            25 => Array [],
-            26 => Array [],
-            27 => Array [],
-            28 => Array [],
-            29 => Array [],
-            30 => Array [],
-          },
-          "nativeEvents": Array [],
-          "networkMeasures": Array [],
-          "otherUserTimingMarks": Array [],
-          "reactVersion": "17.0.3",
-          "schedulingEvents": Array [
-            Object {
-              "lanes": Array [
-                9,
-              ],
-              "timestamp": 0.005,
-              "type": "schedule-render",
-              "warning": null,
-            },
-          ],
-          "snapshotHeight": 0,
-          "snapshots": Array [],
-          "startTime": 1,
-          "suspenseEvents": Array [],
-          "thrownErrors": Array [],
-        }
-      `);
-    }
-  });
-
-  it('should process a sample legacy render sequence', async () => {
-    ReactDOM.render(<div />, document.createElement('div'));
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      const data = await preprocessData([
-        ...createBoilerplateEntries(),
-        ...createUserTimingData(clearedMarks),
-      ]);
-      expect(data).toMatchInlineSnapshot(`
-        Object {
-          "batchUIDToMeasuresMap": Map {
-            0 => Array [
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.008,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.005,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.001,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.005,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.005999999999999999,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.007,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 1,
-                "duration": 0.0010000000000000009,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.011,
-                "type": "layout-effects",
-              },
-            ],
-          },
-          "componentMeasures": Array [],
-          "duration": 0.013,
-          "flamechart": Array [],
-          "internalModuleSourceToRanges": Map {},
-          "laneToLabelMap": Map {
-            0 => "Sync",
-            1 => "InputContinuousHydration",
-            2 => "InputContinuous",
-            3 => "DefaultHydration",
-            4 => "Default",
-            5 => "TransitionHydration",
-            6 => "Transition",
-            7 => "Transition",
-            8 => "Transition",
-            9 => "Transition",
-            10 => "Transition",
-            11 => "Transition",
-            12 => "Transition",
-            13 => "Transition",
-            14 => "Transition",
-            15 => "Transition",
-            16 => "Transition",
-            17 => "Transition",
-            18 => "Transition",
-            19 => "Transition",
-            20 => "Transition",
-            21 => "Transition",
-            22 => "Retry",
-            23 => "Retry",
-            24 => "Retry",
-            25 => "Retry",
-            26 => "Retry",
-            27 => "SelectiveHydration",
-            28 => "IdleHydration",
-            29 => "Idle",
-            30 => "Offscreen",
-          },
-          "laneToReactMeasureMap": Map {
-            0 => Array [
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.008,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.005,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.001,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.005,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.005999999999999999,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.007,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 1,
-                "duration": 0.0010000000000000009,
-                "lanes": Array [
-                  0,
-                ],
-                "timestamp": 0.011,
-                "type": "layout-effects",
-              },
-            ],
-            1 => Array [],
-            2 => Array [],
-            3 => Array [],
-            4 => Array [],
-            5 => Array [],
-            6 => Array [],
-            7 => Array [],
-            8 => Array [],
-            9 => Array [],
-            10 => Array [],
-            11 => Array [],
-            12 => Array [],
-            13 => Array [],
-            14 => Array [],
-            15 => Array [],
-            16 => Array [],
-            17 => Array [],
-            18 => Array [],
-            19 => Array [],
-            20 => Array [],
-            21 => Array [],
-            22 => Array [],
-            23 => Array [],
-            24 => Array [],
-            25 => Array [],
-            26 => Array [],
-            27 => Array [],
-            28 => Array [],
-            29 => Array [],
-            30 => Array [],
-          },
-          "nativeEvents": Array [],
-          "networkMeasures": Array [],
-          "otherUserTimingMarks": Array [
-            Object {
-              "name": "__v3",
-              "timestamp": 0.003,
-            },
-          ],
-          "reactVersion": "17.0.3",
-          "schedulingEvents": Array [
-            Object {
-              "lanes": Array [
-                0,
-              ],
-              "timestamp": 0.004,
-              "type": "schedule-render",
-              "warning": null,
-            },
-          ],
-          "snapshotHeight": 0,
-          "snapshots": Array [],
-          "startTime": 4,
-          "suspenseEvents": Array [],
-          "thrownErrors": Array [],
-        }
-      `);
-    }
-  });
-
-  it('should process a sample createRoot render sequence', async () => {
-    function App() {
-      const [didMount, setDidMount] = React.useState(false);
-      React.useEffect(() => {
-        if (!didMount) {
-          setDidMount(true);
-        }
-      });
-      return true;
-    }
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      const root = ReactDOM.createRoot(document.createElement('div'));
-      act(() => root.render(<App />));
-
-      const data = await preprocessData([
-        ...createBoilerplateEntries(),
-        ...createUserTimingData(clearedMarks),
-      ]);
-      expect(data).toMatchInlineSnapshot(`
-        Object {
-          "batchUIDToMeasuresMap": Map {
-            0 => Array [
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.009999999999999998,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.005,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.003,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.005,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.006,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.009,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 1,
-                "duration": 0.0010000000000000009,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.013,
-                "type": "layout-effects",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.004,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.016,
-                "type": "passive-effects",
-              },
-            ],
-            1 => Array [
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.009999999999999998,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.021,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.002999999999999999,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.021,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.005999999999999998,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.025,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 1,
-                "duration": 0.0009999999999999974,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.029,
-                "type": "layout-effects",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.0030000000000000027,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.032,
-                "type": "passive-effects",
-              },
-            ],
-          },
-          "componentMeasures": Array [
-            Object {
-              "componentName": "App",
-              "duration": 0.001,
-              "timestamp": 0.006,
-              "type": "render",
-              "warning": null,
-            },
-            Object {
-              "componentName": "App",
-              "duration": 0.0019999999999999983,
-              "timestamp": 0.017,
-              "type": "passive-effect-mount",
-              "warning": null,
-            },
-            Object {
-              "componentName": "App",
-              "duration": 0.0010000000000000009,
-              "timestamp": 0.022,
-              "type": "render",
-              "warning": null,
-            },
-            Object {
-              "componentName": "App",
-              "duration": 0.0010000000000000009,
-              "timestamp": 0.033,
-              "type": "passive-effect-mount",
-              "warning": null,
-            },
-          ],
-          "duration": 0.035,
-          "flamechart": Array [],
-          "internalModuleSourceToRanges": Map {},
-          "laneToLabelMap": Map {
-            0 => "Sync",
-            1 => "InputContinuousHydration",
-            2 => "InputContinuous",
-            3 => "DefaultHydration",
-            4 => "Default",
-            5 => "TransitionHydration",
-            6 => "Transition",
-            7 => "Transition",
-            8 => "Transition",
-            9 => "Transition",
-            10 => "Transition",
-            11 => "Transition",
-            12 => "Transition",
-            13 => "Transition",
-            14 => "Transition",
-            15 => "Transition",
-            16 => "Transition",
-            17 => "Transition",
-            18 => "Transition",
-            19 => "Transition",
-            20 => "Transition",
-            21 => "Transition",
-            22 => "Retry",
-            23 => "Retry",
-            24 => "Retry",
-            25 => "Retry",
-            26 => "Retry",
-            27 => "SelectiveHydration",
-            28 => "IdleHydration",
-            29 => "Idle",
-            30 => "Offscreen",
-          },
-          "laneToReactMeasureMap": Map {
-            0 => Array [],
-            1 => Array [],
-            2 => Array [],
-            3 => Array [],
-            4 => Array [
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.009999999999999998,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.005,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.003,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.005,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.006,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.009,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 1,
-                "duration": 0.0010000000000000009,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.013,
-                "type": "layout-effects",
-              },
-              Object {
-                "batchUID": 0,
-                "depth": 0,
-                "duration": 0.004,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.016,
-                "type": "passive-effects",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.009999999999999998,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.021,
-                "type": "render-idle",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.002999999999999999,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.021,
-                "type": "render",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.005999999999999998,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.025,
-                "type": "commit",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 1,
-                "duration": 0.0009999999999999974,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.029,
-                "type": "layout-effects",
-              },
-              Object {
-                "batchUID": 1,
-                "depth": 0,
-                "duration": 0.0030000000000000027,
-                "lanes": Array [
-                  4,
-                ],
-                "timestamp": 0.032,
-                "type": "passive-effects",
-              },
-            ],
-            5 => Array [],
-            6 => Array [],
-            7 => Array [],
-            8 => Array [],
-            9 => Array [],
-            10 => Array [],
-            11 => Array [],
-            12 => Array [],
-            13 => Array [],
-            14 => Array [],
-            15 => Array [],
-            16 => Array [],
-            17 => Array [],
-            18 => Array [],
-            19 => Array [],
-            20 => Array [],
-            21 => Array [],
-            22 => Array [],
-            23 => Array [],
-            24 => Array [],
-            25 => Array [],
-            26 => Array [],
-            27 => Array [],
-            28 => Array [],
-            29 => Array [],
-            30 => Array [],
-          },
-          "nativeEvents": Array [],
-          "networkMeasures": Array [],
-          "otherUserTimingMarks": Array [
-            Object {
-              "name": "__v3",
-              "timestamp": 0.003,
-            },
-          ],
-          "reactVersion": "17.0.3",
-          "schedulingEvents": Array [
-            Object {
-              "lanes": Array [
-                4,
-              ],
-              "timestamp": 0.004,
-              "type": "schedule-render",
-              "warning": null,
-            },
-            Object {
-              "componentName": "App",
-              "lanes": Array [
-                4,
-              ],
-              "timestamp": 0.018,
-              "type": "schedule-state-update",
-              "warning": null,
-            },
-          ],
-          "snapshotHeight": 0,
-          "snapshots": Array [],
-          "startTime": 4,
-          "suspenseEvents": Array [],
-          "thrownErrors": Array [],
-        }
-      `);
-    }
-  });
-
-  // @gate enableSchedulingProfiler
-  it('should error if events and measures are incomplete', async () => {
-    const container = document.createElement('div');
-    ReactDOM.render(<div />, container);
-
-    const invalidMarks = clearedMarks.filter(
-      mark => !mark.includes('render-stop'),
-    );
-    const invalidUserTimingData = createUserTimingData(invalidMarks);
-
-    const error = spyOnDevAndProd(console, 'error');
-    preprocessData([...createBoilerplateEntries(), ...invalidUserTimingData]);
-    expect(error).toHaveBeenCalled();
-  });
-
-  // @gate enableSchedulingProfiler
-  it('should error if work is completed without being started', async () => {
-    const container = document.createElement('div');
-    ReactDOM.render(<div />, container);
-
-    const invalidMarks = clearedMarks.filter(
-      mark => !mark.includes('render-start'),
-    );
-    const invalidUserTimingData = createUserTimingData(invalidMarks);
-
-    const error = spyOnDevAndProd(console, 'error');
-    preprocessData([...createBoilerplateEntries(), ...invalidUserTimingData]);
-    expect(error).toHaveBeenCalled();
-  });
-
-  it('should populate other user timing marks', async () => {
-    const userTimingData = createUserTimingData([]);
-    userTimingData.push(
-      createUserTimingEntry({
-        args: {},
-        cat: 'blink.user_timing',
-        id: '0xcdf75f7c',
-        name: 'VCWithoutImage: root',
-        ph: 'n',
-        scope: 'blink.user_timing',
-      }),
-    );
-    userTimingData.push(
-      createUserTimingEntry({
-        cat: 'blink.user_timing',
-        name: '--a-mark-that-looks-like-one-of-ours',
-        ph: 'R',
-      }),
-    );
-    userTimingData.push(
-      createUserTimingEntry({
-        cat: 'blink.user_timing',
-        name: 'Some other mark',
-        ph: 'R',
-      }),
-    );
-
-    const data = await preprocessData([
-      ...createBoilerplateEntries(),
-      ...userTimingData,
-    ]);
-    expect(data.otherUserTimingMarks).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "name": "VCWithoutImage: root",
-          "timestamp": 0.003,
-        },
-        Object {
-          "name": "--a-mark-that-looks-like-one-of-ours",
-          "timestamp": 0.004,
-        },
-        Object {
-          "name": "Some other mark",
-          "timestamp": 0.005,
-        },
-      ]
-    `);
-  });
-
-  it('should include a suspended resource "displayName" if one is set', async () => {
-    let promise = null;
-    let resolvedValue = null;
-    function readValue(value) {
-      if (resolvedValue !== null) {
-        return resolvedValue;
-      } else if (promise === null) {
-        promise = Promise.resolve(true).then(() => {
-          resolvedValue = value;
-        });
-        promise.displayName = 'Testing displayName';
-      }
-      throw promise;
-    }
-
-    function Component() {
-      const value = readValue(123);
-      return value;
-    }
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      const testMarks = [creactCpuProfilerSample()];
-
-      const root = ReactDOM.createRoot(document.createElement('div'));
-      act(() =>
-        root.render(
-          <React.Suspense fallback="Loading...">
-            <Component />
-          </React.Suspense>,
-        ),
-      );
-
-      testMarks.push(...createUserTimingData(clearedMarks));
-
-      const data = await act(() => preprocessData(testMarks));
-      expect(data.suspenseEvents).toHaveLength(1);
-      expect(data.suspenseEvents[0].promiseName).toBe('Testing displayName');
-    }
-  });
-
-  describe('warnings', () => {
-    describe('long event handlers', () => {
-      it('should not warn when React scedules a (sync) update inside of a short event handler', async () => {
-        function App() {
-          return null;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const testMarks = [
-            creactCpuProfilerSample(),
-            ...createBoilerplateEntries(),
-            createNativeEventEntry('click', 5),
-          ];
-
-          clearedMarks.splice(0);
-
-          ReactDOM.render(<App />, document.createElement('div'));
-
-          testMarks.push(...createUserTimingData(clearedMarks));
-
-          const data = await preprocessData(testMarks);
-          const event = data.nativeEvents.find(({type}) => type === 'click');
-          expect(event.warning).toBe(null);
-        }
-      });
-
-      it('should not warn about long events if the cause was non-React JavaScript', async () => {
-        function App() {
-          return null;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const testMarks = [
-            creactCpuProfilerSample(),
-            ...createBoilerplateEntries(),
-            createNativeEventEntry('click', 25000),
-          ];
-
-          startTime += 2000;
-
-          clearedMarks.splice(0);
-
-          ReactDOM.render(<App />, document.createElement('div'));
-
-          testMarks.push(...createUserTimingData(clearedMarks));
-
-          const data = await preprocessData(testMarks);
-          const event = data.nativeEvents.find(({type}) => type === 'click');
-          expect(event.warning).toBe(null);
-        }
-      });
-
-      it('should warn when React scedules a long (sync) update inside of an event', async () => {
-        function App() {
-          return null;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const testMarks = [
-            creactCpuProfilerSample(),
-            ...createBoilerplateEntries(),
-            createNativeEventEntry('click', 25000),
-          ];
-
-          clearedMarks.splice(0);
-
-          ReactDOM.render(<App />, document.createElement('div'));
-
-          clearedMarks.forEach(markName => {
-            if (markName === '--render-stop') {
-              // Fake a long running render
-              startTime += 20000;
-            }
-
-            testMarks.push({
-              pid: ++pid,
-              tid: ++tid,
-              ts: ++startTime,
-              args: {data: {}},
-              cat: 'blink.user_timing',
-              name: markName,
-              ph: 'R',
-            });
-          });
-
-          const data = await preprocessData(testMarks);
-          const event = data.nativeEvents.find(({type}) => type === 'click');
-          expect(event.warning).toMatchInlineSnapshot(
-            `"An event handler scheduled a big update with React. Consider using the Transition API to defer some of this work."`,
-          );
-        }
-      });
-
-      it('should not warn when React finishes a previously long (async) update with a short (sync) update inside of an event', async () => {
-        function Yield({id, value}) {
-          Scheduler.unstable_yieldValue(`${id}:${value}`);
-          return null;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const testMarks = [
-            creactCpuProfilerSample(),
-            ...createBoilerplateEntries(),
-          ];
-
-          // Advance the clock by some arbitrary amount.
-          startTime += 50000;
-
-          const root = ReactDOM.createRoot(document.createElement('div'));
-
-          // Temporarily turn off the act environment, since we're intentionally using Scheduler instead.
-          global.IS_REACT_ACT_ENVIRONMENT = false;
-          React.startTransition(() => {
-            // Start rendering an async update (but don't finish).
-            root.render(
-              <>
-                <Yield id="A" value={1} />
-                <Yield id="B" value={1} />
-              </>,
-            );
-            expect(Scheduler).toFlushAndYieldThrough(['A:1']);
-
-            testMarks.push(...createUserTimingData(clearedMarks));
-            clearedMarks.splice(0);
-
-            // Advance the clock some more to make the pending React update seem long.
-            startTime += 20000;
-
-            // Fake a long "click" event in the middle
-            // and schedule a sync update that will also flush the previous work.
-            testMarks.push(createNativeEventEntry('click', 25000));
-            ReactDOM.flushSync(() => {
-              root.render(
-                <>
-                  <Yield id="A" value={2} />
-                  <Yield id="B" value={2} />
-                </>,
-              );
-            });
-          });
-
-          expect(Scheduler).toHaveYielded(['A:2', 'B:2']);
-
-          testMarks.push(...createUserTimingData(clearedMarks));
-
-          const data = await preprocessData(testMarks);
-          const event = data.nativeEvents.find(({type}) => type === 'click');
-          expect(event.warning).toBe(null);
-        }
-      });
-    });
-
-    describe('nested updates', () => {
-      it('should not warn about short nested (state) updates during layout effects', async () => {
-        function Component() {
-          const [didMount, setDidMount] = React.useState(false);
-          Scheduler.unstable_yieldValue(
-            `Component ${didMount ? 'update' : 'mount'}`,
-          );
-          React.useLayoutEffect(() => {
-            setDidMount(true);
-          }, []);
-          return didMount;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() => {
-            root.render(<Component />);
-          });
-
-          expect(Scheduler).toHaveYielded([
-            'Component mount',
-            'Component update',
-          ]);
-
-          const data = await preprocessData([
-            ...createBoilerplateEntries(),
-            ...createUserTimingData(clearedMarks),
-          ]);
-
-          const event = data.schedulingEvents.find(
-            ({type}) => type === 'schedule-state-update',
-          );
-          expect(event.warning).toBe(null);
-        }
-      });
-
-      it('should not warn about short (forced) updates during layout effects', async () => {
-        class Component extends React.Component {
-          _didMount: boolean = false;
-          componentDidMount() {
-            this._didMount = true;
-            this.forceUpdate();
-          }
-          render() {
-            Scheduler.unstable_yieldValue(
-              `Component ${this._didMount ? 'update' : 'mount'}`,
-            );
-            return null;
-          }
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() => {
-            root.render(<Component />);
-          });
-
-          expect(Scheduler).toHaveYielded([
-            'Component mount',
-            'Component update',
-          ]);
-
-          const data = await preprocessData([
-            ...createBoilerplateEntries(),
-            ...createUserTimingData(clearedMarks),
-          ]);
-
-          const event = data.schedulingEvents.find(
-            ({type}) => type === 'schedule-force-update',
-          );
-          expect(event.warning).toBe(null);
-        }
-      });
-
-      it('should warn about long nested (state) updates during layout effects', async () => {
-        function Component() {
-          const [didMount, setDidMount] = React.useState(false);
-          Scheduler.unstable_yieldValue(
-            `Component ${didMount ? 'update' : 'mount'}`,
-          );
-          // Fake a long render
-          startTime += 20000;
-          React.useLayoutEffect(() => {
-            setDidMount(true);
-          }, []);
-          return didMount;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const cpuProfilerSample = creactCpuProfilerSample();
-
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() => {
-            root.render(<Component />);
-          });
-
-          expect(Scheduler).toHaveYielded([
-            'Component mount',
-            'Component update',
-          ]);
-
-          const testMarks = [];
-          clearedMarks.forEach(markName => {
-            if (markName === '--component-render-start-Component') {
-              // Fake a long running render
-              startTime += 20000;
-            }
-
-            testMarks.push({
-              pid: ++pid,
-              tid: ++tid,
-              ts: ++startTime,
-              args: {data: {}},
-              cat: 'blink.user_timing',
-              name: markName,
-              ph: 'R',
-            });
-          });
-
-          const data = await preprocessData([
-            cpuProfilerSample,
-            ...createBoilerplateEntries(),
-            ...testMarks,
-          ]);
-
-          const event = data.schedulingEvents.find(
-            ({type}) => type === 'schedule-state-update',
-          );
-          expect(event.warning).toMatchInlineSnapshot(
-            `"A big nested update was scheduled during layout. Nested updates require React to re-render synchronously before the browser can paint. Consider delaying this update by moving it to a passive effect (useEffect)."`,
-          );
-        }
-      });
-
-      it('should warn about long nested (forced) updates during layout effects', async () => {
-        class Component extends React.Component {
-          _didMount: boolean = false;
-          componentDidMount() {
-            this._didMount = true;
-            this.forceUpdate();
-          }
-          render() {
-            Scheduler.unstable_yieldValue(
-              `Component ${this._didMount ? 'update' : 'mount'}`,
-            );
-            return null;
-          }
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const cpuProfilerSample = creactCpuProfilerSample();
-
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() => {
-            root.render(<Component />);
-          });
-
-          expect(Scheduler).toHaveYielded([
-            'Component mount',
-            'Component update',
-          ]);
-
-          const testMarks = [];
-          clearedMarks.forEach(markName => {
-            if (markName === '--component-render-start-Component') {
-              // Fake a long running render
-              startTime += 20000;
-            }
-
-            testMarks.push({
-              pid: ++pid,
-              tid: ++tid,
-              ts: ++startTime,
-              args: {data: {}},
-              cat: 'blink.user_timing',
-              name: markName,
-              ph: 'R',
-            });
-          });
-
-          const data = await preprocessData([
-            cpuProfilerSample,
-            ...createBoilerplateEntries(),
-            ...testMarks,
-          ]);
-
-          const event = data.schedulingEvents.find(
-            ({type}) => type === 'schedule-force-update',
-          );
-          expect(event.warning).toMatchInlineSnapshot(
-            `"A big nested update was scheduled during layout. Nested updates require React to re-render synchronously before the browser can paint. Consider delaying this update by moving it to a passive effect (useEffect)."`,
-          );
-        }
-      });
-
-      it('should not warn about transition updates scheduled during commit phase', async () => {
-        function Component() {
-          const [value, setValue] = React.useState(0);
-          // eslint-disable-next-line no-unused-vars
-          const [isPending, startTransition] = React.useTransition();
-
-          Scheduler.unstable_yieldValue(
-            `Component rendered with value ${value}`,
-          );
-
-          // Fake a long render
-          if (value !== 0) {
-            Scheduler.unstable_yieldValue('Long render');
-            startTime += 20000;
-          }
-
-          React.useLayoutEffect(() => {
-            startTransition(() => {
-              setValue(1);
-            });
-          }, []);
-
-          return value;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const cpuProfilerSample = creactCpuProfilerSample();
-
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() => {
-            root.render(<Component />);
-          });
-
-          expect(Scheduler).toHaveYielded([
-            'Component rendered with value 0',
-            'Component rendered with value 0',
-            'Component rendered with value 1',
-            'Long render',
-          ]);
-
-          const testMarks = [];
-          clearedMarks.forEach(markName => {
-            if (markName === '--component-render-start-Component') {
-              // Fake a long running render
-              startTime += 20000;
-            }
-
-            testMarks.push({
-              pid: ++pid,
-              tid: ++tid,
-              ts: ++startTime,
-              args: {data: {}},
-              cat: 'blink.user_timing',
-              name: markName,
-              ph: 'R',
-            });
-          });
-
-          const data = await preprocessData([
-            cpuProfilerSample,
-            ...createBoilerplateEntries(),
-            ...testMarks,
-          ]);
-
-          data.schedulingEvents.forEach(event => {
-            expect(event.warning).toBeNull();
-          });
-        }
-      });
-
-      it('should not warn about deferred value updates scheduled during commit phase', async () => {
-        function Component() {
-          const [value, setValue] = React.useState(0);
-          const deferredValue = React.useDeferredValue(value);
-
-          Scheduler.unstable_yieldValue(
-            `Component rendered with value ${value} and deferredValue ${deferredValue}`,
-          );
-
-          // Fake a long render
-          if (deferredValue !== 0) {
-            Scheduler.unstable_yieldValue('Long render');
-            startTime += 20000;
-          }
-
-          React.useLayoutEffect(() => {
-            setValue(1);
-          }, []);
-
-          return value + deferredValue;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const cpuProfilerSample = creactCpuProfilerSample();
-
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() => {
-            root.render(<Component />);
-          });
-
-          expect(Scheduler).toHaveYielded([
-            'Component rendered with value 0 and deferredValue 0',
-            'Component rendered with value 1 and deferredValue 0',
-            'Component rendered with value 1 and deferredValue 1',
-            'Long render',
-          ]);
-
-          const testMarks = [];
-          clearedMarks.forEach(markName => {
-            if (markName === '--component-render-start-Component') {
-              // Fake a long running render
-              startTime += 20000;
-            }
-
-            testMarks.push({
-              pid: ++pid,
-              tid: ++tid,
-              ts: ++startTime,
-              args: {data: {}},
-              cat: 'blink.user_timing',
-              name: markName,
-              ph: 'R',
-            });
-          });
-
-          const data = await preprocessData([
-            cpuProfilerSample,
-            ...createBoilerplateEntries(),
-            ...testMarks,
-          ]);
-
-          data.schedulingEvents.forEach(event => {
-            expect(event.warning).toBeNull();
-          });
-        }
-      });
-    });
-
-    describe('errors thrown while rendering', () => {
-      it('shoult parse Errors thrown during render', async () => {
-        spyOnDev(console, 'error');
-        spyOnProd(console, 'error');
-
-        class ErrorBoundary extends React.Component {
-          state = {error: null};
-          componentDidCatch(error) {
-            this.setState({error});
-          }
-          render() {
-            if (this.state.error) {
-              return null;
-            }
-            return this.props.children;
-          }
-        }
-
-        function ExampleThatThrows() {
-          throw Error('Expected error');
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          const testMarks = [creactCpuProfilerSample()];
-
-          // Mount and commit the app
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() =>
-            root.render(
-              <ErrorBoundary>
-                <ExampleThatThrows />
-              </ErrorBoundary>,
-            ),
-          );
-
-          testMarks.push(...createUserTimingData(clearedMarks));
-
-          const data = await preprocessData(testMarks);
-          expect(data.thrownErrors).toHaveLength(2);
-          expect(data.thrownErrors[0].message).toMatchInlineSnapshot(
-            '"Expected error"',
-          );
-        }
-      });
-    });
-
-    describe('suspend during an update', () => {
-      // This also tests an edge case where the a component suspends while profiling
-      // before the first commit is logged (so the lane-to-labels map will not yet exist).
-      it('should warn about suspending during an udpate', async () => {
-        let promise = null;
-        let resolvedValue = null;
-        function readValue(value) {
-          if (resolvedValue !== null) {
-            return resolvedValue;
-          } else if (promise === null) {
-            promise = Promise.resolve(true).then(() => {
-              resolvedValue = value;
-            });
-          }
-          throw promise;
-        }
-
-        function Component({shouldSuspend}) {
-          Scheduler.unstable_yieldValue(`Component ${shouldSuspend}`);
-          if (shouldSuspend) {
-            readValue(123);
-          }
-          return null;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          // Mount and commit the app
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() =>
-            root.render(
-              <React.Suspense fallback="Loading...">
-                <Component shouldSuspend={false} />
-              </React.Suspense>,
-            ),
-          );
-
-          clearedMarks.splice(0);
-
-          const testMarks = [creactCpuProfilerSample()];
-
-          // Start profiling and suspend during a render.
-          act(() =>
-            root.render(
-              <React.Suspense fallback="Loading...">
-                <Component shouldSuspend={true} />
-              </React.Suspense>,
-            ),
-          );
-
-          testMarks.push(...createUserTimingData(clearedMarks));
-
-          const data = await act(() => preprocessData(testMarks));
-          expect(data.suspenseEvents).toHaveLength(1);
-          expect(data.suspenseEvents[0].warning).toMatchInlineSnapshot(
-            `"A component suspended during an update which caused a fallback to be shown. Consider using the Transition API to avoid hiding components after they've been mounted."`,
-          );
-        }
-      });
-
-      it('should not warn about suspending during an transition', async () => {
-        let promise = null;
-        let resolvedValue = null;
-        function readValue(value) {
-          if (resolvedValue !== null) {
-            return resolvedValue;
-          } else if (promise === null) {
-            promise = Promise.resolve(true).then(() => {
-              resolvedValue = value;
-            });
-          }
-          throw promise;
-        }
-
-        function Component({shouldSuspend}) {
-          Scheduler.unstable_yieldValue(`Component ${shouldSuspend}`);
-          if (shouldSuspend) {
-            readValue(123);
-          }
-          return null;
-        }
-
-        if (gate(flags => flags.enableSchedulingProfiler)) {
-          // Mount and commit the app
-          const root = ReactDOM.createRoot(document.createElement('div'));
-          act(() =>
-            root.render(
-              <React.Suspense fallback="Loading...">
-                <Component shouldSuspend={false} />
-              </React.Suspense>,
-            ),
-          );
-
-          clearedMarks.splice(0);
-
-          const testMarks = [creactCpuProfilerSample()];
-
-          // Start profiling and suspend during a render.
-          await act(async () =>
-            React.startTransition(() =>
-              root.render(
-                <React.Suspense fallback="Loading...">
-                  <Component shouldSuspend={true} />
-                </React.Suspense>,
-              ),
-            ),
-          );
-
-          testMarks.push(...createUserTimingData(clearedMarks));
-
-          const data = await act(() => preprocessData(testMarks));
-          expect(data.suspenseEvents).toHaveLength(1);
-          expect(data.suspenseEvents[0].warning).toBe(null);
-        }
-      });
-    });
-  });
-
-  // TODO: Add test for snapshot base64 parsing
-
-  // TODO: Add test for flamechart parsing
-});
diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.new.js b/packages/react-reconciler/src/ReactFiberBeginWork.new.js
index 3e344d33261e8..e8d8b38b55a41 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.new.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.new.js
@@ -35,7 +35,8 @@ import checkPropTypes from 'shared/checkPropTypes';
 import {
   markComponentRenderStarted,
   markComponentRenderStopped,
-} from './SchedulingProfiler';
+  setIsStrictModeForDevtools,
+} from './ReactFiberDevToolsHook.new';
 import {
   IndeterminateComponent,
   FunctionComponent,
@@ -240,7 +241,6 @@ import {createCapturedValue} from './ReactCapturedValue';
 import {createClassErrorUpdate} from './ReactFiberThrow.new';
 import {completeSuspendedOffscreenHostContainer} from './ReactFiberCompleteWork.new';
 import is from 'shared/objectIs';
-import {setIsStrictModeForDevtools} from './ReactFiberDevToolsHook.new';
 import {
   getForksAtLevel,
   isForkedChild,
diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.old.js b/packages/react-reconciler/src/ReactFiberBeginWork.old.js
index 5192d6b2fc99d..3e1dc87620a18 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.old.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.old.js
@@ -35,7 +35,8 @@ import checkPropTypes from 'shared/checkPropTypes';
 import {
   markComponentRenderStarted,
   markComponentRenderStopped,
-} from './SchedulingProfiler';
+  setIsStrictModeForDevtools,
+} from './ReactFiberDevToolsHook.old';
 import {
   IndeterminateComponent,
   FunctionComponent,
@@ -240,7 +241,6 @@ import {createCapturedValue} from './ReactCapturedValue';
 import {createClassErrorUpdate} from './ReactFiberThrow.old';
 import {completeSuspendedOffscreenHostContainer} from './ReactFiberCompleteWork.old';
 import is from 'shared/objectIs';
-import {setIsStrictModeForDevtools} from './ReactFiberDevToolsHook.old';
 import {
   getForksAtLevel,
   isForkedChild,
diff --git a/packages/react-reconciler/src/ReactFiberClassComponent.new.js b/packages/react-reconciler/src/ReactFiberClassComponent.new.js
index 18e56db09313c..0279cabd519be 100644
--- a/packages/react-reconciler/src/ReactFiberClassComponent.new.js
+++ b/packages/react-reconciler/src/ReactFiberClassComponent.new.js
@@ -37,7 +37,6 @@ import getComponentNameFromFiber from 'react-reconciler/src/getComponentNameFrom
 import getComponentNameFromType from 'shared/getComponentNameFromType';
 import isArray from 'shared/isArray';
 import {REACT_CONTEXT_TYPE, REACT_PROVIDER_TYPE} from 'shared/ReactSymbols';
-import {setIsStrictModeForDevtools} from './ReactFiberDevToolsHook.new';
 
 import {resolveDefaultProps} from './ReactFiberLazyComponent.new';
 import {
@@ -74,11 +73,11 @@ import {
   scheduleUpdateOnFiber,
 } from './ReactFiberWorkLoop.new';
 import {logForceUpdateScheduled, logStateUpdateScheduled} from './DebugTracing';
-
 import {
   markForceUpdateScheduled,
   markStateUpdateScheduled,
-} from './SchedulingProfiler';
+  setIsStrictModeForDevtools,
+} from './ReactFiberDevToolsHook.new';
 
 const fakeInternalInstance = {};
 
diff --git a/packages/react-reconciler/src/ReactFiberClassComponent.old.js b/packages/react-reconciler/src/ReactFiberClassComponent.old.js
index a54dfabfca525..184993ff35b05 100644
--- a/packages/react-reconciler/src/ReactFiberClassComponent.old.js
+++ b/packages/react-reconciler/src/ReactFiberClassComponent.old.js
@@ -37,7 +37,6 @@ import getComponentNameFromFiber from 'react-reconciler/src/getComponentNameFrom
 import getComponentNameFromType from 'shared/getComponentNameFromType';
 import isArray from 'shared/isArray';
 import {REACT_CONTEXT_TYPE, REACT_PROVIDER_TYPE} from 'shared/ReactSymbols';
-import {setIsStrictModeForDevtools} from './ReactFiberDevToolsHook.old';
 
 import {resolveDefaultProps} from './ReactFiberLazyComponent.old';
 import {
@@ -74,11 +73,11 @@ import {
   scheduleUpdateOnFiber,
 } from './ReactFiberWorkLoop.old';
 import {logForceUpdateScheduled, logStateUpdateScheduled} from './DebugTracing';
-
 import {
   markForceUpdateScheduled,
   markStateUpdateScheduled,
-} from './SchedulingProfiler';
+  setIsStrictModeForDevtools,
+} from './ReactFiberDevToolsHook.old';
 
 const fakeInternalInstance = {};
 
diff --git a/packages/react-reconciler/src/ReactFiberCommitWork.new.js b/packages/react-reconciler/src/ReactFiberCommitWork.new.js
index efdc515d9c0b2..ecb83e28171c2 100644
--- a/packages/react-reconciler/src/ReactFiberCommitWork.new.js
+++ b/packages/react-reconciler/src/ReactFiberCommitWork.new.js
@@ -86,8 +86,6 @@ import {
   resetCurrentFiber as resetCurrentDebugFiberInDEV,
   setCurrentFiber as setCurrentDebugFiberInDEV,
 } from './ReactCurrentFiber';
-import {isDevToolsPresent} from './ReactFiberDevToolsHook.new';
-import {onCommitUnmount} from './ReactFiberDevToolsHook.new';
 import {resolveDefaultProps} from './ReactFiberLazyComponent.new';
 import {
   isCurrentUpdateNested,
@@ -147,6 +145,7 @@ import {didWarnAboutReassigningProps} from './ReactFiberBeginWork.new';
 import {doesFiberContain} from './ReactFiberTreeReflection';
 import {invokeGuardedCallback, clearCaughtError} from 'shared/ReactErrorUtils';
 import {
+  isDevToolsPresent,
   markComponentPassiveEffectMountStarted,
   markComponentPassiveEffectMountStopped,
   markComponentPassiveEffectUnmountStarted,
@@ -155,7 +154,8 @@ import {
   markComponentLayoutEffectMountStopped,
   markComponentLayoutEffectUnmountStarted,
   markComponentLayoutEffectUnmountStopped,
-} from './SchedulingProfiler';
+  onCommitUnmount,
+} from './ReactFiberDevToolsHook.new';
 import {releaseCache, retainCache} from './ReactFiberCacheComponent.new';
 
 let didWarnAboutUndefinedSnapshotBeforeUpdate: Set<mixed> | null = null;
diff --git a/packages/react-reconciler/src/ReactFiberCommitWork.old.js b/packages/react-reconciler/src/ReactFiberCommitWork.old.js
index 7d4d5d7aeecef..8466b41c85dcf 100644
--- a/packages/react-reconciler/src/ReactFiberCommitWork.old.js
+++ b/packages/react-reconciler/src/ReactFiberCommitWork.old.js
@@ -86,8 +86,6 @@ import {
   resetCurrentFiber as resetCurrentDebugFiberInDEV,
   setCurrentFiber as setCurrentDebugFiberInDEV,
 } from './ReactCurrentFiber';
-import {isDevToolsPresent} from './ReactFiberDevToolsHook.old';
-import {onCommitUnmount} from './ReactFiberDevToolsHook.old';
 import {resolveDefaultProps} from './ReactFiberLazyComponent.old';
 import {
   isCurrentUpdateNested,
@@ -147,6 +145,7 @@ import {didWarnAboutReassigningProps} from './ReactFiberBeginWork.old';
 import {doesFiberContain} from './ReactFiberTreeReflection';
 import {invokeGuardedCallback, clearCaughtError} from 'shared/ReactErrorUtils';
 import {
+  isDevToolsPresent,
   markComponentPassiveEffectMountStarted,
   markComponentPassiveEffectMountStopped,
   markComponentPassiveEffectUnmountStarted,
@@ -155,7 +154,8 @@ import {
   markComponentLayoutEffectMountStopped,
   markComponentLayoutEffectUnmountStarted,
   markComponentLayoutEffectUnmountStopped,
-} from './SchedulingProfiler';
+  onCommitUnmount,
+} from './ReactFiberDevToolsHook.old';
 import {releaseCache, retainCache} from './ReactFiberCacheComponent.old';
 
 let didWarnAboutUndefinedSnapshotBeforeUpdate: Set<mixed> | null = null;
diff --git a/packages/react-reconciler/src/ReactFiberDevToolsHook.new.js b/packages/react-reconciler/src/ReactFiberDevToolsHook.new.js
index d1748dd8f2285..2978f7b3279b5 100644
--- a/packages/react-reconciler/src/ReactFiberDevToolsHook.new.js
+++ b/packages/react-reconciler/src/ReactFiberDevToolsHook.new.js
@@ -7,16 +7,22 @@
  * @flow
  */
 
-import {
-  consoleManagedByDevToolsDuringStrictMode,
-  enableProfilerTimer,
-} from 'shared/ReactFeatureFlags';
-
+import type {Lane, Lanes} from './ReactFiberLane.new';
 import type {Fiber, FiberRoot} from './ReactInternalTypes';
-import type {ReactNodeList} from 'shared/ReactTypes';
+import type {ReactNodeList, Wakeable} from 'shared/ReactTypes';
 import type {EventPriority} from './ReactEventPriorities.new';
+import type {DevToolsProfilingHooks} from 'react-devtools-shared/src/backend/types';
 
+import {
+  getLabelForLane,
+  TotalLanes,
+} from 'react-reconciler/src/ReactFiberLane.new';
 import {DidCapture} from './ReactFiberFlags';
+import {
+  consoleManagedByDevToolsDuringStrictMode,
+  enableProfilerTimer,
+  enableSchedulingProfiler,
+} from 'shared/ReactFeatureFlags';
 import {
   DiscreteEventPriority,
   ContinuousEventPriority,
@@ -38,6 +44,7 @@ declare var __REACT_DEVTOOLS_GLOBAL_HOOK__: Object | void;
 
 let rendererID = null;
 let injectedHook = null;
+let injectedProfilingHooks: DevToolsProfilingHooks | null = null;
 let hasLoggedError = false;
 
 export const isDevToolsPresent =
@@ -67,7 +74,11 @@ export function injectInternals(internals: Object): boolean {
     return true;
   }
   try {
-    rendererID = hook.inject(internals);
+    rendererID = hook.inject({
+      ...internals,
+      getLaneLabelMap,
+      injectProfilingHooks,
+    });
     // We have successfully injected, so now it is safe to set up hooks.
     injectedHook = hook;
   } catch (err) {
@@ -212,3 +223,302 @@ export function setIsStrictModeForDevtools(newIsStrictMode: boolean) {
     }
   }
 }
+
+// Profiler API hooks
+
+function injectProfilingHooks(profilingHooks: DevToolsProfilingHooks): void {
+  injectedProfilingHooks = profilingHooks;
+}
+
+function getLaneLabelMap(): Map<Lane, string> {
+  const map: Map<Lane, string> = new Map();
+
+  let lane = 1;
+  for (let index = 0; index < TotalLanes; index++) {
+    const label = ((getLabelForLane(lane): any): string);
+    map.set(lane, label);
+    lane *= 2;
+  }
+
+  return map;
+}
+
+export function markCommitStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStarted === 'function'
+    ) {
+      injectedProfilingHooks.markCommitStarted(lanes);
+    }
+  }
+}
+
+export function markCommitStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStopped === 'function'
+    ) {
+      injectedProfilingHooks.markCommitStopped();
+    }
+  }
+}
+
+export function markComponentRenderStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStarted === 'function'
+    ) {
+      injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+  }
+}
+
+export function markComponentRenderStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStopped === 'function'
+    ) {
+      injectedProfilingHooks.markComponentRenderStopped();
+    }
+  }
+}
+
+export function markComponentPassiveEffectMountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentPassiveEffectMountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+    }
+  }
+}
+
+export function markComponentPassiveEffectUnmountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentPassiveEffectUnmountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+    }
+  }
+}
+
+export function markComponentLayoutEffectMountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentLayoutEffectMountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+    }
+  }
+}
+
+export function markComponentLayoutEffectUnmountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentLayoutEffectUnmountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+    }
+  }
+}
+
+export function markComponentErrored(
+  fiber: Fiber,
+  thrownValue: mixed,
+  lanes: Lanes,
+): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentErrored === 'function'
+    ) {
+      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+    }
+  }
+}
+
+export function markComponentSuspended(
+  fiber: Fiber,
+  wakeable: Wakeable,
+  lanes: Lanes,
+): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentSuspended === 'function'
+    ) {
+      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+    }
+  }
+}
+
+export function markLayoutEffectsStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStarted === 'function'
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    }
+  }
+}
+
+export function markLayoutEffectsStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStopped === 'function'
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    }
+  }
+}
+
+export function markPassiveEffectsStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStarted === 'function'
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+    }
+  }
+}
+
+export function markPassiveEffectsStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStopped === 'function'
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStopped();
+    }
+  }
+}
+
+export function markRenderStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStarted === 'function'
+    ) {
+      injectedProfilingHooks.markRenderStarted(lanes);
+    }
+  }
+}
+
+export function markRenderYielded(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderYielded === 'function'
+    ) {
+      injectedProfilingHooks.markRenderYielded();
+    }
+  }
+}
+
+export function markRenderStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStopped === 'function'
+    ) {
+      injectedProfilingHooks.markRenderStopped();
+    }
+  }
+}
+
+export function markRenderScheduled(lane: Lane): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderScheduled === 'function'
+    ) {
+      injectedProfilingHooks.markRenderScheduled(lane);
+    }
+  }
+}
+
+export function markForceUpdateScheduled(fiber: Fiber, lane: Lane): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markForceUpdateScheduled === 'function'
+    ) {
+      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+    }
+  }
+}
+
+export function markStateUpdateScheduled(fiber: Fiber, lane: Lane): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markStateUpdateScheduled === 'function'
+    ) {
+      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+  }
+}
diff --git a/packages/react-reconciler/src/ReactFiberDevToolsHook.old.js b/packages/react-reconciler/src/ReactFiberDevToolsHook.old.js
index aeaadc84b0193..d26d12236c24c 100644
--- a/packages/react-reconciler/src/ReactFiberDevToolsHook.old.js
+++ b/packages/react-reconciler/src/ReactFiberDevToolsHook.old.js
@@ -7,16 +7,22 @@
  * @flow
  */
 
-import {
-  consoleManagedByDevToolsDuringStrictMode,
-  enableProfilerTimer,
-} from 'shared/ReactFeatureFlags';
-
+import type {Lane, Lanes} from './ReactFiberLane.old';
 import type {Fiber, FiberRoot} from './ReactInternalTypes';
-import type {ReactNodeList} from 'shared/ReactTypes';
+import type {ReactNodeList, Wakeable} from 'shared/ReactTypes';
 import type {EventPriority} from './ReactEventPriorities.old';
+import type {DevToolsProfilingHooks} from 'react-devtools-shared/src/backend/types';
 
+import {
+  getLabelForLane,
+  TotalLanes,
+} from 'react-reconciler/src/ReactFiberLane.old';
 import {DidCapture} from './ReactFiberFlags';
+import {
+  consoleManagedByDevToolsDuringStrictMode,
+  enableProfilerTimer,
+  enableSchedulingProfiler,
+} from 'shared/ReactFeatureFlags';
 import {
   DiscreteEventPriority,
   ContinuousEventPriority,
@@ -38,6 +44,7 @@ declare var __REACT_DEVTOOLS_GLOBAL_HOOK__: Object | void;
 
 let rendererID = null;
 let injectedHook = null;
+let injectedProfilingHooks: DevToolsProfilingHooks | null = null;
 let hasLoggedError = false;
 
 export const isDevToolsPresent =
@@ -67,7 +74,11 @@ export function injectInternals(internals: Object): boolean {
     return true;
   }
   try {
-    rendererID = hook.inject(internals);
+    rendererID = hook.inject({
+      ...internals,
+      getLaneLabelMap,
+      injectProfilingHooks,
+    });
     // We have successfully injected, so now it is safe to set up hooks.
     injectedHook = hook;
   } catch (err) {
@@ -212,3 +223,302 @@ export function setIsStrictModeForDevtools(newIsStrictMode: boolean) {
     }
   }
 }
+
+// Profiler API hooks
+
+function injectProfilingHooks(profilingHooks: DevToolsProfilingHooks): void {
+  injectedProfilingHooks = profilingHooks;
+}
+
+function getLaneLabelMap(): Map<Lane, string> {
+  const map: Map<Lane, string> = new Map();
+
+  let lane = 1;
+  for (let index = 0; index < TotalLanes; index++) {
+    const label = ((getLabelForLane(lane): any): string);
+    map.set(lane, label);
+    lane *= 2;
+  }
+
+  return map;
+}
+
+export function markCommitStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStarted === 'function'
+    ) {
+      injectedProfilingHooks.markCommitStarted(lanes);
+    }
+  }
+}
+
+export function markCommitStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStopped === 'function'
+    ) {
+      injectedProfilingHooks.markCommitStopped();
+    }
+  }
+}
+
+export function markComponentRenderStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStarted === 'function'
+    ) {
+      injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+  }
+}
+
+export function markComponentRenderStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStopped === 'function'
+    ) {
+      injectedProfilingHooks.markComponentRenderStopped();
+    }
+  }
+}
+
+export function markComponentPassiveEffectMountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentPassiveEffectMountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+    }
+  }
+}
+
+export function markComponentPassiveEffectUnmountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentPassiveEffectUnmountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+    }
+  }
+}
+
+export function markComponentLayoutEffectMountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentLayoutEffectMountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+    }
+  }
+}
+
+export function markComponentLayoutEffectUnmountStarted(fiber: Fiber): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+    }
+  }
+}
+
+export function markComponentLayoutEffectUnmountStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped ===
+        'function'
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+    }
+  }
+}
+
+export function markComponentErrored(
+  fiber: Fiber,
+  thrownValue: mixed,
+  lanes: Lanes,
+): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentErrored === 'function'
+    ) {
+      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+    }
+  }
+}
+
+export function markComponentSuspended(
+  fiber: Fiber,
+  wakeable: Wakeable,
+  lanes: Lanes,
+): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentSuspended === 'function'
+    ) {
+      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+    }
+  }
+}
+
+export function markLayoutEffectsStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStarted === 'function'
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    }
+  }
+}
+
+export function markLayoutEffectsStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStopped === 'function'
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    }
+  }
+}
+
+export function markPassiveEffectsStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStarted === 'function'
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+    }
+  }
+}
+
+export function markPassiveEffectsStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStopped === 'function'
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStopped();
+    }
+  }
+}
+
+export function markRenderStarted(lanes: Lanes): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStarted === 'function'
+    ) {
+      injectedProfilingHooks.markRenderStarted(lanes);
+    }
+  }
+}
+
+export function markRenderYielded(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderYielded === 'function'
+    ) {
+      injectedProfilingHooks.markRenderYielded();
+    }
+  }
+}
+
+export function markRenderStopped(): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStopped === 'function'
+    ) {
+      injectedProfilingHooks.markRenderStopped();
+    }
+  }
+}
+
+export function markRenderScheduled(lane: Lane): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderScheduled === 'function'
+    ) {
+      injectedProfilingHooks.markRenderScheduled(lane);
+    }
+  }
+}
+
+export function markForceUpdateScheduled(fiber: Fiber, lane: Lane): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markForceUpdateScheduled === 'function'
+    ) {
+      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+    }
+  }
+}
+
+export function markStateUpdateScheduled(fiber: Fiber, lane: Lane): void {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markStateUpdateScheduled === 'function'
+    ) {
+      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+  }
+}
diff --git a/packages/react-reconciler/src/ReactFiberHooks.new.js b/packages/react-reconciler/src/ReactFiberHooks.new.js
index 2c26859bafe70..cf8086b075aa2 100644
--- a/packages/react-reconciler/src/ReactFiberHooks.new.js
+++ b/packages/react-reconciler/src/ReactFiberHooks.new.js
@@ -101,7 +101,7 @@ import {
   warnAboutMultipleRenderersDEV,
 } from './ReactMutableSource.new';
 import {logStateUpdateScheduled} from './DebugTracing';
-import {markStateUpdateScheduled} from './SchedulingProfiler';
+import {markStateUpdateScheduled} from './ReactFiberDevToolsHook.new';
 import {createCache, CacheContext} from './ReactFiberCacheComponent.new';
 import {
   createUpdate as createLegacyQueueUpdate,
diff --git a/packages/react-reconciler/src/ReactFiberHooks.old.js b/packages/react-reconciler/src/ReactFiberHooks.old.js
index 077073bbeef3c..ff2aff6720e11 100644
--- a/packages/react-reconciler/src/ReactFiberHooks.old.js
+++ b/packages/react-reconciler/src/ReactFiberHooks.old.js
@@ -101,7 +101,7 @@ import {
   warnAboutMultipleRenderersDEV,
 } from './ReactMutableSource.old';
 import {logStateUpdateScheduled} from './DebugTracing';
-import {markStateUpdateScheduled} from './SchedulingProfiler';
+import {markStateUpdateScheduled} from './ReactFiberDevToolsHook.old';
 import {createCache, CacheContext} from './ReactFiberCacheComponent.old';
 import {
   createUpdate as createLegacyQueueUpdate,
diff --git a/packages/react-reconciler/src/ReactFiberReconciler.new.js b/packages/react-reconciler/src/ReactFiberReconciler.new.js
index 1b8b9502de3ee..1cf200e35d56d 100644
--- a/packages/react-reconciler/src/ReactFiberReconciler.new.js
+++ b/packages/react-reconciler/src/ReactFiberReconciler.new.js
@@ -44,7 +44,11 @@ import {
   isContextProvider as isLegacyContextProvider,
 } from './ReactFiberContext.new';
 import {createFiberRoot} from './ReactFiberRoot.new';
-import {injectInternals, onScheduleRoot} from './ReactFiberDevToolsHook.new';
+import {
+  injectInternals,
+  markRenderScheduled,
+  onScheduleRoot,
+} from './ReactFiberDevToolsHook.new';
 import {
   requestEventTime,
   requestUpdateLane,
@@ -87,7 +91,6 @@ import {
   setRefreshHandler,
   findHostInstancesForRefresh,
 } from './ReactFiberHotReloading.new';
-import {markRenderScheduled} from './SchedulingProfiler';
 import ReactVersion from 'shared/ReactVersion';
 export {registerMutableSourceForHydration} from './ReactMutableSource.new';
 export {createPortal} from './ReactPortal';
diff --git a/packages/react-reconciler/src/ReactFiberReconciler.old.js b/packages/react-reconciler/src/ReactFiberReconciler.old.js
index 8649ff6989841..4b02959ab0840 100644
--- a/packages/react-reconciler/src/ReactFiberReconciler.old.js
+++ b/packages/react-reconciler/src/ReactFiberReconciler.old.js
@@ -44,7 +44,11 @@ import {
   isContextProvider as isLegacyContextProvider,
 } from './ReactFiberContext.old';
 import {createFiberRoot} from './ReactFiberRoot.old';
-import {injectInternals, onScheduleRoot} from './ReactFiberDevToolsHook.old';
+import {
+  injectInternals,
+  markRenderScheduled,
+  onScheduleRoot,
+} from './ReactFiberDevToolsHook.old';
 import {
   requestEventTime,
   requestUpdateLane,
@@ -87,7 +91,6 @@ import {
   setRefreshHandler,
   findHostInstancesForRefresh,
 } from './ReactFiberHotReloading.old';
-import {markRenderScheduled} from './SchedulingProfiler';
 import ReactVersion from 'shared/ReactVersion';
 export {registerMutableSourceForHydration} from './ReactMutableSource.old';
 export {createPortal} from './ReactPortal';
diff --git a/packages/react-reconciler/src/ReactFiberWorkLoop.new.js b/packages/react-reconciler/src/ReactFiberWorkLoop.new.js
index 740ed6dca40a5..b108da0106e42 100644
--- a/packages/react-reconciler/src/ReactFiberWorkLoop.new.js
+++ b/packages/react-reconciler/src/ReactFiberWorkLoop.new.js
@@ -65,20 +65,6 @@ import {
   logRenderStarted,
   logRenderStopped,
 } from './DebugTracing';
-import {
-  markCommitStarted,
-  markCommitStopped,
-  markComponentRenderStopped,
-  markComponentSuspended,
-  markComponentErrored,
-  markLayoutEffectsStarted,
-  markLayoutEffectsStopped,
-  markPassiveEffectsStarted,
-  markPassiveEffectsStopped,
-  markRenderStarted,
-  markRenderYielded,
-  markRenderStopped,
-} from './SchedulingProfiler';
 
 import {
   resetAfterCommit,
@@ -224,9 +210,21 @@ import {
   clearCaughtError,
 } from 'shared/ReactErrorUtils';
 import {
+  isDevToolsPresent,
+  markCommitStarted,
+  markCommitStopped,
+  markComponentRenderStopped,
+  markComponentSuspended,
+  markComponentErrored,
+  markLayoutEffectsStarted,
+  markLayoutEffectsStopped,
+  markPassiveEffectsStarted,
+  markPassiveEffectsStopped,
+  markRenderStarted,
+  markRenderYielded,
+  markRenderStopped,
   onCommitRoot as onCommitRootDevTools,
   onPostCommitRoot as onPostCommitRootDevTools,
-  isDevToolsPresent,
 } from './ReactFiberDevToolsHook.new';
 import {onCommitRoot as onCommitRootTestSelector} from './ReactTestSelectors';
 import {releaseCache} from './ReactFiberCacheComponent.new';
diff --git a/packages/react-reconciler/src/ReactFiberWorkLoop.old.js b/packages/react-reconciler/src/ReactFiberWorkLoop.old.js
index 673da7908c289..a32f8853337e6 100644
--- a/packages/react-reconciler/src/ReactFiberWorkLoop.old.js
+++ b/packages/react-reconciler/src/ReactFiberWorkLoop.old.js
@@ -65,20 +65,6 @@ import {
   logRenderStarted,
   logRenderStopped,
 } from './DebugTracing';
-import {
-  markCommitStarted,
-  markCommitStopped,
-  markComponentRenderStopped,
-  markComponentSuspended,
-  markComponentErrored,
-  markLayoutEffectsStarted,
-  markLayoutEffectsStopped,
-  markPassiveEffectsStarted,
-  markPassiveEffectsStopped,
-  markRenderStarted,
-  markRenderYielded,
-  markRenderStopped,
-} from './SchedulingProfiler';
 
 import {
   resetAfterCommit,
@@ -224,9 +210,21 @@ import {
   clearCaughtError,
 } from 'shared/ReactErrorUtils';
 import {
+  isDevToolsPresent,
+  markCommitStarted,
+  markCommitStopped,
+  markComponentRenderStopped,
+  markComponentSuspended,
+  markComponentErrored,
+  markLayoutEffectsStarted,
+  markLayoutEffectsStopped,
+  markPassiveEffectsStarted,
+  markPassiveEffectsStopped,
+  markRenderStarted,
+  markRenderYielded,
+  markRenderStopped,
   onCommitRoot as onCommitRootDevTools,
   onPostCommitRoot as onPostCommitRootDevTools,
-  isDevToolsPresent,
 } from './ReactFiberDevToolsHook.old';
 import {onCommitRoot as onCommitRootTestSelector} from './ReactTestSelectors';
 import {releaseCache} from './ReactFiberCacheComponent.old';
diff --git a/packages/react-reconciler/src/SchedulingProfiler.js b/packages/react-reconciler/src/SchedulingProfiler.js
deleted file mode 100644
index 6ef0b6293bc76..0000000000000
--- a/packages/react-reconciler/src/SchedulingProfiler.js
+++ /dev/null
@@ -1,395 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import type {Lane, Lanes} from './ReactFiberLane.old';
-import type {Fiber} from './ReactInternalTypes';
-import type {Wakeable} from 'shared/ReactTypes';
-
-import {
-  enableNewReconciler,
-  enableSchedulingProfiler,
-} from 'shared/ReactFeatureFlags';
-import ReactVersion from 'shared/ReactVersion';
-import getComponentNameFromFiber from 'react-reconciler/src/getComponentNameFromFiber';
-import {SCHEDULING_PROFILER_VERSION} from 'react-devtools-timeline/src/constants';
-import isArray from 'shared/isArray';
-
-import {
-  getLabelForLane as getLabelForLane_old,
-  TotalLanes as TotalLanes_old,
-} from 'react-reconciler/src/ReactFiberLane.old';
-import {
-  getLabelForLane as getLabelForLane_new,
-  TotalLanes as TotalLanes_new,
-} from 'react-reconciler/src/ReactFiberLane.new';
-
-const getLabelForLane = enableNewReconciler
-  ? getLabelForLane_new
-  : getLabelForLane_old;
-
-const TotalLanes = enableNewReconciler ? TotalLanes_new : TotalLanes_old;
-
-/**
- * If performance exists and supports the subset of the User Timing API that we
- * require.
- */
-const supportsUserTiming =
-  typeof performance !== 'undefined' &&
-  typeof performance.mark === 'function' &&
-  typeof performance.clearMarks === 'function';
-
-let supportsUserTimingV3 = false;
-if (enableSchedulingProfiler) {
-  if (supportsUserTiming) {
-    const CHECK_V3_MARK = '__v3';
-    const markOptions = {};
-    // $FlowFixMe: Ignore Flow complaining about needing a value
-    Object.defineProperty(markOptions, 'startTime', {
-      get: function() {
-        supportsUserTimingV3 = true;
-        return 0;
-      },
-      set: function() {},
-    });
-
-    try {
-      // $FlowFixMe: Flow expects the User Timing level 2 API.
-      performance.mark(CHECK_V3_MARK, markOptions);
-    } catch (error) {
-      // Ignore
-    } finally {
-      performance.clearMarks(CHECK_V3_MARK);
-    }
-  }
-}
-
-const laneLabels: Array<string> = [];
-
-export function getLaneLabels(): Array<string> {
-  if (laneLabels.length === 0) {
-    let lane = 1;
-    for (let index = 0; index < TotalLanes; index++) {
-      laneLabels.push(((getLabelForLane(lane): any): string));
-
-      lane *= 2;
-    }
-  }
-  return laneLabels;
-}
-
-function markLaneToLabelMetadata() {
-  getLaneLabels();
-
-  markAndClear(`--react-lane-labels-${laneLabels.join(',')}`);
-}
-
-function markAndClear(name) {
-  performance.mark(name);
-  performance.clearMarks(name);
-}
-
-function markVersionMetadata() {
-  markAndClear(`--react-version-${ReactVersion}`);
-  markAndClear(`--profiler-version-${SCHEDULING_PROFILER_VERSION}`);
-}
-
-function markInternalModuleRanges() {
-  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-  if (
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges === 'function'
-  ) {
-    const ranges = __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges();
-    // This check would not be required,
-    // except that it's possible for things to override __REACT_DEVTOOLS_GLOBAL_HOOK__.
-    if (isArray(ranges)) {
-      for (let i = 0; i < ranges.length; i++) {
-        const range = ranges[i];
-        if (isArray(range) && range.length === 2) {
-          const [startStackFrame, stopStackFrame] = ranges[i];
-
-          markAndClear(`--react-internal-module-start-${startStackFrame}`);
-          markAndClear(`--react-internal-module-stop-${stopStackFrame}`);
-        }
-      }
-    }
-  }
-}
-
-export function markCommitStarted(lanes: Lanes): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear(`--commit-start-${lanes}`);
-
-      // Certain types of metadata should be logged infrequently.
-      // Normally we would log this during module init,
-      // but there's no guarantee a user is profiling at that time.
-      // Commits happen infrequently (less than renders or state updates)
-      // so we log this extra information along with a commit.
-      // It will likely be logged more than once but that's okay.
-      //
-      // TODO Once DevTools supports starting/stopping the profiler,
-      // we can log this data only once (when started) and remove the per-commit logging.
-      markVersionMetadata();
-      markLaneToLabelMetadata();
-      markInternalModuleRanges();
-    }
-  }
-}
-
-export function markCommitStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--commit-stop');
-    }
-  }
-}
-
-export function markComponentRenderStarted(fiber: Fiber): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--component-render-start-${componentName}`);
-    }
-  }
-}
-
-export function markComponentRenderStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--component-render-stop');
-    }
-  }
-}
-
-export function markComponentPassiveEffectMountStarted(fiber: Fiber): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--component-passive-effect-mount-start-${componentName}`);
-    }
-  }
-}
-
-export function markComponentPassiveEffectMountStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--component-passive-effect-mount-stop');
-    }
-  }
-}
-
-export function markComponentPassiveEffectUnmountStarted(fiber: Fiber): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--component-passive-effect-unmount-start-${componentName}`);
-    }
-  }
-}
-
-export function markComponentPassiveEffectUnmountStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--component-passive-effect-unmount-stop');
-    }
-  }
-}
-
-export function markComponentLayoutEffectMountStarted(fiber: Fiber): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--component-layout-effect-mount-start-${componentName}`);
-    }
-  }
-}
-
-export function markComponentLayoutEffectMountStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--component-layout-effect-mount-stop');
-    }
-  }
-}
-
-export function markComponentLayoutEffectUnmountStarted(fiber: Fiber): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--component-layout-effect-unmount-start-${componentName}`);
-    }
-  }
-}
-
-export function markComponentLayoutEffectUnmountStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--component-layout-effect-unmount-stop');
-    }
-  }
-}
-
-export function markComponentErrored(
-  fiber: Fiber,
-  thrownValue: mixed,
-  lanes: Lanes,
-): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      const phase = fiber.alternate === null ? 'mount' : 'update';
-
-      let message = '';
-      if (
-        thrownValue !== null &&
-        typeof thrownValue === 'object' &&
-        typeof thrownValue.message === 'string'
-      ) {
-        message = thrownValue.message;
-      } else if (typeof thrownValue === 'string') {
-        message = thrownValue;
-      }
-
-      // TODO (timeline) Add component stack id
-      markAndClear(`--error-${componentName}-${phase}-${message}`);
-    }
-  }
-}
-
-const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
-
-// $FlowFixMe: Flow cannot handle polymorphic WeakMaps
-const wakeableIDs: WeakMap<Wakeable, number> = new PossiblyWeakMap();
-let wakeableID: number = 0;
-function getWakeableID(wakeable: Wakeable): number {
-  if (!wakeableIDs.has(wakeable)) {
-    wakeableIDs.set(wakeable, wakeableID++);
-  }
-  return ((wakeableIDs.get(wakeable): any): number);
-}
-
-export function markComponentSuspended(
-  fiber: Fiber,
-  wakeable: Wakeable,
-  lanes: Lanes,
-): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const eventType = wakeableIDs.has(wakeable) ? 'resuspend' : 'suspend';
-      const id = getWakeableID(wakeable);
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      const phase = fiber.alternate === null ? 'mount' : 'update';
-
-      // Following the non-standard fn.displayName convention,
-      // frameworks like Relay may also annotate Promises with a displayName,
-      // describing what operation/data the thrown Promise is related to.
-      // When this is available we should pass it along to the Timeline.
-      const displayName = (wakeable: any).displayName || '';
-
-      // TODO (timeline) Add component stack id
-      markAndClear(
-        `--suspense-${eventType}-${id}-${componentName}-${phase}-${lanes}-${displayName}`,
-      );
-      wakeable.then(
-        () => markAndClear(`--suspense-resolved-${id}-${componentName}`),
-        () => markAndClear(`--suspense-rejected-${id}-${componentName}`),
-      );
-    }
-  }
-}
-
-export function markLayoutEffectsStarted(lanes: Lanes): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear(`--layout-effects-start-${lanes}`);
-    }
-  }
-}
-
-export function markLayoutEffectsStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--layout-effects-stop');
-    }
-  }
-}
-
-export function markPassiveEffectsStarted(lanes: Lanes): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear(`--passive-effects-start-${lanes}`);
-    }
-  }
-}
-
-export function markPassiveEffectsStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--passive-effects-stop');
-    }
-  }
-}
-
-export function markRenderStarted(lanes: Lanes): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear(`--render-start-${lanes}`);
-    }
-  }
-}
-
-export function markRenderYielded(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--render-yield');
-    }
-  }
-}
-
-export function markRenderStopped(): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear('--render-stop');
-    }
-  }
-}
-
-export function markRenderScheduled(lane: Lane): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      markAndClear(`--schedule-render-${lane}`);
-    }
-  }
-}
-
-export function markForceUpdateScheduled(fiber: Fiber, lane: Lane): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--schedule-forced-update-${lane}-${componentName}`);
-    }
-  }
-}
-
-export function markStateUpdateScheduled(fiber: Fiber, lane: Lane): void {
-  if (enableSchedulingProfiler) {
-    if (supportsUserTimingV3) {
-      const componentName = getComponentNameFromFiber(fiber) || 'Unknown';
-      // TODO (timeline) Add component stack id
-      markAndClear(`--schedule-state-update-${lane}-${componentName}`);
-    }
-  }
-}
diff --git a/packages/react-reconciler/src/__tests__/ReactUpdaters-test.internal.js b/packages/react-reconciler/src/__tests__/ReactUpdaters-test.internal.js
index 7770c070667d6..44301017338cb 100644
--- a/packages/react-reconciler/src/__tests__/ReactUpdaters-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactUpdaters-test.internal.js
@@ -51,6 +51,32 @@ describe('updaters', () => {
       onCommitUnmount: jest.fn(() => {}),
       onPostCommitRoot: jest.fn(() => {}),
       onScheduleRoot: jest.fn(() => {}),
+
+      // Profiling APIs
+      markCommitStarted: jest.fn(() => {}),
+      markCommitStopped: jest.fn(() => {}),
+      markComponentRenderStarted: jest.fn(() => {}),
+      markComponentRenderStopped: jest.fn(() => {}),
+      markComponentPassiveEffectMountStarted: jest.fn(() => {}),
+      markComponentPassiveEffectMountStopped: jest.fn(() => {}),
+      markComponentPassiveEffectUnmountStarted: jest.fn(() => {}),
+      markComponentPassiveEffectUnmountStopped: jest.fn(() => {}),
+      markComponentLayoutEffectMountStarted: jest.fn(() => {}),
+      markComponentLayoutEffectMountStopped: jest.fn(() => {}),
+      markComponentLayoutEffectUnmountStarted: jest.fn(() => {}),
+      markComponentLayoutEffectUnmountStopped: jest.fn(() => {}),
+      markComponentErrored: jest.fn(() => {}),
+      markComponentSuspended: jest.fn(() => {}),
+      markLayoutEffectsStarted: jest.fn(() => {}),
+      markLayoutEffectsStopped: jest.fn(() => {}),
+      markPassiveEffectsStarted: jest.fn(() => {}),
+      markPassiveEffectsStopped: jest.fn(() => {}),
+      markRenderStarted: jest.fn(() => {}),
+      markRenderYielded: jest.fn(() => {}),
+      markRenderStopped: jest.fn(() => {}),
+      markRenderScheduled: jest.fn(() => {}),
+      markForceUpdateScheduled: jest.fn(() => {}),
+      markStateUpdateScheduled: jest.fn(() => {}),
     };
 
     jest.mock(
diff --git a/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js b/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js
deleted file mode 100644
index 6b1e4290d0102..0000000000000
--- a/packages/react-reconciler/src/__tests__/SchedulingProfiler-test.internal.js
+++ /dev/null
@@ -1,998 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @emails react-core
- * @jest-environment node
- */
-
-'use strict';
-
-describe('SchedulingProfiler', () => {
-  let React;
-  let ReactTestRenderer;
-  let ReactNoop;
-  let Scheduler;
-  let act;
-
-  let clearedMarks;
-  let featureDetectionMarkName = null;
-  let marks;
-
-  function createUserTimingPolyfill() {
-    featureDetectionMarkName = null;
-
-    clearedMarks = [];
-    marks = [];
-
-    // This is not a true polyfill, but it gives us enough to capture marks.
-    // Reference: https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
-    return {
-      clearMarks(markName) {
-        clearedMarks.push(markName);
-        marks = marks.filter(mark => mark !== markName);
-      },
-      mark(markName, markOptions) {
-        if (featureDetectionMarkName === null) {
-          featureDetectionMarkName = markName;
-        }
-        marks.push(markName);
-        if (markOptions != null) {
-          // This is triggers the feature detection.
-          markOptions.startTime++;
-        }
-      },
-    };
-  }
-
-  function clearPendingMarks() {
-    clearedMarks.splice(0);
-  }
-
-  function getMarks() {
-    return clearedMarks[0] === featureDetectionMarkName
-      ? clearedMarks.slice(1)
-      : clearedMarks;
-  }
-
-  beforeEach(() => {
-    jest.resetModules();
-
-    global.performance = createUserTimingPolyfill();
-
-    React = require('react');
-
-    // ReactNoop must be imported after ReactTestRenderer!
-    ReactTestRenderer = require('react-test-renderer');
-    ReactNoop = require('react-noop-renderer');
-
-    Scheduler = require('scheduler');
-    act = require('jest-react').act;
-  });
-
-  afterEach(() => {
-    // Verify all logged marks also get cleared.
-    expect(marks).toHaveLength(0);
-
-    delete global.performance;
-  });
-
-  // @gate !enableSchedulingProfiler
-  it('should not mark if enableSchedulingProfiler is false', () => {
-    ReactTestRenderer.create(<div />);
-    expect(getMarks()).toEqual([]);
-  });
-
-  it('should mark sync render without suspends or state updates', () => {
-    ReactTestRenderer.create(<div />);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-1",
-                "--render-start-1",
-                "--render-stop",
-                "--commit-start-1",
-                "--react-version-17.0.3",
-                "--profiler-version-1",
-                "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-                "--layout-effects-start-1",
-                "--layout-effects-stop",
-                "--commit-stop",
-              ]
-          `);
-    }
-  });
-
-  it('should mark concurrent render without suspends or state updates', () => {
-    ReactTestRenderer.create(<div />, {unstable_isConcurrent: true});
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--render-start-16",
-                "--render-stop",
-                "--commit-start-16",
-                "--react-version-17.0.3",
-                "--profiler-version-1",
-                "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-                "--layout-effects-start-16",
-                "--layout-effects-stop",
-                "--commit-stop",
-              ]
-          `);
-    }
-  });
-
-  it('should mark render yields', async () => {
-    function Bar() {
-      Scheduler.unstable_yieldValue('Bar');
-      return null;
-    }
-
-    function Foo() {
-      Scheduler.unstable_yieldValue('Foo');
-      return <Bar />;
-    }
-
-    if (gate(flags => flags.enableSyncDefaultUpdates)) {
-      React.startTransition(() => {
-        ReactNoop.render(<Foo />);
-      });
-
-      // Do one step of work.
-      expect(ReactNoop.flushNextYield()).toEqual(['Foo']);
-
-      if (gate(flags => flags.enableSchedulingProfiler)) {
-        expect(getMarks()).toMatchInlineSnapshot(`
-                  Array [
-                    "--schedule-render-64",
-                    "--render-start-64",
-                    "--component-render-start-Foo",
-                    "--component-render-stop",
-                    "--render-yield",
-                  ]
-              `);
-      }
-    } else {
-      ReactNoop.render(<Foo />);
-
-      // Do one step of work.
-      expect(ReactNoop.flushNextYield()).toEqual(['Foo']);
-
-      if (gate(flags => flags.enableSchedulingProfiler)) {
-        expect(getMarks()).toMatchInlineSnapshot(`
-                  Array []
-              `);
-      }
-    }
-  });
-
-  it('should mark sync render with suspense that resolves', async () => {
-    const fakeSuspensePromise = Promise.resolve(true);
-    function Example() {
-      throw fakeSuspensePromise;
-    }
-
-    ReactTestRenderer.create(
-      <React.Suspense fallback={null}>
-        <Example />
-      </React.Suspense>,
-    );
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-1",
-          "--render-start-1",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--suspense-suspend-0-Example-mount-1-",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-1",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-
-    clearPendingMarks();
-
-    await fakeSuspensePromise;
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--suspense-resolved-0-Example",
-              ]
-          `);
-    }
-  });
-
-  it('should mark sync render with suspense that rejects', async () => {
-    const fakeSuspensePromise = Promise.reject(new Error('error'));
-    function Example() {
-      throw fakeSuspensePromise;
-    }
-
-    ReactTestRenderer.create(
-      <React.Suspense fallback={null}>
-        <Example />
-      </React.Suspense>,
-    );
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-1",
-          "--render-start-1",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--suspense-suspend-0-Example-mount-1-",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-1",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-
-    clearPendingMarks();
-
-    await expect(fakeSuspensePromise).rejects.toThrow();
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--suspense-rejected-0-Example",
-              ]
-          `);
-    }
-  });
-
-  it('should mark concurrent render with suspense that resolves', async () => {
-    const fakeSuspensePromise = Promise.resolve(true);
-    function Example() {
-      throw fakeSuspensePromise;
-    }
-
-    ReactTestRenderer.create(
-      <React.Suspense fallback={null}>
-        <Example />
-      </React.Suspense>,
-      {unstable_isConcurrent: true},
-    );
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--suspense-suspend-0-Example-mount-16-",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-
-    clearPendingMarks();
-
-    await fakeSuspensePromise;
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--suspense-resolved-0-Example",
-              ]
-          `);
-    }
-  });
-
-  it('should mark concurrent render with suspense that rejects', async () => {
-    const fakeSuspensePromise = Promise.reject(new Error('error'));
-    function Example() {
-      throw fakeSuspensePromise;
-    }
-
-    ReactTestRenderer.create(
-      <React.Suspense fallback={null}>
-        <Example />
-      </React.Suspense>,
-      {unstable_isConcurrent: true},
-    );
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--suspense-suspend-0-Example-mount-16-",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-
-    clearPendingMarks();
-
-    await expect(fakeSuspensePromise).rejects.toThrow();
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--suspense-rejected-0-Example",
-              ]
-          `);
-    }
-  });
-
-  it('should mark cascading class component state updates', () => {
-    class Example extends React.Component {
-      state = {didMount: false};
-      componentDidMount() {
-        this.setState({didMount: true});
-      }
-      render() {
-        return null;
-      }
-    }
-
-    ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--schedule-state-update-1-Example",
-          "--layout-effects-stop",
-          "--render-start-1",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--commit-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('should mark cascading class component force updates', () => {
-    class Example extends React.Component {
-      componentDidMount() {
-        this.forceUpdate();
-      }
-      render() {
-        return null;
-      }
-    }
-
-    ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--schedule-forced-update-1-Example",
-          "--layout-effects-stop",
-          "--render-start-1",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--commit-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('should mark render phase state updates for class component', () => {
-    class Example extends React.Component {
-      state = {didRender: false};
-      render() {
-        if (this.state.didRender === false) {
-          this.setState({didRender: true});
-        }
-        return null;
-      }
-    }
-
-    ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(() => {
-      expect(Scheduler).toFlushUntilNextPaint([]);
-    }).toErrorDev('Cannot update during an existing state transition');
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--render-start-16",
-                "--component-render-start-Example",
-                "--schedule-state-update-16-Example",
-                "--component-render-stop",
-                "--render-stop",
-                "--commit-start-16",
-                "--react-version-17.0.3",
-                "--profiler-version-1",
-                "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-                "--layout-effects-start-16",
-                "--layout-effects-stop",
-                "--commit-stop",
-              ]
-          `);
-    }
-  });
-
-  it('should mark render phase force updates for class component', () => {
-    class Example extends React.Component {
-      state = {didRender: false};
-      render() {
-        if (this.state.didRender === false) {
-          this.forceUpdate(() => this.setState({didRender: true}));
-        }
-        return null;
-      }
-    }
-
-    ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(() => {
-      expect(Scheduler).toFlushUntilNextPaint([]);
-    }).toErrorDev('Cannot update during an existing state transition');
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--render-start-16",
-                "--component-render-start-Example",
-                "--schedule-forced-update-16-Example",
-                "--component-render-stop",
-                "--render-stop",
-                "--commit-start-16",
-                "--react-version-17.0.3",
-                "--profiler-version-1",
-                "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-                "--layout-effects-start-16",
-                "--layout-effects-stop",
-                "--commit-stop",
-              ]
-          `);
-    }
-  });
-
-  it('should mark cascading layout updates', () => {
-    function Example() {
-      const [didMount, setDidMount] = React.useState(false);
-      React.useLayoutEffect(() => {
-        setDidMount(true);
-      }, []);
-      return didMount;
-    }
-
-    ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--component-layout-effect-mount-start-Example",
-          "--schedule-state-update-1-Example",
-          "--component-layout-effect-mount-stop",
-          "--layout-effects-stop",
-          "--render-start-1",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--commit-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  // This test is coupled to lane implementation details, so I'm disabling it in
-  // the new fork until it stabilizes so we don't have to repeatedly update it.
-  it('should mark cascading passive updates', () => {
-    function Example() {
-      const [didMount, setDidMount] = React.useState(false);
-      React.useEffect(() => {
-        setDidMount(true);
-      }, []);
-      return didMount;
-    }
-
-    act(() => {
-      ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-    });
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-16",
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--layout-effects-stop",
-          "--commit-stop",
-          "--passive-effects-start-16",
-          "--component-passive-effect-mount-start-Example",
-          "--schedule-state-update-16-Example",
-          "--component-passive-effect-mount-stop",
-          "--passive-effects-stop",
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('should mark render phase updates', () => {
-    function Example() {
-      const [didRender, setDidRender] = React.useState(false);
-      if (!didRender) {
-        setDidRender(true);
-      }
-      return didRender;
-    }
-
-    act(() => {
-      ReactTestRenderer.create(<Example />, {unstable_isConcurrent: true});
-    });
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-16",
-          "--render-start-16",
-          "--component-render-start-Example",
-          "--schedule-state-update-16-Example",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('should mark sync render that throws', async () => {
-    class ErrorBoundary extends React.Component {
-      state = {error: null};
-      componentDidCatch(error) {
-        this.setState({error});
-      }
-      render() {
-        if (this.state.error) {
-          return null;
-        }
-        return this.props.children;
-      }
-    }
-
-    function ExampleThatThrows() {
-      throw Error('Expected error');
-    }
-
-    ReactTestRenderer.create(
-      <ErrorBoundary>
-        <ExampleThatThrows />
-      </ErrorBoundary>,
-    );
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-1",
-          "--render-start-1",
-          "--component-render-start-ErrorBoundary",
-          "--component-render-stop",
-          "--component-render-start-ExampleThatThrows",
-          "--component-render-start-ExampleThatThrows",
-          "--component-render-stop",
-          "--error-ExampleThatThrows-mount-Expected error",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-1",
-          "--schedule-state-update-1-ErrorBoundary",
-          "--layout-effects-stop",
-          "--commit-stop",
-          "--render-start-1",
-          "--component-render-start-ErrorBoundary",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('should mark concurrent render that throws', async () => {
-    spyOnProd(console, 'error');
-
-    class ErrorBoundary extends React.Component {
-      state = {error: null};
-      componentDidCatch(error) {
-        this.setState({error});
-      }
-      render() {
-        if (this.state.error) {
-          return null;
-        }
-        return this.props.children;
-      }
-    }
-
-    function ExampleThatThrows() {
-      // eslint-disable-next-line no-throw-literal
-      throw 'Expected error';
-    }
-
-    ReactTestRenderer.create(
-      <ErrorBoundary>
-        <ExampleThatThrows />
-      </ErrorBoundary>,
-      {unstable_isConcurrent: true},
-    );
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-              Array [
-                "--schedule-render-16",
-              ]
-          `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushUntilNextPaint([]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--render-start-16",
-          "--component-render-start-ErrorBoundary",
-          "--component-render-stop",
-          "--component-render-start-ExampleThatThrows",
-          "--component-render-start-ExampleThatThrows",
-          "--component-render-stop",
-          "--error-ExampleThatThrows-mount-Expected error",
-          "--render-stop",
-          "--render-start-16",
-          "--component-render-start-ErrorBoundary",
-          "--component-render-stop",
-          "--component-render-start-ExampleThatThrows",
-          "--component-render-start-ExampleThatThrows",
-          "--component-render-stop",
-          "--error-ExampleThatThrows-mount-Expected error",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--schedule-state-update-1-ErrorBoundary",
-          "--layout-effects-stop",
-          "--render-start-1",
-          "--component-render-start-ErrorBoundary",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--commit-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('should mark passive and layout effects', async () => {
-    function ComponentWithEffects() {
-      React.useLayoutEffect(() => {
-        Scheduler.unstable_yieldValue('layout 1 mount');
-        return () => {
-          Scheduler.unstable_yieldValue('layout 1 unmount');
-        };
-      }, []);
-
-      React.useEffect(() => {
-        Scheduler.unstable_yieldValue('passive 1 mount');
-        return () => {
-          Scheduler.unstable_yieldValue('passive 1 unmount');
-        };
-      }, []);
-
-      React.useLayoutEffect(() => {
-        Scheduler.unstable_yieldValue('layout 2 mount');
-        return () => {
-          Scheduler.unstable_yieldValue('layout 2 unmount');
-        };
-      }, []);
-
-      React.useEffect(() => {
-        Scheduler.unstable_yieldValue('passive 2 mount');
-        return () => {
-          Scheduler.unstable_yieldValue('passive 2 unmount');
-        };
-      }, []);
-
-      React.useEffect(() => {
-        Scheduler.unstable_yieldValue('passive 3 mount');
-        return () => {
-          Scheduler.unstable_yieldValue('passive 3 unmount');
-        };
-      }, []);
-
-      return null;
-    }
-
-    const renderer = ReactTestRenderer.create(<ComponentWithEffects />, {
-      unstable_isConcurrent: true,
-    });
-
-    expect(Scheduler).toFlushUntilNextPaint([
-      'layout 1 mount',
-      'layout 2 mount',
-    ]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-16",
-          "--render-start-16",
-          "--component-render-start-ComponentWithEffects",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-16",
-          "--component-layout-effect-mount-start-ComponentWithEffects",
-          "--component-layout-effect-mount-stop",
-          "--component-layout-effect-mount-start-ComponentWithEffects",
-          "--component-layout-effect-mount-stop",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-
-    clearPendingMarks();
-
-    expect(Scheduler).toFlushAndYield([
-      'passive 1 mount',
-      'passive 2 mount',
-      'passive 3 mount',
-    ]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--passive-effects-start-16",
-          "--component-passive-effect-mount-start-ComponentWithEffects",
-          "--component-passive-effect-mount-stop",
-          "--component-passive-effect-mount-start-ComponentWithEffects",
-          "--component-passive-effect-mount-stop",
-          "--component-passive-effect-mount-start-ComponentWithEffects",
-          "--component-passive-effect-mount-stop",
-          "--passive-effects-stop",
-        ]
-      `);
-    }
-
-    clearPendingMarks();
-
-    renderer.unmount();
-
-    expect(Scheduler).toFlushAndYield([
-      'layout 1 unmount',
-      'layout 2 unmount',
-      'passive 1 unmount',
-      'passive 2 unmount',
-      'passive 3 unmount',
-    ]);
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(getMarks()).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-render-16",
-          "--render-start-16",
-          "--render-stop",
-          "--commit-start-16",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--component-layout-effect-unmount-start-ComponentWithEffects",
-          "--component-layout-effect-unmount-stop",
-          "--component-layout-effect-unmount-start-ComponentWithEffects",
-          "--component-layout-effect-unmount-stop",
-          "--layout-effects-start-16",
-          "--layout-effects-stop",
-          "--commit-stop",
-          "--passive-effects-start-16",
-          "--component-passive-effect-unmount-start-ComponentWithEffects",
-          "--component-passive-effect-unmount-stop",
-          "--component-passive-effect-unmount-start-ComponentWithEffects",
-          "--component-passive-effect-unmount-stop",
-          "--component-passive-effect-unmount-start-ComponentWithEffects",
-          "--component-passive-effect-unmount-stop",
-          "--passive-effects-stop",
-        ]
-      `);
-    }
-  });
-});
diff --git a/packages/react-reconciler/src/__tests__/SchedulingProfilerLabels-test.internal.js b/packages/react-reconciler/src/__tests__/SchedulingProfilerLabels-test.internal.js
deleted file mode 100644
index a27c0271c116a..0000000000000
--- a/packages/react-reconciler/src/__tests__/SchedulingProfilerLabels-test.internal.js
+++ /dev/null
@@ -1,216 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @emails react-core
- */
-
-'use strict';
-
-// This test schedules work for as many lanes as we can (easily) using public APIs.
-// It will hopefully serve as a reminder to update getLabelsForLanes() when we update Lanes.
-// It's okay to delete any individual test in this file if the public API changes.
-describe('SchedulingProfiler labels', () => {
-  let React;
-  let ReactDOM;
-
-  let act;
-  let clearedMarks;
-  let featureDetectionMarkName = null;
-  let marks;
-
-  global.IS_REACT_ACT_ENVIRONMENT = true;
-
-  function polyfillJSDomUserTiming() {
-    featureDetectionMarkName = null;
-
-    clearedMarks = [];
-    marks = [];
-
-    // This is not a true polyfill, but it gives us enough to capture marks.
-    // Reference: https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
-
-    // JSDom already implements global.performance and it can't be overridden.
-    // However it only supports now() and timeOrigin() so we need to "upgrade it" in place.
-
-    if (!global.performance) {
-      global.performance = {};
-    }
-
-    global.performance.clearMarks = function clearMarks(markName) {
-      clearedMarks.push(markName);
-      marks = marks.filter(mark => mark !== markName);
-    };
-
-    global.performance.mark = function mark(markName, markOptions) {
-      if (featureDetectionMarkName === null) {
-        featureDetectionMarkName = markName;
-      }
-      marks.push(markName);
-      if (markOptions != null) {
-        // This is triggers the feature detection.
-        markOptions.startTime++;
-      }
-    };
-  }
-
-  function dispatchAndSetCurrentEvent(element, event) {
-    try {
-      window.event = event;
-      element.dispatchEvent(event);
-    } finally {
-      window.event = undefined;
-    }
-  }
-
-  beforeEach(() => {
-    jest.resetModules();
-
-    polyfillJSDomUserTiming();
-
-    React = require('react');
-    ReactDOM = require('react-dom');
-
-    const TestUtils = require('react-dom/test-utils');
-    act = TestUtils.act;
-  });
-
-  afterEach(() => {
-    // Verify all logged marks also get cleared.
-    expect(marks).toHaveLength(0);
-
-    delete global.performance;
-  });
-
-  it('regression test SyncLane', () => {
-    ReactDOM.render(<div />, document.createElement('div'));
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      expect(clearedMarks).toMatchInlineSnapshot(`
-              Array [
-                "__v3",
-                "--schedule-render-1",
-                "--render-start-1",
-                "--render-stop",
-                "--commit-start-1",
-                "--react-version-17.0.3",
-                "--profiler-version-1",
-                "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-                "--layout-effects-start-1",
-                "--layout-effects-stop",
-                "--commit-stop",
-              ]
-          `);
-    }
-  });
-
-  it('regression test DefaultLane', () => {
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      act(() => {
-        const container = document.createElement('div');
-        const root = ReactDOM.createRoot(container);
-
-        root.render(<div />);
-        expect(clearedMarks).toMatchInlineSnapshot(`
-                  Array [
-                    "__v3",
-                    "--schedule-render-16",
-                  ]
-              `);
-      });
-    }
-  });
-
-  it('regression test InputDiscreteLane', () => {
-    const container = document.createElement('div');
-    const root = ReactDOM.createRoot(container);
-    const targetRef = React.createRef(null);
-
-    function App() {
-      const [count, setCount] = React.useState(0);
-      const handleClick = () => {
-        setCount(count + 1);
-      };
-      return <button ref={targetRef} onClick={handleClick} />;
-    }
-
-    if (
-      gate(
-        flags => flags.enableSchedulingProfiler && !flags.enableLegacyFBSupport,
-      )
-    ) {
-      act(() => {
-        root.render(<App />);
-      });
-
-      clearedMarks.splice(0);
-
-      act(() => {
-        targetRef.current.click();
-      });
-
-      expect(clearedMarks).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-state-update-1-App",
-          "--render-start-1",
-          "--component-render-start-App",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-1",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-1",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-
-  it('regression test InputContinuousLane', () => {
-    const targetRef = React.createRef(null);
-
-    function App() {
-      const [count, setCount] = React.useState(0);
-      const handleMouseOver = () => setCount(count + 1);
-      return <div ref={targetRef} onMouseOver={handleMouseOver} />;
-    }
-
-    if (gate(flags => flags.enableSchedulingProfiler)) {
-      const container = document.createElement('div');
-      const root = ReactDOM.createRoot(container);
-
-      act(() => {
-        root.render(<App />);
-      });
-
-      clearedMarks.splice(0);
-
-      act(() => {
-        const event = document.createEvent('MouseEvents');
-        event.initEvent('mouseover', true, true);
-        dispatchAndSetCurrentEvent(targetRef.current, event);
-      });
-
-      expect(clearedMarks).toMatchInlineSnapshot(`
-        Array [
-          "--schedule-state-update-4-App",
-          "--render-start-4",
-          "--component-render-start-App",
-          "--component-render-stop",
-          "--render-stop",
-          "--commit-start-4",
-          "--react-version-17.0.3",
-          "--profiler-version-1",
-          "--react-lane-labels-Sync,InputContinuousHydration,InputContinuous,DefaultHydration,Default,TransitionHydration,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Transition,Retry,Retry,Retry,Retry,Retry,SelectiveHydration,IdleHydration,Idle,Offscreen",
-          "--layout-effects-start-4",
-          "--layout-effects-stop",
-          "--commit-stop",
-        ]
-      `);
-    }
-  });
-});
diff --git a/scripts/jest/matchers/profilerMatchers.js b/scripts/jest/matchers/profilerMatchers.js
deleted file mode 100644
index e69de29bb2d1d..0000000000000