fix: preserve initializer receiver identity

Author: DjDeveloperr

NativeScript/ffi/hermes/NativeApiJsi.mm

@@ -303,8 +303,15 @@ throw JSError(runtime,
           throw JSError(runtime,
                         "Objective-C selector requires a native receiver.");
         }
-        return receiverHostObject->callPreparedObjectSelector(
+        Value result = receiverHostObject->callPreparedObjectSelector(
             runtime, *prepared, args, count, gsdDispatchClass);
+        if (!receiverIsClass && prepared->isInitMethod) {
+          if (auto preserved = preservedNativeApiInitializerSelfReturn(
+                  runtime, bridge, receiver, result, thisValue)) {
+            return *preserved;
+          }
+        }
+        return result;
       });
 }
 

NativeScript/ffi/jsc/NativeApiJSCSelectorGroups.mm

@@ -398,9 +398,18 @@ throw JSError(runtime,
         data->cachedDispatchClass = dispatchClass;
       }
     }
-    return setJSCEnginePreparedObjCResult(
+    JSValueRef result = setJSCEnginePreparedObjCResult(
         runtime, data->bridge, receiver, *prepared, receiverHostObject,
         initializerClassWrapper, argumentCount, arguments, dispatchClass);
+    if (!data->receiverIsClass && prepared->isInitMethod &&
+        thisObject != nullptr) {
+      if (auto preserved = preservedNativeApiInitializerSelfReturn(
+              runtime, data->bridge, receiver, Value::borrowed(runtime, result),
+              Value::borrowed(runtime, thisObject))) {
+        return preserved->local(runtime);
+      }
+    }
+    return result;
   } catch (const std::exception& error) {
     engine::jscengine::setException(context, exception, error);
     return JSValueMakeUndefined(context);

NativeScript/ffi/quickjs/NativeApiQuickJSSelectorGroups.mm

@@ -411,9 +411,18 @@ throw JSError(runtime,
         data->cachedDispatchClass = dispatchClass;
       }
     }
-    return setQuickJSEnginePreparedObjCResult(
+    JSValue result = setQuickJSEnginePreparedObjCResult(
         runtime, data->bridge, receiver, *prepared, receiverHostObject,
         initializerClassWrapper, count, argv, dispatchClass);
+    if (!data->receiverIsClass && prepared->isInitMethod) {
+      if (auto preserved = preservedNativeApiInitializerSelfReturn(
+              runtime, data->bridge, receiver, Value::borrowed(runtime, result),
+              Value::borrowed(runtime, thisValue))) {
+        JS_FreeValue(context, result);
+        return preserved->local(runtime);
+      }
+    }
+    return result;
   } catch (const std::exception& error) {
     return engine::quickjsengine::throwError(context, error);
   }

NativeScript/ffi/shared/bridge/ClassBuilder.mm

@@ -80,6 +80,36 @@ void rememberNativeApiKnownExposedMethod(
   return std::nullopt;
 }
 
+std::optional<Value> preservedNativeApiInitializerSelfReturn(
+    Runtime& runtime, const std::shared_ptr<NativeApiBridge>& bridge,
+    id receiver, const Value& result, const Value& receiverValue) {
+  if (bridge == nullptr || receiver == nil || !receiverValue.isObject()) {
+    return std::nullopt;
+  }
+
+  id resultObject =
+      NativeApiObjectHostObject::nativeObjectFromValue(runtime, result);
+  if (resultObject != receiver) {
+    return std::nullopt;
+  }
+
+  Object receiverObject = receiverValue.asObject(runtime);
+  if (!receiverObject.isHostObject<NativeApiObjectHostObject>(runtime)) {
+    return std::nullopt;
+  }
+
+  auto receiverHostObject =
+      receiverObject.getHostObject<NativeApiObjectHostObject>(runtime);
+  if (receiverHostObject == nullptr ||
+      receiverHostObject->object() != receiver) {
+    return std::nullopt;
+  }
+
+  Value preserved(runtime, receiverValue);
+  bridge->rememberRoundTripValue(runtime, receiver, preserved);
+  return preserved;
+}
+
 Value callNativeApiBaseObjectSelector(
     Runtime& runtime, const std::shared_ptr<NativeApiBridge>& bridge,
     const Object& receiverObject,
@@ -90,19 +120,15 @@ Value callNativeApiBaseObjectSelector(
   Value result = receiverHostObject->callObjectSelector(
       runtime, selectorName, member, args, count, dispatchClass);
 
-  if (selectorName.rfind("init", 0) != 0 || receiver == nil) {
+  if (selectorName.rfind("init", 0) != 0) {
     return result;
   }
 
-  id resultObject =
-      NativeApiObjectHostObject::nativeObjectFromValue(runtime, result);
-  if (resultObject != receiver) {
-    return result;
+  if (auto preserved = preservedNativeApiInitializerSelfReturn(
+          runtime, bridge, receiver, result, Value(runtime, receiverObject))) {
+    return *preserved;
   }
-
-  bridge->rememberRoundTripValue(runtime, receiver,
-                                 Value(runtime, receiverObject));
-  return Value(runtime, receiverObject);
+  return result;
 }
 
 const char* nativeApiEngineFastEnumerationEncoding() {

NativeScript/ffi/shared/bridge/Install.mm

@@ -972,18 +972,7 @@ function installSelectorGroups(target, groups, receiverIsClass) {
                     return rememberInstanceClass(fn(...args));
                   };
                 })(selectorFunction, name)
-              : (function(fn, memberName) {
-                  return function() {
-                    if (this && typeof this === 'object' && this.kind === 'object') {
-                      var baseArgs = [nativeClass, this, memberName];
-                      for (var baseArgIndex = 0; baseArgIndex < arguments.length; baseArgIndex++) {
-                        baseArgs.push(arguments[baseArgIndex]);
-                      }
-                      return api.__invokeBase(...baseArgs);
-                    }
-                    return fn.apply(this, arguments);
-                  };
-                })(selectorFunction, name)
+              : selectorFunction
           });
       }
     }

