react-native-windows 0.74.10 → 0.75.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include <jsi/jsi.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <EventEmitter.h> // [Windows]
+
+namespace facebook::react {
+
+/**
+ * For now, support the same set of return types as existing impl.
+ * This can be improved to support richer typed objects.
+ */
+enum TurboModuleMethodValueKind {
+  VoidKind,
+  BooleanKind,
+  NumberKind,
+  StringKind,
+  ObjectKind,
+  ArrayKind,
+  FunctionKind,
+  PromiseKind,
+};
+
+/**
+ * Determines TurboModuleMethodValueKind based on the jsi::Value type.
+ */
+TurboModuleMethodValueKind getTurboModuleMethodValueKind(
+    jsi::Runtime& rt,
+    const jsi::Value* value);
+
+class TurboCxxModule;
+class TurboModuleBinding;
+
+/**
+ * Base HostObject class for every module to be exposed to JS
+ */
+class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
+ public:
+  TurboModule(std::string name, std::shared_ptr<CallInvoker> jsInvoker);
+
+  // Note: keep this method declared inline to avoid conflicts
+  // between RTTI and non-RTTI compilation units
+  facebook::jsi::Value get(
+      facebook::jsi::Runtime& runtime,
+      const facebook::jsi::PropNameID& propName) override {
+    {
+      auto prop = create(runtime, propName);
+      // If we have a JS wrapper, cache the result of this lookup
+      // We don't cache misses, to allow for methodMap_ to dynamically be
+      // extended
+      if (jsRepresentation_ && !prop.isUndefined()) {
+        jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
+            runtime, propName, prop);
+      }
+      return prop;
+    }
+  }
+
+  virtual std::vector<facebook::jsi::PropNameID> getPropertyNames(
+      facebook::jsi::Runtime& runtime) override {
+    std::vector<jsi::PropNameID> result;
+    result.reserve(methodMap_.size());
+    for (auto it = methodMap_.cbegin(); it != methodMap_.cend(); ++it) {
+      result.push_back(jsi::PropNameID::forUtf8(runtime, it->first));
+    }
+    return result;
+  }
+
+ protected:
+  const std::string name_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+
+  struct MethodMetadata {
+    size_t argCount;
+    facebook::jsi::Value (*invoker)(
+        facebook::jsi::Runtime& rt,
+        TurboModule& turboModule,
+        const facebook::jsi::Value* args,
+        size_t count);
+  };
+  std::unordered_map<std::string, MethodMetadata> methodMap_;
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
+      eventEmitterMap_;
+
+  using ArgFactory =
+      std::function<void(jsi::Runtime& runtime, std::vector<jsi::Value>& args)>;
+
+  /**
+   * Calls RCTDeviceEventEmitter.emit to JavaScript, with given event name and
+   * an optional list of arguments.
+   * If present, argFactory is a callback used to construct extra arguments,
+   * e.g.
+   *
+   *  emitDeviceEvent(rt, "myCustomEvent",
+   *    [](jsi::Runtime& rt, std::vector<jsi::Value>& args) {
+   *      args.emplace_back(jsi::Value(true));
+   *      args.emplace_back(jsi::Value(42));
+   *  });
+   */
+  void emitDeviceEvent(
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr);
+
+  // Backwards compatibility version
+  void emitDeviceEvent(
+      jsi::Runtime& /*runtime*/,
+
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr) {
+    emitDeviceEvent(eventName, std::move(argFactory));
+  }
+
+  virtual jsi::Value create(
+      jsi::Runtime& runtime,
+      const jsi::PropNameID& propName) {
+    std::string propNameUtf8 = propName.utf8(runtime);
+    if (auto methodIter = methodMap_.find(propNameUtf8);
+        methodIter != methodMap_.end()) {
+      const MethodMetadata& meta = methodIter->second;
+      return jsi::Function::createFromHostFunction(
+          runtime,
+          propName,
+          static_cast<unsigned int>(meta.argCount),
+          [this, meta](
+              jsi::Runtime& rt,
+              [[maybe_unused]] const jsi::Value& thisVal,
+              const jsi::Value* args,
+              size_t count) { return meta.invoker(rt, *this, args, count); });
+    } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
+               eventEmitterIter != eventEmitterMap_.end()) {
+      return eventEmitterIter->second->get(runtime, jsInvoker_);
+    }
+    // Neither Method nor EventEmitter were not found, let JS decide what to do.
+    return facebook::jsi::Value::undefined();
+  }
+
+ private:
+  friend class TurboCxxModule;
+  friend class TurboModuleBinding;
+  std::unique_ptr<jsi::WeakObject> jsRepresentation_;
+};
+
+/**
+ * An app/platform-specific provider function to get an instance of a module
+ * given a name.
+ */
+using TurboModuleProviderFunctionType =
+    std::function<std::shared_ptr<TurboModule>(const std::string& name)>;
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModuleUtils.h

