fix: prefer JS subclass property setters

Author: DjDeveloperr

NativeScript/ffi/shared/bridge/HostObjects.mm

@@ -1880,6 +1880,21 @@ NativeApiHostSetResult set(Runtime& runtime, const PropNameID& name, const Value
       throw JSError(runtime, "Cannot set property on nil object.");
     }
 
+    bool isEngineExtendedInstance =
+        class_conformsToProtocol(object_getClass(object_),
+                                 @protocol(NativeApiClassBuilderProtocol));
+    if (isEngineExtendedInstance) {
+#ifdef NATIVESCRIPT_NATIVE_API_HOST_EXPLICIT_OVERRIDE
+      if (invokeEnginePrototypeSetter(runtime, property, value)) {
+        NATIVE_API_SET_RETURN(true);
+      }
+#else
+      if (enginePrototypeHasSetter(runtime, property)) {
+        NATIVE_API_SET_RETURN(false);
+      }
+#endif
+    }
+
     if (Class appearanceClass =
             taggedAppearanceProxyClass(runtime, bridge_, object_)) {
       if (const NativeApiSymbol* symbol =
@@ -1950,8 +1965,7 @@ throw JSError(
     // For JS-subclassed instances, an unknown property is owned by the JS
     // prototype (e.g. a JS-defined accessor); defer so the engine runs it instead of
     // shadowing it with a bridge expando.
-    if (class_conformsToProtocol(object_getClass(object_),
-                                 @protocol(NativeApiClassBuilderProtocol))) {
+    if (isEngineExtendedInstance) {
 #ifdef NATIVESCRIPT_NATIVE_API_HOST_EXPLICIT_OVERRIDE
       // Engines whose exotic property storage doesn't fall back to own
       // properties need the JS-owned set resolved here: invoke a JS-prototype

PROGRESS.md

@@ -17,6 +17,42 @@ TypeScript/UI worklets.
 
 ## Latest Update - 2026-06-30
 
+### 2026-06-30 02:10 EDT - JS subclass setters prefer prototype accessors before native setters
+
+- Scope check:
+  - Still generic NativeScript runtime behavior on the RN-module branch. No RNS
+    native implementation and no direct-engine backend refactor work.
+  - Simulator-only rule remains active; no physical devices were used.
+- CI finding:
+  - GitHub Actions run `28423162506` on `2295794f` kept setup, FFI boundary
+    check, native build, CLI build, and macOS tests green.
+  - iOS still completed with one failure:
+    `ApiTests.js SpecialCaseProperty_When_CustomSelector_ImplementedInJS`.
+  - `ApiTests.js NSMutableArrayMethods` still passed, so the construction-state
+    fix remains valid.
+  - The repeated `getter` output persisted because writes to a JS-overridden
+    native property still hit the native setter before the JS prototype setter.
+- Change:
+  - JS-extended object property writes now prefer JS prototype setters before
+    native metadata/runtime setters on every backend.
+  - The existing unknown-property expando fallback remains in place for JS
+    fields without a prototype setter.
+  - Source coverage now guards both getter and setter prototype precedence in
+    the tracked runtime bridge and RN mirror.
+- Verification:
+  - Focused construction/property guard test passed:
+    `node packages/react-native/test/runtime-instance-selector-base-dispatch.test.js`.
+  - 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.
+  - Existing generated macOS project compile/link passed with
+    `xcodebuild -project dist/intermediates/macos/NativeScript.xcodeproj ...`.
+- Still next:
+  - Commit/push this setter-precedence fix and watch fresh PR CI. Expected
+    result: macOS remains green and iOS clears the remaining
+    `SpecialCaseProperty_When_CustomSelector_ImplementedInJS` failure.
+
 ### 2026-06-30 01:44 EDT - JS subclass getters prefer prototype accessors before ObjC runtime getters
 
 - Scope check:

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

@@ -84,6 +84,40 @@ for (const relativePath of [
       guardedIndex < branchIndex,
     `${relativePath}: JS-subclassed property reads should prefer prototype getters before native runtime getters on every backend`,
   );
+
+  const nilObjectSetIndex = source.indexOf(
+    'throw JSError(runtime, "Cannot set property on nil object.");',
+  );
+  const setIndex = source.lastIndexOf(
+    "NativeApiHostSetResult set(",
+    nilObjectSetIndex,
+  );
+  const writableIndex = source.indexOf(
+    "selectWritablePropertyMember(members, property, false)",
+    setIndex,
+  );
+  const explicitSetterIndex = source.indexOf(
+    "invokeEnginePrototypeSetter(runtime, property, value)",
+    setIndex,
+  );
+  const fallbackSetterIndex = source.indexOf(
+    "enginePrototypeHasSetter(runtime, property)",
+    setIndex,
+  );
+
+  assert(
+    setIndex !== -1 &&
+      nilObjectSetIndex !== -1 &&
+      setIndex < nilObjectSetIndex &&
+      writableIndex !== -1 &&
+      explicitSetterIndex !== -1 &&
+      fallbackSetterIndex !== -1 &&
+      setIndex < explicitSetterIndex &&
+      explicitSetterIndex < writableIndex &&
+      setIndex < fallbackSetterIndex &&
+      fallbackSetterIndex < writableIndex,
+    `${relativePath}: JS-subclassed property writes should prefer prototype setters before native runtime setters on every backend`,
+  );
 }
 
 for (const relativePath of [