react-native-windows 0.73.10 → 0.74.0-preview.1

package/Shared/OInstance.cpp

@@ -13,7 +13,7 @@
 #include <folly/Bits.h>
 #include <folly/json.h>
 #include <jsi/jsi.h>
-#include <jsiexecutor/jsireact/JSIExecutor.h>
+#include <jsireact/JSIExecutor.h>
 #include <filesystem>
 #include "OInstance.h"
 #include "Unicode.h"
@@ -40,6 +40,8 @@
 #include <DevSettings.h>
 #include <DevSupportManager.h>
 #include <IReactRootView.h>
+#include <ReactPropertyBag.h>
+#include <SchedulerSettings.h>
 #include <Shlwapi.h>
 #include <WebSocketJSExecutorFactory.h>
 #include <safeint.h>
@@ -56,6 +58,9 @@
 #endif
 #include <ReactCommon/CallInvoker.h>
 #include <ReactCommon/TurboModuleBinding.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h>
 #include "BaseScriptStoreImpl.h"
 #include "ChakraRuntimeHolder.h"
 
@@ -68,6 +73,144 @@ using namespace Microsoft::JSI;
 using std::make_shared;
 using winrt::Microsoft::ReactNative::ReactPropertyBagHelper;
 
+namespace Microsoft::ReactNative {
+
+// Note: Based on
+// https://github.com/facebook/react-native/blob/24d91268b64c7abbd4b26547ffcc663dc90ec5e7/ReactCommon/cxxreact/Instance.cpp#L112
+bool isHBCBundle(const std::string &bundle) {
+  static uint32_t constexpr HBCBundleMagicNumber = 0xffe7c3c3;
+
+  // Note:: Directly access the pointer to avoid copy/length-check. It matters as this string contains the bundle which
+  // can be potentially huge.
+  // https://herbsutter.com/2008/04/07/cringe-not-vectors-are-guaranteed-to-be-contiguous/#comment-483
+  auto header = reinterpret_cast<const facebook::react::BundleHeader *>(&bundle[0]);
+  if (HBCBundleMagicNumber == header->magic32.value) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void LoadRemoteUrlScript(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    std::shared_ptr<facebook::react::IDevSupportManager> devManager,
+    std::string &&jsBundleRelativePath,
+    std::function<void(std::unique_ptr<const facebook::react::JSBigStdString> script, const std::string &sourceURL)>
+        fnLoadScriptCallback) noexcept {
+  // First attempt to get download the Js locally, to catch any bundling
+  // errors before attempting to load the actual script.
+
+  uint32_t hermesBytecodeVersion = 0;
+#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+  hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
+#endif
+
+  auto [jsBundleString, success] = GetJavaScriptFromServer(
+      devSettings->sourceBundleHost,
+      devSettings->sourceBundlePort,
+      devSettings->debugBundlePath.empty() ? jsBundleRelativePath : devSettings->debugBundlePath,
+      devSettings->platformName,
+      devSettings->bundleAppId,
+      devSettings->devBundle,
+      devSettings->useFastRefresh,
+      devSettings->inlineSourceMap,
+      hermesBytecodeVersion);
+
+  if (!success) {
+    devManager->UpdateBundleStatus(false, -1);
+    devSettings->errorCallback(jsBundleString);
+    return;
+  }
+
+  int64_t currentTimeInMilliSeconds =
+      std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
+          .count();
+  devManager->UpdateBundleStatus(true, currentTimeInMilliSeconds);
+
+  auto bundleUrl = facebook::react::DevServerHelper::get_BundleUrl(
+      devSettings->sourceBundleHost,
+      devSettings->sourceBundlePort,
+      devSettings->debugBundlePath.empty() ? jsBundleRelativePath : devSettings->debugBundlePath,
+      devSettings->platformName,
+      devSettings->bundleAppId,
+      devSettings->devBundle,
+      devSettings->useFastRefresh,
+      devSettings->inlineSourceMap,
+      hermesBytecodeVersion);
+
+  // This code is based on the HBC Bundle integration on Android
+  // Ref:
+  // https://github.com/facebook/react-native/blob/24d91268b64c7abbd4b26547ffcc663dc90ec5e7/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp#L231
+  if (isHBCBundle(jsBundleString)) {
+    auto script = std::make_unique<facebook::react::JSBigStdString>(jsBundleString, false);
+    const char *buffer = script->c_str();
+    uint32_t bufferLength = (uint32_t)script->size();
+
+    // Please refer the code here for details on the file format:
+    // https://github.com/facebook/metro/blob/b1bacf52070be62872d6bd3420f37a4405ed34e6/packages/metro/src/lib/bundleToBytecode.js#L29
+    // Essentially, there is an 8 byte long file header with 4 bytes of a magic number followed by 4 bytes to encode
+    // the number of modules.The module buffers follows, each one starts with 4 byte header which encodes module
+    // length.A properly formatted HBCB should have at least 8 bytes..
+    uint32_t offset = 8;
+#define __SAFEADD__(s1, s2, t)             \
+  if (!msl::utilities::SafeAdd(s1, s2, t)) \
+    break;
+    while (offset < bufferLength) {
+      uint32_t segment;
+      __SAFEADD__(offset, 4, segment)
+      uint32_t moduleLength = (bufferLength < segment) ? 0 : *(((uint32_t *)buffer) + offset / 4);
+
+      // Early break if the module length is computed as 0.. as the segment start may be overflowing the buffer.
+      if (moduleLength == 0)
+        break;
+
+      uint32_t segmentEnd;
+      __SAFEADD__(moduleLength, segment, segmentEnd)
+      // Early break if the segment overflows beyond the buffer. This is unlikely for a properly formatted
+      // HBCB though.
+      if (segmentEnd > bufferLength)
+        break;
+
+      fnLoadScriptCallback(
+          std::make_unique<const facebook::react::JSBigStdString>(std::string(buffer + segment, buffer + segmentEnd)),
+          bundleUrl);
+
+      // Aligned at 4 byte boundary.
+      offset += ((moduleLength + 3) & ~3) + 4;
+    }
+#undef __SAFEADD__
+  } else {
+    // Remote debug executor loads script from a Uri, rather than taking the actual bundle string
+    fnLoadScriptCallback(
+        std::make_unique<const facebook::react::JSBigStdString>(
+            devSettings->useWebDebugger ? bundleUrl : jsBundleString),
+        bundleUrl);
+  }
+}
+
+std::unique_ptr<const facebook::react::JSBigString> JsBigStringFromPath(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    const std::string &jsBundleRelativePath) noexcept {
+#if (defined(_MSC_VER) && !defined(WINRT))
+  std::wstring bundlePath = (fs::u8path(devSettings->bundleRootPath) / jsBundleRelativePath).wstring();
+  return facebook::react::FileMappingBigString::fromPath(bundlePath);
+#else
+  std::wstring bundlePath;
+  // TODO: Replace call to private string function with C++ 20 `starts_with`
+  if (devSettings->bundleRootPath._Starts_with("resource://")) {
+    auto uri = winrt::Windows::Foundation::Uri(
+        winrt::to_hstring(devSettings->bundleRootPath), winrt::to_hstring(jsBundleRelativePath));
+    bundlePath = uri.ToString();
+  } else {
+    bundlePath = (fs::u8path(devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).wstring();
+  }
+
+  return std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
+#endif
+}
+
+} // namespace Microsoft::ReactNative
+
 namespace facebook {
 namespace react {
 
@@ -89,26 +232,6 @@ class OJSIExecutorFactory : public JSExecutorFactory {
     }
     bindNativeLogger(*runtimeHolder_->getRuntime(), logger);
 
-    auto turboModuleManager = std::make_shared<TurboModuleManager>(turboModuleRegistry_, jsCallInvoker_);
-
-    // TODO: The binding here should also add the proxys that convert cxxmodules into turbomodules
-    // [@vmoroz] Note, that we must not use the RN TurboCxxModule.h code because it uses global
-    // LongLivedObjectCollection instance that prevents us from using multiple RN instance in the same process.
-    auto binding = [turboModuleManager](const std::string &name) -> std::shared_ptr<TurboModule> {
-      return turboModuleManager->getModule(name);
-    };
-
-    TurboModuleBinding::install(
-        *runtimeHolder_->getRuntime(),
-        std::function(binding),
-        TurboModuleBindingMode::HostObject,
-        longLivedObjectCollection_);
-
-    // init TurboModule
-    for (const auto &moduleName : turboModuleManager->getEagerInitModuleNames()) {
-      turboModuleManager->getModule(moduleName);
-    }
-
     return std::make_unique<JSIExecutor>(
         runtimeHolder_->getRuntime(),
         std::move(delegate),
@@ -123,22 +246,13 @@ class OJSIExecutorFactory : public JSExecutorFactory {
   OJSIExecutorFactory(
       std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder,
       NativeLoggingHook loggingHook,
-      std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
-      bool isProfilingEnabled,
-      std::shared_ptr<CallInvoker> jsCallInvoker) noexcept
+      bool isProfilingEnabled) noexcept
       : runtimeHolder_{std::move(runtimeHolder)},
         loggingHook_{std::move(loggingHook)},
-        turboModuleRegistry_{std::move(turboModuleRegistry)},
-        longLivedObjectCollection_{std::move(longLivedObjectCollection)},
-        jsCallInvoker_{std::move(jsCallInvoker)},
         isProfilingEnabled_{isProfilingEnabled} {}
 
  private:
   std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder_;
-  std::shared_ptr<TurboModuleRegistry> turboModuleRegistry_;
-  std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
-  std::shared_ptr<CallInvoker> jsCallInvoker_;
   NativeLoggingHook loggingHook_;
   bool isProfilingEnabled_;
 };
@@ -155,6 +269,7 @@ void logMarker(const facebook::react::ReactMarker::ReactMarkerId /*id*/, const c
         &&cxxModules,
     std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
     std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &propertyBag,
     std::unique_ptr<InstanceCallback> &&callback,
     std::shared_ptr<MessageQueueThread> jsQueue,
     std::shared_ptr<MessageQueueThread> nativeQueue,
@@ -166,6 +281,7 @@ void logMarker(const facebook::react::ReactMarker::ReactMarkerId /*id*/, const c
       std::move(cxxModules),
       std::move(turboModuleRegistry),
       std::move(longLivedObjectCollection),
+      propertyBag,
       std::move(callback),
       std::move(jsQueue),
       std::move(nativeQueue),
@@ -195,7 +311,8 @@ void logMarker(const facebook::react::ReactMarker::ReactMarkerId /*id*/, const c
       std::move(jsBundleBasePath),
       std::move(cxxModules),
       std::move(turboModuleRegistry),
-      nullptr,
+      nullptr, // longLivedObjectCollection
+      nullptr, // PropertyBag
       std::move(callback),
       std::move(jsQueue),
       std::move(nativeQueue),
@@ -234,6 +351,7 @@ InstanceImpl::InstanceImpl(
         &&cxxModules,
     std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
     std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &propertyBag,
     std::unique_ptr<InstanceCallback> &&callback,
     std::shared_ptr<MessageQueueThread> jsQueue,
     std::shared_ptr<MessageQueueThread> nativeQueue,
@@ -298,12 +416,9 @@ InstanceImpl::InstanceImpl(
     if (m_devSettings->jsiRuntimeHolder) {
       assert(m_devSettings->jsiEngineOverride == JSIEngineOverride::Default);
       jsef = std::make_shared<OJSIExecutorFactory>(
-          m_devSettings->jsiRuntimeHolder,
-          m_devSettings->loggingCallback,
-          m_turboModuleRegistry,
-          m_longLivedObjectCollection,
-          !m_devSettings->useFastRefresh,
-          m_innerInstance->getJSCallInvoker());
+          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, !m_devSettings->useFastRefresh);
+    } else if (m_devSettings->jsExecutorFactoryDelegate != nullptr) {
+      jsef = m_devSettings->jsExecutorFactoryDelegate(m_innerInstance->getJSCallInvoker());
     } else {
       assert(m_devSettings->jsiEngineOverride != JSIEngineOverride::Default);
       switch (m_devSettings->jsiEngineOverride) {
@@ -365,17 +480,61 @@ InstanceImpl::InstanceImpl(
           break;
       }
       jsef = std::make_shared<OJSIExecutorFactory>(
-          m_devSettings->jsiRuntimeHolder,
-          m_devSettings->loggingCallback,
-          m_turboModuleRegistry,
-          m_longLivedObjectCollection,
-          !m_devSettings->useFastRefresh,
-          m_innerInstance->getJSCallInvoker());
+          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, !m_devSettings->useFastRefresh);
     }
   }
 
   m_innerInstance->initializeBridge(std::move(callback), jsef, m_jsThread, m_moduleRegistry);
 
+  // For RuntimeScheduler to work properly, we need to install TurboModuleManager with RuntimeSchedulerCallbackInvoker.
+  // To be able to do that, we need to be able to call m_innerInstance->getRuntimeExecutor(), which we can only do after
+  // m_innerInstance->initializeBridge(...) is called.
+  if (!m_devSettings->useWebDebugger) {
+    const auto runtimeExecutor = m_innerInstance->getRuntimeExecutor();
+#ifdef USE_FABRIC
+    Microsoft::ReactNative::SchedulerSettings::SetRuntimeExecutor(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(propertyBag), runtimeExecutor);
+#endif
+    if (m_devSettings->useRuntimeScheduler) {
+      m_runtimeScheduler = std::make_shared<RuntimeScheduler>(runtimeExecutor);
+      Microsoft::ReactNative::SchedulerSettings::SetRuntimeScheduler(
+          winrt::Microsoft::ReactNative::ReactPropertyBag(propertyBag), m_runtimeScheduler);
+    }
+
+    // Using runOnQueueSync because initializeBridge calls createJSExecutor with runOnQueueSync,
+    // so this is an attempt to keep the same semantics for exiting this method with TurboModuleManager
+    // initialized.
+    m_jsThread->runOnQueueSync([propertyBag,
+                                innerInstance = m_innerInstance,
+                                runtimeHolder = m_devSettings->jsiRuntimeHolder,
+                                runtimeScheduler = m_runtimeScheduler,
+                                turboModuleRegistry = m_turboModuleRegistry,
+                                longLivedObjectCollection = m_longLivedObjectCollection]() {
+      if (runtimeScheduler) {
+        RuntimeSchedulerBinding::createAndInstallIfNeeded(*runtimeHolder->getRuntime(), runtimeScheduler);
+      }
+      auto turboModuleManager = std::make_shared<TurboModuleManager>(
+          turboModuleRegistry,
+          runtimeScheduler ? std::make_shared<RuntimeSchedulerCallInvoker>(runtimeScheduler)
+                           : innerInstance->getJSCallInvoker());
+
+      // TODO: The binding here should also add the proxys that convert cxxmodules into turbomodules
+      // [@vmoroz] Note, that we must not use the RN TurboCxxModule.h code because it uses global
+      // LongLivedObjectCollection instance that prevents us from using multiple RN instance in the same process.
+      auto binding = [turboModuleManager](const std::string &name) -> std::shared_ptr<TurboModule> {
+        return turboModuleManager->getModule(name);
+      };
+
+      TurboModuleBinding::install(
+          *runtimeHolder->getRuntime(), std::function(binding), nullptr, longLivedObjectCollection);
+
+      // init TurboModule
+      for (const auto &moduleName : turboModuleManager->getEagerInitModuleNames()) {
+        turboModuleManager->getModule(moduleName);
+      }
+    });
+  }
+
   // All JSI runtimes do support host objects and hence the native modules
   // proxy.
   const bool isNativeModulesProxyAvailable = ((m_devSettings->jsiRuntimeHolder != nullptr) ||
@@ -402,132 +561,20 @@ void InstanceImpl::loadBundleSync(std::string &&jsBundleRelativePath) {
   loadBundleInternal(std::move(jsBundleRelativePath), /*synchronously:*/ true);
 }
 
-// Note: Based on
-// https://github.com/facebook/react-native/blob/24d91268b64c7abbd4b26547ffcc663dc90ec5e7/ReactCommon/cxxreact/Instance.cpp#L112
-bool isHBCBundle(const std::string &bundle) {
-  static uint32_t constexpr HBCBundleMagicNumber = 0xffe7c3c3;
-
-  // Note:: Directly access the pointer to avoid copy/length-check. It matters as this string contains the bundle which
-  // can be potentially huge.
-  // https://herbsutter.com/2008/04/07/cringe-not-vectors-are-guaranteed-to-be-contiguous/#comment-483
-  auto header = reinterpret_cast<const BundleHeader *>(&bundle[0]);
-  if (HBCBundleMagicNumber == header->magic32.value) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
 void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool synchronously) {
   try {
     if (m_devSettings->useWebDebugger || m_devSettings->liveReloadCallback != nullptr ||
         m_devSettings->useFastRefresh) {
-      // First attempt to get download the Js locally, to catch any bundling
-      // errors before attempting to load the actual script.
-
-      uint32_t hermesBytecodeVersion = 0;
-#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
-      hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
-#endif
-
-      auto [jsBundleString, success] = Microsoft::ReactNative::GetJavaScriptFromServer(
-          m_devSettings->sourceBundleHost,
-          m_devSettings->sourceBundlePort,
-          m_devSettings->debugBundlePath.empty() ? jsBundleRelativePath : m_devSettings->debugBundlePath,
-          m_devSettings->platformName,
-          m_devSettings->bundleAppId,
-          m_devSettings->devBundle,
-          m_devSettings->useFastRefresh,
-          m_devSettings->inlineSourceMap,
-          hermesBytecodeVersion);
-
-      if (!success) {
-        m_devManager->UpdateBundleStatus(false, -1);
-        m_devSettings->errorCallback(jsBundleString);
-        return;
-      }
+      Microsoft::ReactNative::LoadRemoteUrlScript(
+          m_devSettings,
+          m_devManager,
+          std::move(jsBundleRelativePath),
+          [=](std::unique_ptr<const JSBigStdString> script, const std::string &sourceURL) {
+            m_innerInstance->loadScriptFromString(std::move(script), sourceURL, false);
+          });
 
-      int64_t currentTimeInMilliSeconds =
-          std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
-              .count();
-      m_devManager->UpdateBundleStatus(true, currentTimeInMilliSeconds);
-
-      auto bundleUrl = DevServerHelper::get_BundleUrl(
-          m_devSettings->sourceBundleHost,
-          m_devSettings->sourceBundlePort,
-          m_devSettings->debugBundlePath.empty() ? jsBundleRelativePath : m_devSettings->debugBundlePath,
-          m_devSettings->platformName,
-          m_devSettings->bundleAppId,
-          m_devSettings->devBundle,
-          m_devSettings->useFastRefresh,
-          m_devSettings->inlineSourceMap,
-          hermesBytecodeVersion);
-
-      // This code is based on the HBC Bundle integration on Android
-      // Ref:
-      // https://github.com/facebook/react-native/blob/24d91268b64c7abbd4b26547ffcc663dc90ec5e7/ReactAndroid/src/main/jni/react/jni/CatalystInstanceImpl.cpp#L231
-      if (isHBCBundle(jsBundleString)) {
-        auto script = std::make_unique<JSBigStdString>(jsBundleString, false);
-        const char *buffer = script->c_str();
-        uint32_t bufferLength = (uint32_t)script->size();
-
-        // Please refer the code here for details on the file format:
-        // https://github.com/facebook/metro/blob/b1bacf52070be62872d6bd3420f37a4405ed34e6/packages/metro/src/lib/bundleToBytecode.js#L29
-        // Essentially, there is an 8 byte long file header with 4 bytes of a magic number followed by 4 bytes to encode
-        // the number of modules.The module buffers follows, each one starts with 4 byte header which encodes module
-        // length.A properly formatted HBCB should have at least 8 bytes..
-        uint32_t offset = 8;
-#define __SAFEADD__(s1, s2, t)             \
-  if (!msl::utilities::SafeAdd(s1, s2, t)) \
-    break;
-        while (offset < bufferLength) {
-          uint32_t segment;
-          __SAFEADD__(offset, 4, segment)
-          uint32_t moduleLength = (bufferLength < segment) ? 0 : *(((uint32_t *)buffer) + offset / 4);
-
-          // Early break if the module length is computed as 0.. as the segment start may be overflowing the buffer.
-          if (moduleLength == 0)
-            break;
-
-          uint32_t segmentEnd;
-          __SAFEADD__(moduleLength, segment, segmentEnd)
-          // Early break if the segment overflows beyond the buffer. This is unlikely for a properly formatted
-          // HBCB though.
-          if (segmentEnd > bufferLength)
-            break;
-
-          m_innerInstance->loadScriptFromString(
-              std::make_unique<const JSBigStdString>(std::string(buffer + segment, buffer + segmentEnd)),
-              bundleUrl,
-              false);
-
-          // Aligned at 4 byte boundary.
-          offset += ((moduleLength + 3) & ~3) + 4;
-        }
-#undef __SAFEADD__
-      } else {
-        // Remote debug executor loads script from a Uri, rather than taking the actual bundle string
-        m_innerInstance->loadScriptFromString(
-            std::make_unique<const JSBigStdString>(m_devSettings->useWebDebugger ? bundleUrl : jsBundleString),
-            bundleUrl,
-            synchronously);
-      }
     } else {
-#if (defined(_MSC_VER) && !defined(WINRT))
-      std::string bundlePath = (fs::u8path(m_devSettings->bundleRootPath) / jsBundleRelativePath).u8string();
-      auto bundleString = FileMappingBigString::fromPath(bundlePath);
-#else
-      std::string bundlePath;
-      if (m_devSettings->bundleRootPath._Starts_with("resource://")) {
-        auto uri = winrt::Windows::Foundation::Uri(
-            winrt::to_hstring(m_devSettings->bundleRootPath), winrt::to_hstring(jsBundleRelativePath));
-        bundlePath = winrt::to_string(uri.ToString());
-      } else {
-        bundlePath = (fs::u8path(m_devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).u8string();
-      }
-
-      auto bundleString = std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
-#endif
+      auto bundleString = Microsoft::ReactNative::JsBigStringFromPath(m_devSettings, jsBundleRelativePath);
       m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(jsBundleRelativePath), synchronously);
     }
   } catch (const std::exception &e) {
@@ -615,7 +662,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
             m_devSettings->useFastRefresh,
             m_devSettings->inlineSourceMap,
             hermesBytecodeVersion)
-      : std::string();
+      : m_devSettings->bundleRootPath;
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       facebook::react::SourceCodeModule::Name,

package/Shared/OInstance.h

@@ -12,6 +12,7 @@
 // React Native
 #include <ReactCommon/LongLivedObject.h>
 #include <cxxreact/Instance.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 
 // Standard Library
 #include <memory>
@@ -34,6 +35,7 @@ class InstanceImpl final : public InstanceWrapper, private ::std::enable_shared_
           &&cxxModules,
       std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
       std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
+      const winrt::Microsoft::ReactNative::IReactPropertyBag &propertyBag,
       std::unique_ptr<InstanceCallback> &&callback,
       std::shared_ptr<MessageQueueThread> jsQueue,
       std::shared_ptr<MessageQueueThread> nativeQueue,
@@ -75,6 +77,7 @@ class InstanceImpl final : public InstanceWrapper, private ::std::enable_shared_
           &&cxxModules,
       std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
       std::shared_ptr<facebook::react::LongLivedObjectCollection> longLivedObjectCollection,
+      const winrt::Microsoft::ReactNative::IReactPropertyBag &propertyBag,
       std::unique_ptr<InstanceCallback> &&callback,
       std::shared_ptr<MessageQueueThread> jsQueue,
       std::shared_ptr<MessageQueueThread> nativeQueue,
@@ -88,6 +91,7 @@ class InstanceImpl final : public InstanceWrapper, private ::std::enable_shared_
 
  private:
   std::shared_ptr<Instance> m_innerInstance;
+  std::shared_ptr<RuntimeScheduler> m_runtimeScheduler;
 
   std::string m_jsBundleBasePath;
   std::shared_ptr<facebook::react::ModuleRegistry> m_moduleRegistry;
@@ -103,3 +107,18 @@ class InstanceImpl final : public InstanceWrapper, private ::std::enable_shared_
 
 } // namespace react
 } // namespace facebook
+
+namespace Microsoft::ReactNative {
+
+void LoadRemoteUrlScript(
+    std::shared_ptr<facebook::react::DevSettings> devsettings,
+    std::shared_ptr<facebook::react::IDevSupportManager> devManager,
+    std::string &&jsBundleRelativePath,
+    std::function<void(std::unique_ptr<const facebook::react::JSBigStdString> script, const std::string &sourceURL)>
+        fnLoadScriptCallback) noexcept;
+
+std::unique_ptr<const facebook::react::JSBigString> JsBigStringFromPath(
+    std::shared_ptr<facebook::react::DevSettings> devsettings,
+    const std::string &jsBundleRelativePath) noexcept;
+
+} // namespace Microsoft::ReactNative