@@ -11,9 +11,8 @@
 #include <string>
 
 #include <jsi/jsi.h>
-
-#include <ReactCommon/CallInvoker.h>
 #include <CallbackWrapper.h> // [Windows]
+#include <LongLivedObject.h> // [Windows]
 
 namespace facebook::react {
 
@@ -26,7 +25,6 @@ struct Promise : public LongLivedObject {
   void resolve(const jsi::Value& result);
   void reject(const std::string& error);
 
-  jsi::Runtime& runtime_;
   jsi::Function resolve_;
   jsi::Function reject_;
 };
@@ -56,4 +54,4 @@ class RAIICallbackWrapperDestroyer {
   std::weak_ptr<CallbackWrapper> callbackWrapper_;
 };
 
-} // namespace facebook::react
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/scrollview/ScrollViewProps.cpp

@@ -111,17 +111,15 @@ ScrollViewProps::ScrollViewProps(
                     // [Windows fix
                     (Float)1)),
                     // Windows]
-      endDraggingSensitivityVelocityMultiplier(
+      enableSyncOnScroll(
           CoreFeatures::enablePropIteratorSetter
-              ? sourceProps.endDraggingSensitivityVelocityMultiplier
+              ? sourceProps.enableSyncOnScroll
               : convertRawProp(
                     context,
                     rawProps,
-                    "endDraggingSensitivityVelocityMultiplier",
-                    sourceProps.endDraggingSensitivityVelocityMultiplier,
-                    // [Windows fix
-                    (Float)0)),
-                    // Windows]
+                    "enableSyncOnScroll",
+                    sourceProps.enableSyncOnScroll,
+                    false)),
       directionalLockEnabled(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.directionalLockEnabled
@@ -229,6 +227,23 @@ ScrollViewProps::ScrollViewProps(
                     "showsVerticalScrollIndicator",
                     sourceProps.showsVerticalScrollIndicator,
                     true)),
