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