NativeScript/ffi/v8/NativeApiV8SelectorGroups.mm

@@ -422,6 +422,14 @@ throw JSError(runtime,
     setV8EnginePreparedObjCResult(runtime, data->bridge, receiver, *prepared,
                                   receiverHostObject, initializerClassWrapper,
                                   info, dispatchClass);
+    if (!data->receiverIsClass && prepared->isInitMethod) {
+      if (auto preserved = preservedNativeApiInitializerSelfReturn(
+              runtime, data->bridge, receiver,
+              Value(runtime, info.GetReturnValue().Get()),
+              Value(runtime, info.This()))) {
+        info.GetReturnValue().Set(preserved->local(runtime));
+      }
+    }
   } catch (const std::exception& exception) {
     engine::v8engine::throwV8Exception(info.GetIsolate(), exception);
   }

PROGRESS.md

@@ -17,6 +17,40 @@ TypeScript/UI worklets.
 
 ## Latest Update - 2026-06-29
 
+### 2026-06-29 21:15 EDT - initializer self-return receiver preservation
+
+- Goal:
+  - Continue unblocking PR #46's runtime CI without drifting back into the
+    original Node-API/direct-engine refactor branch. Simulator-only rule remains
+    active; no physical devices were used.
+- CI finding:
+  - Run `28412396190` still failed in macOS `ApiTests.js
+    NSMutableArrayMethods` with `_array` missing during native `addObject:`.
+  - The previous broad JS instance-selector trampoline had moved execution past
+    the iOS init hang, but it also bypassed the JS wrapper that should carry
+    `_array`, so it was the wrong layer for the final fix.
+- Changes:
+  - Removed the global instance selector wrapper that routed native receivers
+    through `__invokeBase`.
+  - Added a generic bridge helper that preserves the original JS receiver when
+    an Objective-C initializer returns the same native object.
+  - Wired that helper into JSC, V8, QuickJS, Hermes, and the existing
+    `__invokeBase` path so `Base.prototype.init.apply(this, arguments)` keeps
+    receiver identity without hijacking ordinary instance selector dispatch.
+- Verification:
+  - Runtime RN JS tests passed:
+    `for f in packages/react-native/test/*.test.js; do node "$f" || exit 1; done`.
+  - `git diff --check` passed.
+  - `npm run check:ffi-boundaries` passed.
+  - `npm run build:macos-cli` passed.
+  - Focused local macOS `NSMutableArrayMethods` testing is still blocked before
+    launch by the known metadata-generator x86_64/libclang mismatch, so GitHub
+    Actions remains the native macOS/iOS simulator authority.
+- Still next:
+  - Commit/push the initializer receiver preservation fix and watch fresh PR CI.
+  - If CI proves the runtime fix, clean the diagnostic history before resuming
+    the dedicated simulator-only RNS parity sweep.
+
 ### 2026-06-29 18:19 EDT - indexed collection subclass aliases
 
 - Goal:

RN_API.md

@@ -41,6 +41,20 @@ UIKit-backed React Native libraries in TypeScript/UI worklets.
   - Objective-C `Class` values returned through generic object conversion must
     become native class wrappers, not ordinary object wrappers.
 
