react-native(fabric): native proof-of-delivery props elision (Stage 2)

The full serialized _uikitHostPropsJson rides on EVERY host lifecycle
crossing (NativeScriptUIView runUIKitHostLifecycle:transactionJson:)
and is re-marshalled through a JSI string copy on the worklet side
(NativeScriptNativeApiModule's createFromUtf8) even though the JS-side
memo (lastNativePropsJson, already landed) makes the *apply* a no-op
once JS has these exact bytes.

Adds _lastDeliveredUikitHostPropsJson: the props string last DELIVERED
where a crossing proved (via a non-nil handles return) that JS had a
live registration to memo it on. The per-crossing call now elides
props (sends nil) only when the current _uikitHostPropsJson is
byte-identical to that marker; JS already treats empty/missing props
as a pure no-op (syncUIKitHostPropsFromNative's typeof guard), so
elision is outcome-identical to today's JS-side memo hit.

Fail-open by construction: the marker is set only on a non-nil
(proof-of-delivery) handles return and is cleared on any other
outcome (create-miss, JS-side exception) so the very next crossing
resends unconditionally; it is also cleared on any -setHostId: change
(a fresh registration has no memo of its own), which covers
-prepareForRecycle since that routes through the hostId setter. No JS
changes needed.

Extends the structural node test with tripwires for the fail-open
reset points (setHostId clear, dealloc release) and the elision
predicate (byte comparison of the pending call, never a hostId-keyed
side cache).

Verified: itest --suite slide (pop-slide 9/10, edge-swipe-slide 5/5,
zero strands/rehost/bypass -- matches this session's established noise
floor, see the Stage 1 commit), --suite core (11/12, one borderline
MAIN_THREAD_STALL_STEADY jitter scenario, same pattern as pristine
baseline under load), --suite parity (14/14), --suite reveal (12/12 --
the cold-first create/replay windows this change touches), and the
plain-node structural tests (35/38, 3 pre-existing/unrelated).

Honest sizing (Stage 0, NS_NS_HOST_PROFILE): for this demo app's
crossings, native jsMs already tracked the JS-side "rest" bucket almost
exactly (e.g. 82.2ms vs 82.0ms), meaning the props-marshal gap this
stage targets was not separately measurable at this app's payload
sizes -- the design's hypothesis that this dominates the 250-370ms
burst did not hold here. Landed anyway per the design (cheap,
fail-open, protects larger payloads); the real remaining cost is
adapter-side reconcile/handler execution, out of scope (design doc
Sec 6.5/6.6).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: DjDeveloperr

packages/react-native/ios/NativeScriptUIView.mm

@@ -1858,6 +1858,17 @@ @implementation NativeScriptUIView {
   // now-deleted _mountingTransactionToken and
   // _fabricTransactionCommitFallbackToken.
   NSUInteger _fabricTransactionDeliveryToken;
+  // Stage 2 (update-phase crossing optimization, native proof-of-delivery
+  // props elision): the full serialized _uikitHostPropsJson rides on EVERY
+  // host lifecycle crossing and is re-marshalled through a JSI string copy
+  // on the worklet side even though the JS memo (lastNativePropsJson) makes
+  // the *apply* a no-op when it is unchanged. This remembers the props
+  // string last DELIVERED where the crossing proved (via a non-nil handles
+  // return) that JS had a live registration to memo it on -- see
+  // -runUIKitHostLifecycle:transactionJson: for the elision and every reset
+  // point (nil-handle return, -setHostId: change, which also covers
+  // -prepareForRecycle since it routes through the hostId setter).
+  NSString* _lastDeliveredUikitHostPropsJson;
 }
 
 - (instancetype)initWithFrame:(CGRect)frame {
@@ -1911,6 +1922,7 @@ - (void)dealloc {
   [_hostReadyId release];
   [_debugName release];
   [_uikitHostPropsJson release];
+  [_lastDeliveredUikitHostPropsJson release];
   [_onHostReady release];
   [_lastDetachedChildrenLayoutKey release];
   [_lastDetachedChildrenDisplayKey release];
@@ -2010,6 +2022,13 @@ - (void)setHostId:(NSString*)hostId {
   _hasCreatedUIKitHost = NO;
   _hasDeliveredMountedLifecycle = NO;
   _hasReplayedFabricTransactionAfterHostCreation = NO;
+  // Stage 2 proof-of-delivery marker: a new hostId means a completely fresh
+  // JS-side registration (no lastNativePropsJson memo of its own yet), so
+  // any elision decision made for the previous hostId is meaningless here --
+  // always resend on the next crossing. Also the -prepareForRecycle reset
+  // path (it sets hostId to nil, routing through this setter).
+  [_lastDeliveredUikitHostPropsJson release];
+  _lastDeliveredUikitHostPropsJson = nil;
   [_fabricMountedChildLifecycleKeys removeAllObjects];
   [self setNeedsUIKitHostRefreshAfterNativeAttachment];
   [self invalidateHostReadySnapshot];
@@ -2808,12 +2827,45 @@ - (void)runUIKitHostLifecycle:(NSString*)phase transactionJson:(NSString*)transa
   }
 
   [self mountUIKitHostIfNeeded];
+
+  // Stage 2 (proof-of-delivery props elision): _uikitHostPropsJson is a
+  // multi-KB serialized snapshot that otherwise rides on EVERY crossing --
+  // re-marshalled through a JSI string copy on the worklet side even though
+  // the JS-side memo (lastNativePropsJson) already makes the *apply* a
+  // no-op once JS has these exact bytes. Elide it (send nil) only when a
+  // PRIOR crossing already delivered these exact bytes AND proved (via a
+  // non-nil handles return) that JS had a live registration to memo them
+  // on. JS treats empty/missing props as a pure no-op
+  // (syncUIKitHostPropsFromNative's typeof guard) -- identical outcome to
+  // today's memo hit, so eliding changes nothing JS observes.
+  BOOL canElideProps = _lastDeliveredUikitHostPropsJson != nil &&
+      ((_lastDeliveredUikitHostPropsJson == _uikitHostPropsJson) ||
+       [_lastDeliveredUikitHostPropsJson isEqualToString:_uikitHostPropsJson]);
+  NSString* propsJsonForCrossing = canElideProps ? nil : _uikitHostPropsJson;
+
   NSDictionary<NSString*, NSString*>* handles =
       transactionJson.length > 0
-          ? NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, _uikitHostPropsJson,
+          ? NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, propsJsonForCrossing,
                                                       transactionJson, [self nativeMountInfoJson])
-          : NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, _uikitHostPropsJson, nil,
+          : NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, propsJsonForCrossing, nil,
                                                       [self nativeMountInfoJson]);
+
+  // Fail open: a non-nil handles return is the delivery receipt (JS ran the
+  // crossing against a live registration), so these exact bytes are now
+  // known-delivered -- elide them next time. ANY other outcome (nil
+  // handles: create-miss, JS-side exception, etc.) clears the marker so the
+  // very next crossing resends unconditionally rather than risk a
+  // false-elided delivery.
+  if (handles != nil) {
+    if (_lastDeliveredUikitHostPropsJson != _uikitHostPropsJson) {
+      [_lastDeliveredUikitHostPropsJson release];
+      _lastDeliveredUikitHostPropsJson = [_uikitHostPropsJson copy];
+    }
+  } else if (_lastDeliveredUikitHostPropsJson != nil) {
+    [_lastDeliveredUikitHostPropsJson release];
+    _lastDeliveredUikitHostPropsJson = nil;
+  }
+
   [self applyUIKitHostHandles:handles];
 }
 

packages/react-native/test/uikit-host-native-props-api.test.js

@@ -171,17 +171,76 @@ assert(
 	    hostView.includes("_hasCreatedUIKitHost = YES;") &&
 	    hostView.includes("_hostId.length == 0 || _hasCreatedUIKitHost") &&
 	    hostView.includes("NativeScriptRunUIKitHostLifecycleWithInfo(") &&
+	    // Stage 2 (update-phase crossing optimization, native proof-of-delivery
+	    // props elision): the per-crossing lifecycle call now sends
+	    // propsJsonForCrossing (nil when a prior crossing already delivered
+	    // these exact bytes to a live JS registration), not the raw
+	    // _uikitHostPropsJson unconditionally -- see the elision block and its
+	    // reset points below.
 	    normalizedHostView.includes(
-	      "NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, _uikitHostPropsJson, transactionJson, [self nativeMountInfoJson])"
+	      "NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, propsJsonForCrossing, transactionJson, [self nativeMountInfoJson])"
 	    ) &&
 	    normalizedHostView.includes(
-	      "NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, _uikitHostPropsJson, nil, [self nativeMountInfoJson])"
+	      "NativeScriptRunUIKitHostLifecycleWithInfo(_hostId, phase, propsJsonForCrossing, nil, [self nativeMountInfoJson])"
 	    ) &&
 	    hostView.indexOf("NativeScriptRunUIKitHostLifecycleWithInfo(") >
 	      hostView.indexOf("- (void)runUIKitHostLifecycle:"),
   "NativeScriptUIView should forward latest props and native mount info while avoiding already-mounted native host recreation before every lifecycle call",
 );
 
+// Stage 2 tripwires: the elision must be provably fail-open (every reset
+// point present) and must never be computed from anything but a raw string
+// comparison against the bytes native is about to send.
+const runLifecycleIndex = hostView.indexOf(
+  "- (void)runUIKitHostLifecycle:(NSString*)phase transactionJson:",
+);
+const runLifecycleBody = hostView.slice(
+  runLifecycleIndex,
+  hostView.indexOf("\n- (void)runUIKitHostLifecycle:(NSString*)phase {", runLifecycleIndex),
+);
+
+assert(
+  runLifecycleIndex > -1 &&
+    runLifecycleBody.includes("_lastDeliveredUikitHostPropsJson != nil") &&
+    runLifecycleBody.includes(
+      "[_lastDeliveredUikitHostPropsJson isEqualToString:_uikitHostPropsJson]",
+    ) &&
+    runLifecycleBody.includes(
+      "NSString* propsJsonForCrossing = canElideProps ? nil : _uikitHostPropsJson;",
+    ),
+  "the props elision predicate must compare raw bytes on the pending call, never a hostId-keyed side cache",
+);
+
+assert(
+  runLifecycleBody.includes("if (handles != nil) {") &&
+    runLifecycleBody.includes(
+      "_lastDeliveredUikitHostPropsJson = [_uikitHostPropsJson copy];",
+    ) &&
+    runLifecycleBody.includes("} else if (_lastDeliveredUikitHostPropsJson != nil) {") &&
+    runLifecycleBody.includes("_lastDeliveredUikitHostPropsJson = nil;") &&
+    runLifecycleBody.indexOf("if (handles != nil) {") <
+      runLifecycleBody.indexOf("[self applyUIKitHostHandles:handles];"),
+  "the delivered-props marker must be fail-open: set only on a non-nil (proof-of-delivery) handles return, cleared on any other outcome, before handles are applied",
+);
+
+const setHostIdIndex = hostView.indexOf("- (void)setHostId:(NSString*)hostId {");
+const setHostIdBody = hostView.slice(
+  setHostIdIndex,
+  hostView.indexOf("\n- (void)setHostReadyId:", setHostIdIndex),
+);
+assert(
+  setHostIdIndex > -1 &&
+    setHostIdBody.includes("[_lastDeliveredUikitHostPropsJson release];") &&
+    setHostIdBody.includes("_lastDeliveredUikitHostPropsJson = nil;"),
+  "a hostId change (including the -prepareForRecycle reset, which routes through this setter) must clear the delivered-props marker -- a fresh registration has no memo of its own",
+);
+
+assert(
+  hostView.includes("[_lastDeliveredUikitHostPropsJson release];\n}") ||
+    /dealloc[\s\S]*?_lastDeliveredUikitHostPropsJson release\]/.test(hostView),
+  "the delivered-props marker ivar must be released in -dealloc (manual reference counting)",
+);
+
 assert(
   fabricView.includes("newViewProps->uikitHostPropsJson") &&
     fabricView.includes("_containerView.uikitHostPropsJson = uikitHostPropsJson") &&