+      persistentScrollbar(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.persistentScrollbar
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "persistentScrollbar",
+                    sourceProps.persistentScrollbar,
+                    true)),
+      horizontal(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.horizontal
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "horizontal",
+                                                       sourceProps.horizontal,
+                                                       true)),
       scrollEventThrottle(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.scrollEventThrottle
@@ -381,11 +396,14 @@ void ScrollViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(maximumZoomScale);
     RAW_SET_PROP_SWITCH_CASE_BASIC(minimumZoomScale);
     RAW_SET_PROP_SWITCH_CASE_BASIC(scrollEnabled);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(enableSyncOnScroll);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(endDraggingSensitivityMultiplier);
     RAW_SET_PROP_SWITCH_CASE_BASIC(pagingEnabled);
     RAW_SET_PROP_SWITCH_CASE_BASIC(pinchGestureEnabled);
     RAW_SET_PROP_SWITCH_CASE_BASIC(scrollsToTop);
     RAW_SET_PROP_SWITCH_CASE_BASIC(showsHorizontalScrollIndicator);
-    RAW_SET_PROP_SWITCH_CASE_BASIC(showsVerticalScrollIndicator);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(persistentScrollbar);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(horizontal);
     RAW_SET_PROP_SWITCH_CASE_BASIC(scrollEventThrottle);
     RAW_SET_PROP_SWITCH_CASE_BASIC(zoomScale);
     RAW_SET_PROP_SWITCH_CASE_BASIC(contentInset);
@@ -491,6 +509,12 @@ SharedDebugStringConvertibleList ScrollViewProps::getDebugProps() const {
               "showsVerticalScrollIndicator",
               showsVerticalScrollIndicator,
               defaultScrollViewProps.showsVerticalScrollIndicator),
+          debugStringConvertibleItem(
+              "persistentScrollbar",
+              persistentScrollbar,
+              defaultScrollViewProps.persistentScrollbar),
+          debugStringConvertibleItem(
+              "horizontal", horizontal, defaultScrollViewProps.horizontal),
           debugStringConvertibleItem(
               "scrollEventThrottle",
               scrollEventThrottle,
@@ -533,3 +557,4 @@ SharedDebugStringConvertibleList ScrollViewProps::getDebugProps() const {
 #endif
 
 } // namespace facebook::react
+	

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/JSRuntimeFactory.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "JSRuntimeFactory.h"
+#include <jsinspector-modern/ConsoleMessage.h>
+#include <jsinspector-modern/FallbackRuntimeAgentDelegate.h>
+
+namespace facebook::react {
+
+jsi::Runtime& JSIRuntimeHolder::getRuntime() noexcept {
+  return *runtime_;
+}
+
+JSIRuntimeHolder::JSIRuntimeHolder(std::unique_ptr<jsi::Runtime> runtime)
+    : runtime_(std::move(runtime)) {
+  assert(runtime_ != nullptr);
+}
+
+void JSIRuntimeHolder::addConsoleMessage(jsi::Runtime& runtime, jsinspector_modern::ConsoleMessage message) {
+  return;
+}
+
+bool JSIRuntimeHolder::supportsConsole() const{
+  return false;
+}
+
+std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate>
+JSIRuntimeHolder::createAgentDelegate(
+    jsinspector_modern::FrontendChannel frontendChannel,
+    jsinspector_modern::SessionState& sessionState,
+    std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate::ExportedState>,
+    const jsinspector_modern::ExecutionContextDescription&
+        executionContextDescription,
+    RuntimeExecutor runtimeExecutor) {
+  (void)executionContextDescription;
+  (void)runtimeExecutor;
+  return std::make_unique<jsinspector_modern::FallbackRuntimeAgentDelegate>(
+      std::move(frontendChannel), sessionState, runtime_->description());
+}
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/JSRuntimeFactory.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <cxxreact/MessageQueueThread.h>
+#include <jsinspector-modern/ConsoleMessage.h>
+#include <jsi/jsi.h>
+#include <jsinspector-modern/ReactCdp.h>
+
+
+namespace facebook::react {
+
+/**
+ * An interface that represents an instance of a JS VM
+ */
+class JSRuntime : public jsinspector_modern::RuntimeTargetDelegate {
+ public:
+  virtual jsi::Runtime& getRuntime() noexcept = 0;
+
+  virtual ~JSRuntime() = default;
+
+  virtual void addConsoleMessage(jsi::Runtime& runtime, jsinspector_modern::ConsoleMessage message) = 0;
+  virtual bool supportsConsole() const = 0;
+};
+
+/**
+ * Interface for a class that creates instances of a JS VM
+ */
+class JSRuntimeFactory {
+ public:
+  virtual std::unique_ptr<JSRuntime> createJSRuntime(
+      std::shared_ptr<MessageQueueThread> msgQueueThread) noexcept = 0;
+
+  virtual ~JSRuntimeFactory() = default;
+};
+
+/**
+ * Utility class for creating a JSRuntime from a uniquely owned jsi::Runtime.
+ */
+class JSIRuntimeHolder : public JSRuntime {
+ public:
+  jsi::Runtime& getRuntime() noexcept override;
+  void addConsoleMessage(jsi::Runtime& runtime, jsinspector_modern::ConsoleMessage message) override;
+  bool supportsConsole() const override;
+
+  std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate> createAgentDelegate(
+      jsinspector_modern::FrontendChannel frontendChannel,
+      jsinspector_modern::SessionState& sessionState,
+      std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate::ExportedState>
+          previouslyExportedState,
+      const jsinspector_modern::ExecutionContextDescription&
+          executionContextDescription,
+      RuntimeExecutor runtimeExecutor) override;
+
+  explicit JSIRuntimeHolder(std::unique_ptr<jsi::Runtime> runtime);
+
+ private:
+  std::unique_ptr<jsi::Runtime> runtime_;
+};
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/ReactInstance.cpp

@@ -7,6 +7,7 @@
 
 #include "ReactInstance.h"
 
+#include <ReactCommon/RuntimeExecutor.h>
 #include <cxxreact/ErrorUtils.h>
 #include <cxxreact/JSBigString.h>
 #include <cxxreact/JSExecutor.h>
@@ -15,14 +16,13 @@
 #include <glog/logging.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/instrumentation.h>
+#include <jsinspector-modern/HostTarget.h>
 #include <jsireact/JSIExecutor.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
-// [Windows
 #include <react/utils/jsi-utils.h>
-// Windows]
 #include <iostream>
-#include <tuple>
+#include <memory>
 #include <utility>
 
 namespace facebook::react {
@@ -31,86 +31,110 @@ ReactInstance::ReactInstance(
     std::unique_ptr<JSRuntime> runtime,
     std::shared_ptr<MessageQueueThread> jsMessageQueueThread,
     std::shared_ptr<TimerManager> timerManager,
-    JsErrorHandler::JsErrorHandlingFunc jsErrorHandlingFunc,
-    jsinspector_modern::PageTarget* parentInspectorTarget)
+    JsErrorHandler::OnJsError onJsError,
+    jsinspector_modern::HostTarget* parentInspectorTarget)
     : runtime_(std::move(runtime)),
       jsMessageQueueThread_(jsMessageQueueThread),
       timerManager_(std::move(timerManager)),
-      jsErrorHandler_(jsErrorHandlingFunc),
-      hasFatalJsError_(std::make_shared<bool>(false)),
+      jsErrorHandler_(std::make_shared<JsErrorHandler>(std::move(onJsError))),
       parentInspectorTarget_(parentInspectorTarget) {
-  auto runtimeExecutor = [weakRuntime = std::weak_ptr<JSRuntime>(runtime_),
-                          weakTimerManager =
-                              std::weak_ptr<TimerManager>(timerManager_),
-                          weakJsMessageQueueThread =
-                              std::weak_ptr<MessageQueueThread>(
-                                  jsMessageQueueThread_),
-                          weakHasFatalJsError =
-                              std::weak_ptr<bool>(hasFatalJsError_)](
-                             std::function<void(jsi::Runtime & runtime)>&&
-                                 callback) {
-    if (std::shared_ptr<bool> sharedHasFatalJsError =
-            weakHasFatalJsError.lock()) {
-      if (*sharedHasFatalJsError) {
-        LOG(INFO)
-            << "Calling into JS using runtimeExecutor but hasFatalJsError_ is true";
-        return;
-      }
+  RuntimeExecutor runtimeExecutor = [weakRuntime = std::weak_ptr(runtime_),
+                                     weakTimerManager =
+                                         std::weak_ptr(timerManager_),
+                                     weakJsThread =
+                                         std::weak_ptr(jsMessageQueueThread_),
+                                     weakJsErrorHander = std::weak_ptr(
+                                         jsErrorHandler_)](auto callback) {
+    auto jsErrorHandler = weakJsErrorHander.lock();
+    if (weakRuntime.expired() || !jsErrorHandler) {
+      return;
     }
-    if (weakRuntime.expired()) {
+
+    if (jsErrorHandler->hasHandledFatalError()) {
+      LOG(INFO)
+          << "RuntimeExecutor: Detected fatal js error. Dropping work on non-js thread."
+          << std::endl;
       return;
     }
 
-    if (std::shared_ptr<MessageQueueThread> sharedJsMessageQueueThread =
-            weakJsMessageQueueThread.lock()) {
-      sharedJsMessageQueueThread->runOnQueue(
+    if (auto jsThread = weakJsThread.lock()) {
+      jsThread->runOnQueue(
           [weakRuntime, weakTimerManager, callback = std::move(callback)]() {
-            if (auto strongRuntime = weakRuntime.lock()) {
-              jsi::Runtime& jsiRuntime = strongRuntime->getRuntime();
-              SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
-              try {
-                callback(jsiRuntime);
-
-                // If we have first-class support for microtasks,
-                // they would've been called as part of the previous callback.
-                if (!ReactNativeFeatureFlags::enableMicrotasks()) {
-                  if (auto strongTimerManager = weakTimerManager.lock()) {
-                    strongTimerManager->callReactNativeMicrotasks(jsiRuntime);
-                  }
+            auto runtime = weakRuntime.lock();
+            if (!runtime) {
+              return;
+            }
+
+            jsi::Runtime& jsiRuntime = runtime->getRuntime();
+            SystraceSection s("ReactInstance::_runtimeExecutor[Callback]");
+            try {
+              callback(jsiRuntime);
+
+              // If we have first-class support for microtasks,
+              // they would've been called as part of the previous callback.
+              if (!ReactNativeFeatureFlags::enableMicrotasks()) {
+                if (auto timerManager = weakTimerManager.lock()) {
+                  timerManager->callReactNativeMicrotasks(jsiRuntime);
                 }
-              } catch (jsi::JSError& originalError) {
-                handleJSError(jsiRuntime, originalError, true);
               }
+            } catch (jsi::JSError& originalError) {
+              handleJSError(jsiRuntime, originalError, true);
             }
           });
     }
   };
 
   if (parentInspectorTarget_) {
-    inspectorTarget_ = &parentInspectorTarget_->registerInstance(*this);
-    runtimeInspectorTarget_ =
-        &inspectorTarget_->registerRuntime(*runtime_, runtimeExecutor);
+    auto executor = parentInspectorTarget_->executorFromThis();
+
+    auto runtimeExecutorThatWaitsForInspectorSetup =
+        std::make_shared<BufferedRuntimeExecutor>(runtimeExecutor);
+
+    // This code can execute from any thread, so we need to make sure we set up
+    // the inspector logic in the right one. The callback executes immediately
+    // if we are already in the right thread.
+    executor([this, runtimeExecutor, runtimeExecutorThatWaitsForInspectorSetup](
+                 jsinspector_modern::HostTarget& hostTarget) {
+      // Callbacks scheduled through the page target executor are generally
+      // not guaranteed to run (e.g.: if the page target is destroyed)
+      // but in this case it is because the page target cannot be destroyed
+      // before the instance finishes its setup:
+      // * On iOS it's because we do the setup synchronously.
+      // * On Android it's because we explicitly wait for the instance
+      //   creation task to finish before starting the destruction.
+      inspectorTarget_ = &hostTarget.registerInstance(*this);
+      runtimeInspectorTarget_ =
+          &inspectorTarget_->registerRuntime(*runtime_, runtimeExecutor);
+      runtimeExecutorThatWaitsForInspectorSetup->flush();
+    });
+
+    // We decorate the runtime executor used everywhere else to wait for the
+    // inspector to finish its setup.
+    runtimeExecutor =
+        [runtimeExecutorThatWaitsForInspectorSetup](
+            std::function<void(jsi::Runtime & runtime)>&& callback) {
+          runtimeExecutorThatWaitsForInspectorSetup->execute(
+              std::move(callback));
+        };
   }
 
-  runtimeScheduler_ =
-      std::make_shared<RuntimeScheduler>(std::move(runtimeExecutor));
+  runtimeScheduler_ = std::make_shared<RuntimeScheduler>(runtimeExecutor);
 
-  auto pipedRuntimeExecutor =
+  bufferedRuntimeExecutor_ = std::make_shared<BufferedRuntimeExecutor>(
       [runtimeScheduler = runtimeScheduler_.get()](
           std::function<void(jsi::Runtime & runtime)>&& callback) {
         runtimeScheduler->scheduleWork(std::move(callback));
-      };
-
-  bufferedRuntimeExecutor_ =
-      std::make_shared<BufferedRuntimeExecutor>(pipedRuntimeExecutor);
+      });
 }
 
 void ReactInstance::unregisterFromInspector() {
   if (inspectorTarget_) {
     assert(runtimeInspectorTarget_);
     inspectorTarget_->unregisterRuntime(*runtimeInspectorTarget_);
+
     assert(parentInspectorTarget_);
     parentInspectorTarget_->unregisterInstance(*inspectorTarget_);
+
     inspectorTarget_ = nullptr;
   }
 }
@@ -137,6 +161,8 @@ RuntimeExecutor ReactInstance::getBufferedRuntimeExecutor() noexcept {
   };
 }
 
+// TODO(T184010230): Should the RuntimeScheduler returned from this method be
+// buffered?
 std::shared_ptr<RuntimeScheduler>
 ReactInstance::getRuntimeScheduler() noexcept {
   return runtimeScheduler_;
@@ -194,9 +220,7 @@ void ReactInstance::loadScript(
             strongBufferedRuntimeExecuter->flush();
           }
         } catch (jsi::JSError& error) {
-          // Handle uncaught JS errors during loading JS bundle
-          *hasFatalJsError_ = true;
-          this->jsErrorHandler_.handleJsError(error, true);
+          jsErrorHandler_->handleFatalError(error);
         }
       });
 }
@@ -208,20 +232,24 @@ void ReactInstance::loadScript(
 void ReactInstance::callFunctionOnModule(
     const std::string& moduleName,
     const std::string& methodName,
-    const folly::dynamic& args) {
-  // TODO (C++ 20): This code previously implicitly captured `this` in a [=]
-  // capture group. Was it meaning to pass modules_ by value?
-  bufferedRuntimeExecutor_->execute([=, this](jsi::Runtime& runtime) {
+    folly::dynamic&& args) {
+  bufferedRuntimeExecutor_->execute([this,
+                                     moduleName = moduleName,
+                                     methodName = methodName,
+                                     args = std::move(args)](
+                                        jsi::Runtime& runtime) {
     SystraceSection s(
         "ReactInstance::callFunctionOnModule",
         "moduleName",
         moduleName,
         "methodName",
         methodName);
-    if (modules_.find(moduleName) == modules_.end()) {
+    auto it = callableModules_.find(moduleName);
+    if (it == callableModules_.end()) {
       std::ostringstream knownModules;
       int i = 0;
-      for (auto it = modules_.begin(); it != modules_.end(); it++, i++) {
+      for (it = callableModules_.begin(); it != callableModules_.end();
+           it++, i++) {
         const char* space = (i > 0 ? ", " : " ");
         knownModules << space << it->first;
       }
@@ -230,24 +258,25 @@ void ReactInstance::callFunctionOnModule(
           "Failed to call into JavaScript module method " + moduleName + "." +
               methodName +
               "(). Module has not been registered as callable. Registered callable JavaScript modules (n = " +
-              std::to_string(modules_.size()) + "):" + knownModules.str() +
-              ". Did you forget to call `RN$registerCallableModule`?");
+              std::to_string(callableModules_.size()) +
+              "):" + knownModules.str() +
+              ". Did you forget to call `registerCallableModule`?");
     }
 
-    auto module = modules_[moduleName]->factory.call(runtime).asObject(runtime);
-    auto method = module.getProperty(runtime, methodName.c_str());
-    if (method.isUndefined()) {
-      throw jsi::JSError(
-          runtime,
-          "Failed to call into JavaScript module method " + moduleName + "." +
-              methodName + ". Module exists, but the method is undefined.");
+    if (std::holds_alternative<jsi::Function>(it->second)) {
+      auto module =
+          std::get<jsi::Function>(it->second).call(runtime).asObject(runtime);
+      it->second = std::move(module);
     }
 
+    auto& module = std::get<jsi::Object>(it->second);
+    auto method = module.getPropertyAsFunction(runtime, methodName.c_str());
+
     std::vector<jsi::Value> jsArgs;
     for (auto& arg : args) {
       jsArgs.push_back(jsi::valueFromDynamic(runtime, arg));
     }
-    method.asObject(runtime).asFunction(runtime).callWithThis(
+    method.callWithThis(
         runtime, module, (const jsi::Value*)jsArgs.data(), jsArgs.size());
   });
 }
@@ -343,13 +372,14 @@ void ReactInstance::initializeRuntime(
               }
               auto name = args[0].asString(runtime).utf8(runtime);
               if (!args[1].isObject() ||
-                  !args[1].asObject(runtime).isFunction(runtime)) {
+                  !args[1].getObject(runtime).isFunction(runtime)) {
                 throw jsi::JSError(
                     runtime,
                     "The second argument to registerCallableModule must be a function that returns the JS module.");
               }
-              modules_[name] = std::make_shared<CallableModule>(
-                  args[1].getObject(runtime).asFunction(runtime));
+              callableModules_.emplace(
+                  std::move(name),
+                  args[1].getObject(runtime).getFunction(runtime));
               return jsi::Value::undefined();
             }));
 

package/Scripts/StripAdditionalPlatformsFromNuspec.ps1

@@ -16,7 +16,7 @@ If ($PSBoundParameters['Debug']) {
 Write-Output "Creating filtered version of : $nuspec"
 $xml = [xml](gc $nuspec)
 
-$allSlices = @("x64.Release", "x64.Debug", "x86.Release", "x86.Debug", "ARM64.Release", "ARM64.Debug")
+$allSlices = @("x64.Release", "x64.Debug", "x86.Release", "x86.Debug", "ARM64.Release", "ARM64.Debug", "ARM64EC.Debug", "ARM64EC.Release")
 
 $nodesToRemove = @();