+## 2026-06-29 Native Initializer Receiver Identity
+
+- No new public NativeScript React Native API was added.
+- Generic native bridge behavior was clarified for JS/TypeScript native
+  subclasses:
+  - When an Objective-C initializer called through a base prototype returns the
+    same native receiver, the bridge must return and re-cache the original JS
+    receiver object.
+  - This preserves JS expandos/state established in upstream-style
+    `Base.prototype.init.apply(this, arguments)` overrides without routing all
+    instance selector calls through a JS `__invokeBase` trampoline.
+  - If native initialization substitutes a different Objective-C object, the
+    bridge must keep returning the substituted object wrapper.
+
 ## 2026-06-29 Simulator Latency Comparison
 
 - No new public NativeScript React Native API was added.

packages/react-native/test/runtime-instance-selector-base-dispatch.test.js

@@ -12,18 +12,19 @@ for (const relativePath of [
 
   const invokeBaseCount = source.match(/return api\.__invokeBase\(\.\.\.baseArgs\);/g)?.length ?? 0;
   assert(
-    invokeBaseCount >= 2,
-    `${relativePath}: class and instance selector wrappers should route native receivers through __invokeBase`,
+    invokeBaseCount === 1,
+    `${relativePath}: only class selector wrappers should route native receivers through __invokeBase`,
   );
   assert(
-    source.includes("return fn.apply(this, arguments);"),
-    `${relativePath}: instance selector wrapper should preserve normal this-bound fallback dispatch`,
+    !source.includes("return fn.apply(this, arguments);"),
+    `${relativePath}: instance selector wrappers should not globally reroute native receivers through __invokeBase`,
   );
   assert(
     source.includes("value: receiverIsClass") &&
-      source.includes(": (function(fn, memberName) {") &&
-      source.includes("var baseArgs = [nativeClass, this, memberName];"),
-    `${relativePath}: instance selector wrapper should build base invocation arguments from nativeClass, receiver, and member name`,
+      source.includes("? (function(fn, memberName) {") &&
+      source.includes("var baseArgs = [nativeClass, this, memberName];") &&
+      source.includes(": selectorFunction"),
+    `${relativePath}: class selector wrappers should keep base invocation support while instance selectors use engine dispatch`,
   );
 }
 
@@ -34,19 +35,39 @@ for (const relativePath of [
   const source = fs.readFileSync(path.join(repoRoot, relativePath), "utf8");
 
   assert(
-    source.includes("Value callNativeApiBaseObjectSelector("),
-    `${relativePath}: base dispatch should go through the receiver-preserving helper`,
+    source.includes("std::optional<Value> preservedNativeApiInitializerSelfReturn("),
+    `${relativePath}: runtime should expose the initializer self-preservation helper`,
   );
   assert(
-    source.includes('selectorName.rfind("init", 0) != 0') &&
+    source.includes("receiverHostObject->object() != receiver") &&
       source.includes("NativeApiObjectHostObject::nativeObjectFromValue(runtime, result)") &&
       source.includes("bridge->rememberRoundTripValue(runtime, receiver,") &&
-      source.includes("return Value(runtime, receiverObject);"),
-    `${relativePath}: base initializer dispatch should preserve receiver wrapper identity when init returns self`,
+      source.includes("return preserved;"),
+    `${relativePath}: initializer dispatch should preserve the original JS receiver when native init returns self`,
   );
   assert(
-    source.includes("return callNativeApiBaseObjectSelector("),
-    `${relativePath}: __invokeBase should use receiver-preserving selector calls`,
+    source.includes("preservedNativeApiInitializerSelfReturn(") &&
+      source.includes("Value(runtime, receiverObject)"),
+    `${relativePath}: __invokeBase should use the shared initializer self-preservation helper`,
+  );
+}
+
+for (const relativePath of [
+  "NativeScript/ffi/jsc/NativeApiJSCSelectorGroups.mm",
+  "NativeScript/ffi/v8/NativeApiV8SelectorGroups.mm",
+  "NativeScript/ffi/quickjs/NativeApiQuickJSSelectorGroups.mm",
+  "NativeScript/ffi/hermes/NativeApiJsi.mm",
+  "packages/react-native/native-api/ffi/hermes/NativeApiJsi.mm",
+]) {
+  const fullPath = path.join(repoRoot, relativePath);
+  if (!fs.existsSync(fullPath)) {
+    continue;
+  }
+  const source = fs.readFileSync(fullPath, "utf8");
+  assert(
+    source.includes("prepared->isInitMethod") &&
+      source.includes("preservedNativeApiInitializerSelfReturn("),
+    `${relativePath}: engine selector groups should preserve the original receiver when init returns self`,
   );
 }