fix: persist JS subclass instance fields

Author: DjDeveloperr

NativeScript/ffi/shared/bridge/HostObjects.mm

@@ -1354,6 +1354,48 @@ bool invokeEnginePrototypeSetter(Runtime& runtime, const std::string& property,
     return false;
   }
 
+  bool enginePrototypeHasSetter(Runtime& runtime,
+                                const std::string& property) {
+    if (object_ == nil || property.empty()) {
+      return false;
+    }
+    Value classWrapperValue =
+        bridge_->findObjectExpando(runtime, object_, "__nativeApiClassWrapper");
+    if (!classWrapperValue.isObject()) {
+      classWrapperValue =
+          bridge_->findClassValue(runtime, object_getClass(object_));
+    }
+    if (!classWrapperValue.isObject()) {
+      return false;
+    }
+    Value prototypeValue =
+        classWrapperValue.asObject(runtime).getProperty(runtime, "prototype");
+    if (!prototypeValue.isObject()) {
+      return false;
+    }
+    Object objectConstructor =
+        runtime.global().getPropertyAsObject(runtime, "Object");
+    Function getOwnPropertyDescriptor =
+        objectConstructor.getPropertyAsFunction(runtime, "getOwnPropertyDescriptor");
+    Function getPrototypeOf =
+        objectConstructor.getPropertyAsFunction(runtime, "getPrototypeOf");
+    Value propertyName = makeString(runtime, property);
+    Value currentValue(runtime, prototypeValue);
+    for (size_t depth = 0; depth < 64 && currentValue.isObject(); depth++) {
+      Object current = currentValue.asObject(runtime);
+      Value descriptorValue = getOwnPropertyDescriptor.call(
+          runtime, Value(runtime, current), propertyName);
+      if (descriptorValue.isObject()) {
+        Value setterValue =
+            descriptorValue.asObject(runtime).getProperty(runtime, "set");
+        return setterValue.isObject() &&
+               setterValue.asObject(runtime).isFunction(runtime);
+      }
+      currentValue = getPrototypeOf.call(runtime, Value(runtime, current));
+    }
+    return false;
+  }
+
   Value get(Runtime& runtime, const PropNameID& name) override {
     std::string property = name.utf8(runtime);
 
@@ -1903,6 +1945,9 @@ throw JSError(
       }
       NATIVE_API_SET_RETURN(true);
 #else
+      if (!enginePrototypeHasSetter(runtime, property)) {
+        storeOwnExpando(runtime, property, value);
+      }
       NATIVE_API_SET_RETURN(false);
 #endif
     }

PROGRESS.md

@@ -51,6 +51,35 @@ TypeScript/UI worklets.
   - If CI proves the runtime fix, clean the diagnostic history before resuming
     the dedicated simulator-only RNS parity sweep.
 
+### 2026-06-29 21:37 EDT - JS subclass fields mirrored across wrapper churn
+
+- CI finding:
+  - GitHub Actions run `28413556555` on `b016ae80` compiled the edited runtime
+    sources but still failed in macOS tests before iOS ran.
+  - `MethodCallsTests.js Override: More than one methods with same jsname`
+    lost `this.zeroArgs` and `this.x` across a native callback, and
+    `ApiTests.js NSMutableArrayMethods` still lost `_array` during native
+    `addObject:`.
+  - Both failures point to JS-owned instance fields being attached to a
+    transient wrapper instead of surviving native callback/re-wrap paths.
+- Changes:
+  - For JS subclass instances on engines that can defer host-object sets to the
+    normal JS prototype chain, unknown field writes are now mirrored into native
+    object expandos when the JS prototype chain does not define a setter.
+  - Prototype setters still win; the fallback only mirrors plain instance state
+    such as `_array`, `zeroArgs`, and `x`.
+  - Added a source guard for this expando fallback.
+- 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.
+- Still next:
+  - Commit/push the JS subclass expando fallback and watch fresh PR CI.
+  - CI must prove macOS `MethodCallsTests` and `NSMutableArrayMethods` before
+    returning to RNS simulator parity work.
+
 ### 2026-06-29 18:19 EDT - indexed collection subclass aliases
 
 - Goal:

RN_API.md

@@ -55,6 +55,19 @@ UIKit-backed React Native libraries in TypeScript/UI worklets.
   - If native initialization substitutes a different Objective-C object, the
     bridge must keep returning the substituted object wrapper.
 
+## 2026-06-29 JS Subclass Instance Field Persistence
+
+- No new public NativeScript React Native API was added.
+- Generic native bridge behavior was clarified for JS/TypeScript native
+  subclasses:
+  - Plain JS-owned instance fields set on a native subclass wrapper must survive
+    native callback/re-wrap paths for the same Objective-C receiver.
+  - On engines that defer host-object sets to normal JS property semantics, the
+    bridge mirrors unknown writes into native object expandos when the JS
+    prototype chain does not define a setter for that property.
+  - Prototype setters remain authoritative and must not be shadowed by the
+    expando fallback.
+
 ## 2026-06-29 Simulator Latency Comparison
 
 - No new public NativeScript React Native API was added.

packages/react-native/test/runtime-js-subclass-expando.test.js

@@ -0,0 +1,27 @@
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+const repoRoot = path.resolve(__dirname, "../../..");
+
+for (const relativePath of [
+  "NativeScript/ffi/shared/bridge/HostObjects.mm",
+  "packages/react-native/native-api/ffi/shared/bridge/HostObjects.mm",
+]) {
+  const source = fs.readFileSync(path.join(repoRoot, relativePath), "utf8");
+
+  assert(
+    source.includes("bool enginePrototypeHasSetter(Runtime& runtime,") &&
+      source.includes('getPropertyAsFunction(runtime, "getOwnPropertyDescriptor")') &&
+      source.includes('getPropertyAsFunction(runtime, "getPrototypeOf")') &&
+      source.includes('getProperty(runtime, "set")'),
+    `${relativePath}: JS subclass expando fallback should detect prototype setters before caching unknown writes`,
+  );
+
+  assert(
+    source.includes("#else\n      if (!enginePrototypeHasSetter(runtime, property)) {\n        storeOwnExpando(runtime, property, value);\n      }\n      NATIVE_API_SET_RETURN(false);"),
+    `${relativePath}: engines that defer host sets should still mirror plain JS-owned fields into native expandos`,
+  );
+}
+
+console.log("runtime JS subclass expando tests passed");