Process synchronous event beats in the frame that requested them

[janicduplessis]

Summary:

EventEmitter::experimental_flushSync only requests an event beat; the beat is processed at the next EventBeat::induce. On iOS the run loop observer that induces the beat runs before Core Animation's commit observer, so a request made from layoutSubviews — inside CA's commit cycle — is only processed one frame later. Anything that reports layout-driven state to JS synchronously (VirtualView mode changes, and safe area insets in the PRs that build on this) renders a frame late in exactly the cases that matter.

AppleEventBeat now also schedules an induce in the display phase of the current commit cycle. Core Animation runs a commit as layout → display → commit, so a zero-sized layer marked as needing display during layout gets its display call after the whole layout pass and before the transaction is committed. That layer needs to live in the tree being committed, so the beat has to know which tree that is — and the emitter tells it:

• experimental_flushSync carries the tag of the emitting view through EventDispatcher and EventQueue to EventBeat::requestSynchronous(Tag), with kNoTag (Name the no-tag sentinel and use it for the hardcoded -1 tags #58531) meaning no view attribution; a no-argument overload keeps unattributed requesters and the existing tests unchanged. The emitter reads the tag from its ShadowNodeFamily at flush time; kNoTag if the family is already gone.
• AppleEventBeat resolves the tag to the layer of the view's window through a resolver injected by RCTSurfacePresenter (findComponentViewWithTag: on the mounting registry — nullable, non-creating, main thread) and attaches its flusher layer there. The requesting view's window is by definition the root of the layer tree whose layout emitted the request, so the flusher is guaranteed a display phase in the current commit cycle — including for content UIKit mounts in a window of its own, like a full screen modal or LogBox. Requests within one cycle coalesce into a single induce.

One related fix in EventBeat itself: a synchronous request is no longer stranded behind an already-scheduled asynchronous beat (it would silently lose its this-frame guarantee, and the leftover flag would make an unrelated later beat blocking). AppleEventBeat.cpp becomes .mm for the Objective-C.

Risk: this changes when queued events are flushed on iOS for every experimental_flushSync caller — today VirtualView, and safe area insets with the PRs on top. The worst case is a beat processed a frame earlier than before, inside a Core Animation commit; the run loop observer path is untouched and still catches anything the display phase misses (an emitter with no tag, an unmounted view, a request off the main thread). Android ignores the tag. Revert is self-contained.

Design Q&A:

What happens when two views in different windows update at once?
Each requesting window gets its own dirty flusher layer (the map is keyed by host layer), and the first display to fire induces the beat, which drains the whole event queue — every window's updates mount before that commit presents. The remaining flushers hit the isEventBeatRequested_ guard and no-op, so it is one beat total, not one per window. If windows ever commit in separate transactions, each request still resolves within its own window's cycle, since its layer sits in the tree that emitted it. Only requesting windows carry a dirty layer.

Can the tag point at the wrong view — after an unmount, or a recycled view?
No. The tag comes from the emitter's ShadowNodeFamily, and a family keeps one tag for its whole life, across clones and state updates; if the family is already gone the flush carries kNoTag and skips the resolver. What changes over a view's life — its window — is read live: the tag resolves to a view at flush time and view.window.layer is looked up then, so a view that moved between windows targets its current tree. A view mid-unmount or recycled resolves to nil (the registry erases the entry and recycled views get tag 0) and degrades to run-loop-observer timing. The tag only ever influences where the induce is scheduled, never what is delivered or to whom, so the blast radius of any staleness is one frame of timing, not correctness.

Does VirtualView need changes to benefit?
No — its sync mode-change flush goes through its own emitter, so the tag attribution is automatic. The case this improves is a mode change emitted during Core Animation layout (a resize pulling a virtualized item into view): on main that renders one frame late; here the induce lands in the display phase of the VirtualView's own window, including inside a full screen modal.

Changelog:

[INTERNAL] - Process synchronous event beats in the frame that requested them on iOS, scheduling the induce on the requesting view's window

Test Plan:

New unit tests in EventBeatTest.cpp cover the beat semantics: a synchronous request during an already-scheduled asynchronous beat, coalescing, and induce ordering. They drive the protected induce through a subclass standing in for the platform.

On device, with the safe area insets prop from the PRs above merged on top: an RNTester example renders a loud marker (yellow background) while a view observes the safe area but has not received an inset event yet, so any presented marker frame means the dispatch was not synchronous. The full apply → landscape → portrait sequence inside a full screen modal on an iPhone 17 Pro simulator, decomposed with ffmpeg into 982 frames and every frame scanned for the marker color — zero marker frames, and mid-rotation frames already carry the incoming orientation's insets, so the padding animates with the rotation. Scoped honestly: the first inset event after setting the prop is processed at the call site, so the marker primarily proves no regression; the same-frame path for layout-driven changes rests on the by-construction argument above plus the rotation frames.

tag-capture.mp4

yarn fantom .../ViewSafeAreaInsets-itest.js passes 4/4 with the prop merged on top. C++ API snapshots regenerated (scripts/cxx-api/parser, Doxygen 1.16.1): the deltas are the requestSynchronous overload pair, EventEmitter::getTag, the resolver type, and the AppleEventBeat constructor and destructor.

---

Stack — split out of #57967, which stays open as the prototype and design discussion. GitHub will not take a fork branch as a pull request base, so each of these targets main and its diff contains the ones below it until they merge. Each PR is one commit on top of the previous one.

This is the bottom of the stack, so its diff is already just this change.

👉 1. #58530 — Process synchronous event beats in the frame that requested them
2. #58109 — Add an experimental_onSafeAreaInsetsChange view prop
3. #58110 — Report the window safe area insets through Dimensions
4. #58112 — Render the internal SafeAreaView from the safe area insets prop
5. #58113 — Remove the native SafeAreaView and the deprecated public export

An earlier variant that targeted the surface's root view instead of the view's window was closed in #58528; its review thread carries the analysis behind the window-based resolution. #58108 was the per-window predecessor this supersedes.

[janicduplessis]

@Abbondanzo This one is ready for review, the 2nd PR of the safe area insets stack. I changed the approach a little bit from what you reviewed initially, I think it is a lot cleaner this way, just a little bit more plumbing to pass around the view tag, but allows to avoid looping through every windows which I really didn't like.

[meta-codesync]

@Abbondanzo has imported this pull request. If you are a Meta employee, you can view this in D120200496.

[janicduplessis]

@Abbondanzo Rebased on top of the tag PR that landed.

[meta-codesync]

@Abbondanzo merged this pull request in b439ef7.