This test works:
```js
let interaction;

const onRender = jest.fn();

SchedulerTracing.unstable_trace("initial_event", performance.now(), () => {
  const interactions = SchedulerTracing.unstable_getCurrent();
  expect(interactions.size).toBe(1);
  interaction = Array.from(interactions)[0];

  ReactDOM.render(
    <React.Profiler id="profiler" onRender={onRender}>
      <Text text="Hi" />
    </React.Profiler>,
    document.createElement("div")
  );
});

expect(interaction).toBeDefined();
expect(onRender).toHaveBeenCalledTimes(1);
expect(onRender.mock.calls[0][6]).toContain(interaction);
```

But if you wrap it in `act`, it fails:
```js
let interaction;

const onRender = jest.fn();

TestUtils.act(() => {
  SchedulerTracing.unstable_trace("initial_event", performance.now(), () => {
    const interactions = SchedulerTracing.unstable_getCurrent();
    expect(interactions.size).toBe(1);
    interaction = Array.from(interactions)[0];

    ReactDOM.render(
      <React.Profiler id="profiler" onRender={onRender}>
        <Text text="Hi" />
      </React.Profiler>,
      document.createElement("div")
    );
  });

  expect(interaction).toBeDefined();
  expect(onRender).toHaveBeenCalledTimes(1);
  expect(onRender.mock.calls[0][6]).toContain(interaction);
});
```

In the latter case, inside of `ReactFiberScheduler`, the interactions `Set` is empty.
https://github.com/facebook/react/blob/2e5d1a8b9e2c29418a27b24306e4c8d5f8681f4f/packages/react-reconciler/src/ReactFiberScheduler.js#L2119-L2126

Note that this does not seem to impact _updates_, only the initial _mount_. I suspect we just need to wrap a callback or something minor.

I came across this while trying to write profiling tests for the new DevTools. (https://github.com/bvaughn/react-devtools-experimental/pull/258)
let rootWithNestedUpdates: FiberRoot | null = null;
const NESTED_PASSIVE_UPDATE_LIMIT = 50;
let nestedPassiveUpdateCount: number = 0;
let interruptedBy: Fiber | null = null;
// Expiration times are computed by adding to the current time (the start
// time). However, if two updates are scheduled within the same event, we
// should treat their start times as simultaneous, even if the actual clock
// time has advanced between the first and second call.
// In other words, because expiration times determine how updates are batched,
// we want all updates of like priority that occur within the same event to
// receive the same expiration time. Otherwise we get tearing.
let currentEventTime: ExpirationTime = NoWork;
export function requestCurrentTime() {
  if (workPhase === RenderPhase || workPhase === CommitPhase) {
    
    return msToExpirationTime(now());
  }
  // We're not inside React, so we may be in the middle of a browser event.
  if (currentEventTime !== NoWork) {
    
    return currentEventTime;
  }
  // This is the first update since React yielded. Compute a new start time.
  currentEventTime = msToExpirationTime(now());
  return currentEventTime;
}
export function computeExpirationForFiber(
  currentTime: ExpirationTime,
  fiber: Fiber,
): ExpirationTime {