react-native-windows 0.0.0-canary.95 → 0.0.0-canary.950

package/Shared/OInstance.cpp

@@ -8,24 +8,23 @@
 #include <cxxreact/Instance.h>
 #include <cxxreact/JSBigString.h>
 #include <cxxreact/JSExecutor.h>
+#include <cxxreact/JsBundleType.h>
 #include <cxxreact/ReactMarker.h>
+#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"
 
-#include "Chakra/ChakraExecutor.h"
 #include "Chakra/ChakraHelpers.h"
 #include "Chakra/ChakraUtils.h"
-#include "JSI/Shared/RuntimeHolder.h"
+#include "JSI/RuntimeHolder.h"
 
 #include <cxxreact/MessageQueueThread.h>
 #include <cxxreact/ModuleRegistry.h>
 
-#if (defined(_MSC_VER) && !defined(WINRT))
-#include <Modules/WebSocketModule.h>
-#endif
 #include <Modules/ExceptionsManagerModule.h>
 #include <Modules/PlatformConstantsModule.h>
 #include <Modules/SourceCodeModule.h>
@@ -36,144 +35,185 @@
 #endif
 
 #include <BatchingMessageQueueThread.h>
+#include <CppRuntimeOptions.h>
 #include <CreateModules.h>
 #include <DevSettings.h>
-#include <IDevSupportManager.h>
+#include <DevSupportManager.h>
 #include <IReactRootView.h>
-#include <IUIManager.h>
+#include <ReactPropertyBag.h>
+#include <SchedulerSettings.h>
 #include <Shlwapi.h>
 #include <WebSocketJSExecutorFactory.h>
+#include <safeint.h>
+#include "PackagerConnection.h"
 
-#if defined(USE_HERMES)
-#include "HermesRuntimeHolder.h"
+#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+#include <hermes/BytecodeVersion.h>
 #endif
+#include "HermesRuntimeHolder.h"
+
 #if defined(USE_V8)
-#include "BaseScriptStoreImpl.h"
+#include <JSI/V8RuntimeHolder.h>
 #include "V8JSIRuntimeHolder.h"
 #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"
 
-#if (defined(_MSC_VER) && !defined(WINRT))
-// Type only available in Desktop.
-using Microsoft::React::WebSocketModule;
-#endif
-
+#include <tracing/tracing.h>
 namespace fs = std::filesystem;
 
-// forward declaration.
-namespace facebook::react::tracing {
-void initializeETW();
-void initializeJSHooks(facebook::jsi::Runtime &runtime);
-} // namespace facebook::react::tracing
+using namespace facebook;
+using namespace Microsoft::JSI;
 
-namespace {
+using std::make_shared;
+using winrt::Microsoft::ReactNative::ReactPropertyBagHelper;
 
-#if (defined(_MSC_VER) && !defined(WINRT))
-
-std::string GetJSBundleDirectory(
-    const std::string &jsBundleBasePath,
-    const std::string &jsBundleRelativePath) noexcept {
-  // If there is a base path, use that to calculate the absolute path.
-  if (jsBundleBasePath.length() > 0) {
-    std::string jsBundleDirectory = jsBundleBasePath;
-    if (jsBundleDirectory.back() != '\\')
-      jsBundleDirectory += '\\';
-
-    return jsBundleDirectory += jsBundleRelativePath;
-  } else if (!PathIsRelativeA(jsBundleRelativePath.c_str())) {
-    // If the given path is an absolute path, return it as-is
-    return jsBundleRelativePath;
-  }
-  // Otherwise use the path of the executable file to construct the absolute
-  // path.
-  else {
-    wchar_t modulePath[MAX_PATH];
+namespace Microsoft::ReactNative {
 
-    auto len = GetModuleFileNameW(nullptr, modulePath, _countof(modulePath));
+// 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;
 
-    if (len == 0 || (len == _countof(modulePath) && GetLastError() == ERROR_INSUFFICIENT_BUFFER))
-      return jsBundleRelativePath;
+  // 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;
+  }
+}
 
-    // remove the trailing filename as we are interested in only the path
-    auto succeeded = PathRemoveFileSpecW(modulePath);
-    if (!succeeded)
-      return jsBundleRelativePath;
+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
 
-    std::string jsBundlePath = Microsoft::Common::Unicode::Utf16ToUtf8(modulePath, wcslen(modulePath));
-    if (!jsBundlePath.empty() && jsBundlePath.back() != '\\')
-      jsBundlePath += '\\';
+  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;
+  }
 
-    return jsBundlePath += jsBundleRelativePath;
+  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::string GetJSBundleFilePath(const std::string &jsBundleBasePath, const std::string &jsBundleRelativePath) {
-  auto jsBundleFilePath = GetJSBundleDirectory(jsBundleBasePath, jsBundleRelativePath);
-
-  // Usually, the module name: "module name" + "." + "platform name", for
-  // example "lpc.win32". If we can not find the the bundle.js file under the
-  // normal folder, we are trying to find it under the folder without the dot
-  // (e.g. "lpcwin32"). VSO:1997035 remove this code after we have better name
-  // convension
-  if (PathFileExistsA((jsBundleFilePath + "\\bundle.js").c_str())) {
-    jsBundleFilePath += "\\bundle.js";
+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;
+  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 {
-    // remove the dot only if is belongs to the bundle file name.
-    size_t lastDotPosition = jsBundleFilePath.find_last_of('.');
-    size_t bundleFilePosition = jsBundleFilePath.find_last_of('\\');
-    if (lastDotPosition != std::string::npos &&
-        (bundleFilePosition == std::string::npos || lastDotPosition > bundleFilePosition)) {
-      jsBundleFilePath.erase(lastDotPosition, 1);
-    }
-
-    jsBundleFilePath += "\\bundle.js";
-
-    // Back before we have base path plumbed through, we made win32 force a
-    // seperate folder for each bundle by appending bundle.js Now that we have
-    // base path, we can handle multiple SDXs with the same index name so we
-    // should switch to using the same scheme as all the other platforms (and
-    // the bundle server)
-    // TODO: We should remove all the previous logic and use the same names as
-    // the other platforms...
-    if (!PathFileExistsA(jsBundleFilePath.c_str())) {
-      jsBundleFilePath = GetJSBundleDirectory(jsBundleBasePath, jsBundleRelativePath) + ".bundle";
-    }
+    bundlePath = (fs::u8path(devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).wstring();
   }
 
-  return jsBundleFilePath;
-}
+  return std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
 #endif
+}
 
-} // namespace
-
-using namespace facebook;
+} // namespace Microsoft::ReactNative
 
 namespace facebook {
 namespace react {
 
 namespace {
-void runtimeInstaller([[maybe_unused]] jsi::Runtime &runtime) {
-#ifdef ENABLE_JS_SYSTRACE_TO_ETW
-  facebook::react::tracing::initializeJSHooks(runtime);
-#endif
-}
-
-class BridgeCallInvoker : public CallInvoker {
- public:
-  BridgeCallInvoker(std::weak_ptr<MessageQueueThread> messageQueueThread)
-      : messageQueueThread_(std::move(messageQueueThread)) {}
-
-  void invokeAsync(std::function<void()> &&func) override {
-    if (auto queue = messageQueueThread_.lock()) {
-      queue->runOnQueue(std::move(func));
-    }
-  }
-
- private:
-  std::weak_ptr<MessageQueueThread> messageQueueThread_;
-};
 
 class OJSIExecutorFactory : public JSExecutorFactory {
  public:
@@ -191,166 +231,151 @@ class OJSIExecutorFactory : public JSExecutorFactory {
     }
     bindNativeLogger(*runtimeHolder_->getRuntime(), logger);
 
-    auto turboModuleManager =
-        std::make_shared<TurboModuleManager>(turboModuleRegistry_, std::make_shared<BridgeCallInvoker>(jsQueue));
-
-    // TODO: The binding here should also add the proxys that convert cxxmodules into turbomodules
-    auto binding = [turboModuleManager](const std::string &name) -> std::shared_ptr<TurboModule> {
-      return turboModuleManager->getModule(name);
-    };
-
-    TurboModuleBinding::install(*runtimeHolder_->getRuntime(), std::make_shared<TurboModuleBinding>(binding));
-
-    // init TurboModule
-    for (const auto &moduleName : turboModuleManager->getEagerInitModuleNames()) {
-      turboModuleManager->getModule(moduleName);
-    }
-
     return std::make_unique<JSIExecutor>(
-        runtimeHolder_->getRuntime(), std::move(delegate), JSIExecutor::defaultTimeoutInvoker, runtimeInstaller);
+        runtimeHolder_->getRuntime(),
+        std::move(delegate),
+        JSIExecutor::defaultTimeoutInvoker,
+        [isProfiling = isProfilingEnabled_]([[maybe_unused]] jsi::Runtime &runtime) {
+#ifdef ENABLE_JS_SYSTRACE_TO_ETW
+          facebook::react::tracing::initializeJSHooks(runtime, isProfiling);
+#endif
+        });
   }
 
   OJSIExecutorFactory(
-      std::shared_ptr<jsi::RuntimeHolderLazyInit> runtimeHolder,
+      std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder,
       NativeLoggingHook loggingHook,
-      std::shared_ptr<TurboModuleRegistry> turboModuleRegistry) noexcept
+      bool isProfilingEnabled) noexcept
       : runtimeHolder_{std::move(runtimeHolder)},
         loggingHook_{std::move(loggingHook)},
-        turboModuleRegistry_{std::move(turboModuleRegistry)} {}
+        isProfilingEnabled_{isProfilingEnabled} {}
 
  private:
-  std::shared_ptr<jsi::RuntimeHolderLazyInit> runtimeHolder_;
-  std::shared_ptr<TurboModuleRegistry> turboModuleRegistry_;
+  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder_;
   NativeLoggingHook loggingHook_;
+  bool isProfilingEnabled_;
 };
 
 } // namespace
 
 void logMarker(const facebook::react::ReactMarker::ReactMarkerId /*id*/, const char * /*tag*/) {}
 
-struct BridgeUIBatchInstanceCallback : public InstanceCallback {
-  BridgeUIBatchInstanceCallback(
-      std::weak_ptr<Instance> instance,
-      std::weak_ptr<IUIManager> uimanager,
-      std::weak_ptr<MessageQueueThread> uithread)
-      : m_instance(instance), m_weakUiManager(std::move(uimanager)), m_uiThread(std::move(uithread)) {}
-  virtual ~BridgeUIBatchInstanceCallback() = default;
-  void onBatchComplete() override {
-    if (auto uithread = m_uiThread.lock()) {
-      std::weak_ptr<IUIManager> weakUiManager(m_weakUiManager);
-      uithread->runOnQueue([weakUiManager]() {
-        auto uiManager = weakUiManager.lock();
-        if (uiManager != nullptr)
-          uiManager->onBatchComplete();
-      });
-#ifdef WINRT
-      // For UWP we use a batching message queue to optimize the usage
-      // of the CoreDispatcher.  Win32 already has an optimized queue.
-      facebook::react::BatchingMessageQueueThread *batchingUIThread =
-          static_cast<facebook::react::BatchingMessageQueueThread *>(uithread.get());
-      if (batchingUIThread != nullptr) {
-        batchingUIThread->onBatchComplete();
-      }
-#endif
-    }
-  }
-  void incrementPendingJSCalls() override {}
-  void decrementPendingJSCalls() override {}
-
-  std::weak_ptr<Instance> m_instance;
-  std::weak_ptr<IUIManager> m_weakUiManager;
-  std::weak_ptr<MessageQueueThread> m_uiThread;
-};
-
-struct BridgeTestInstanceCallback : public InstanceCallback {
-  BridgeTestInstanceCallback() {}
-  virtual ~BridgeTestInstanceCallback() = default;
-  void onBatchComplete() override {}
-  void incrementPendingJSCalls() override {}
-  void decrementPendingJSCalls() override {}
-};
-
 /*static*/ std::shared_ptr<InstanceImpl> InstanceImpl::MakeNoBundle(
+    std::shared_ptr<Instance> &&instance,
     std::string &&jsBundleBasePath,
     std::vector<
         std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
         &&cxxModules,
     std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-    std::shared_ptr<IUIManager> uimanager,
+    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,
     std::shared_ptr<DevSettings> devSettings,
     std::shared_ptr<IDevSupportManager> devManager) noexcept {
-  auto instance = std::shared_ptr<InstanceImpl>(new InstanceImpl(
+  auto inner = std::shared_ptr<InstanceImpl>(new InstanceImpl(
+      std::move(instance),
       std::move(jsBundleBasePath),
       std::move(cxxModules),
       std::move(turboModuleRegistry),
-      std::move(uimanager),
+      std::move(longLivedObjectCollection),
+      propertyBag,
+      std::move(callback),
       std::move(jsQueue),
       std::move(nativeQueue),
       std::move(devSettings),
       std::move(devManager)));
 
-  instance->RegisterForReloadIfNecessary();
+  inner->RegisterForReloadIfNecessary();
 
-  return instance;
+  return inner;
 }
 
 /*static*/ std::shared_ptr<InstanceImpl> InstanceImpl::MakeAndLoadBundle(
+    std::shared_ptr<Instance> &&instance,
     std::string &&jsBundleBasePath,
     std::string &&jsBundleRelativePath,
     std::vector<
         std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
         &&cxxModules,
     std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-    std::shared_ptr<IUIManager> uimanager,
+    std::unique_ptr<InstanceCallback> &&callback,
     std::shared_ptr<MessageQueueThread> jsQueue,
     std::shared_ptr<MessageQueueThread> nativeQueue,
     std::shared_ptr<DevSettings> devSettings,
     std::shared_ptr<IDevSupportManager> devManager) noexcept {
-  auto instance = std::shared_ptr<InstanceImpl>(new InstanceImpl(
+  auto inner = std::shared_ptr<InstanceImpl>(new InstanceImpl(
+      std::move(instance),
       std::move(jsBundleBasePath),
       std::move(cxxModules),
       std::move(turboModuleRegistry),
-      std::move(uimanager),
+      nullptr, // longLivedObjectCollection
+      nullptr, // PropertyBag
+      std::move(callback),
       std::move(jsQueue),
       std::move(nativeQueue),
       std::move(devSettings),
       std::move(devManager)));
 
-  instance->loadBundle(std::move(jsBundleRelativePath));
-  instance->RegisterForReloadIfNecessary();
+  inner->loadBundle(std::move(jsBundleRelativePath));
+  inner->RegisterForReloadIfNecessary();
+
+  return inner;
+}
 
-  return instance;
+void InstanceImpl::SetInError() noexcept {
+  m_isInError = true;
 }
 
+namespace {
+bool shouldStartHermesInspector(DevSettings &devSettings) {
+  bool isHermes =
+      ((devSettings.jsiEngineOverride == JSIEngineOverride::Hermes) ||
+       (devSettings.jsiEngineOverride == JSIEngineOverride::Default && devSettings.jsiRuntimeHolder &&
+        devSettings.jsiRuntimeHolder->getRuntimeType() == facebook::react::JSIEngineOverride::Hermes));
+
+  if (isHermes && devSettings.useDirectDebugger && !devSettings.useWebDebugger)
+    return true;
+  else
+    return false;
+}
+} // namespace
+
 InstanceImpl::InstanceImpl(
+    std::shared_ptr<Instance> &&instance,
     std::string &&jsBundleBasePath,
     std::vector<
         std::tuple<std::string, facebook::xplat::module::CxxModule::Provider, std::shared_ptr<MessageQueueThread>>>
         &&cxxModules,
     std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
-    std::shared_ptr<IUIManager> uimanager,
+    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,
     std::shared_ptr<DevSettings> devSettings,
     std::shared_ptr<IDevSupportManager> devManager)
-    : m_uimanager(std::move(uimanager)),
-      m_turboModuleRegistry(std::move(turboModuleRegistry)),
+    : m_turboModuleRegistry(std::move(turboModuleRegistry)),
+      m_longLivedObjectCollection(std::move(longLivedObjectCollection)),
       m_jsThread(std::move(jsQueue)),
       m_nativeQueue(nativeQueue),
       m_jsBundleBasePath(std::move(jsBundleBasePath)),
       m_devSettings(std::move(devSettings)),
       m_devManager(std::move(devManager)),
-      m_innerInstance(std::make_shared<Instance>()) {
+      m_innerInstance(std::move(instance)) {
   // Temp set the logmarker here
-  facebook::react::ReactMarker::logTaggedMarker = logMarker;
+  facebook::react::ReactMarker::logTaggedMarkerImpl = logMarker;
 
 #ifdef ENABLE_ETW_TRACING
   // TODO :: Find a better place to initialize ETW once per process.
   facebook::react::tracing::initializeETW();
 #endif
 
+  if (shouldStartHermesInspector(*m_devSettings)) {
+    m_devManager->EnsureHermesInspector(m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort);
+  }
+
   // Default (common) NativeModules
   auto modules = GetDefaultNativeModules(nativeQueue);
 
@@ -365,9 +390,13 @@ InstanceImpl::InstanceImpl(
   std::shared_ptr<JSExecutorFactory> jsef;
   if (m_devSettings->useWebDebugger) {
     try {
-      auto jseFunc = m_devManager->LoadJavaScriptInProxyMode(*m_devSettings);
+      auto jseFunc = m_devManager->LoadJavaScriptInProxyMode(*m_devSettings, [weakthis = weak_from_this()]() {
+        if (auto strongThis = weakthis.lock()) {
+          strongThis->SetInError();
+        }
+      });
 
-      if ((jseFunc == nullptr) || m_devManager->HasException()) {
+      if ((jseFunc == nullptr) || m_isInError) {
         m_devSettings->errorCallback("Failed to create JavaScript Executor.");
         return;
       }
@@ -378,92 +407,133 @@ InstanceImpl::InstanceImpl(
       return;
     }
   } else {
+    if (m_devSettings->useFastRefresh || m_devSettings->liveReloadCallback) {
+      Microsoft::ReactNative::PackagerConnection::CreateOrReusePackagerConnection(*m_devSettings);
+    }
+
     // If the consumer gives us a JSI runtime, then  use it.
     if (m_devSettings->jsiRuntimeHolder) {
       assert(m_devSettings->jsiEngineOverride == JSIEngineOverride::Default);
       jsef = std::make_shared<OJSIExecutorFactory>(
-          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, m_turboModuleRegistry);
-    } else if (m_devSettings->jsiEngineOverride != JSIEngineOverride::Default) {
+          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) {
-        case JSIEngineOverride::Hermes:
-#if defined(USE_HERMES)
-          m_devSettings->jsiRuntimeHolder = std::make_shared<HermesRuntimeHolder>();
+        case JSIEngineOverride::Hermes: {
+          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
+
+          wchar_t tempPath[MAX_PATH];
+          if (GetTempPathW(MAX_PATH, tempPath)) {
+            preparedScriptStore =
+                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+          }
+
+          m_devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
+              m_devSettings, m_jsThread, std::move(preparedScriptStore));
           break;
-#else
-          assert(false); // Hermes is not available in this build, fallthrough
-#endif
+        }
         case JSIEngineOverride::V8: {
 #if defined(USE_V8)
-          std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
-          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
+          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
 
-          char tempPath[MAX_PATH];
-          if (GetTempPathA(MAX_PATH, tempPath)) {
-            preparedScriptStore = std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(tempPath);
+          wchar_t tempPath[MAX_PATH];
+          if (GetTempPathW(MAX_PATH, tempPath)) {
+            preparedScriptStore =
+                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
           }
 
           m_devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(scriptStore), std::move(preparedScriptStore));
+              m_devSettings, m_jsThread, nullptr, std::move(preparedScriptStore), /*multithreading*/ false);
           break;
 #else
           assert(false); // V8 is not available in this build, fallthrough
+          [[fallthrough]];
+#endif
+        }
+        case JSIEngineOverride::V8NodeApi: {
+#if defined(USE_V8)
+          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
+
+          wchar_t tempPath[MAX_PATH];
+          if (GetTempPathW(MAX_PATH, tempPath)) {
+            preparedScriptStore =
+                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+          }
+
+          m_devSettings->jsiRuntimeHolder = make_shared<Microsoft::ReactNative::V8RuntimeHolder>(
+              m_devSettings, m_jsThread, std::move(preparedScriptStore), false);
+          break;
+#else
+          if (m_devSettings->errorCallback)
+            m_devSettings->errorCallback("JSI/V8/NAPI engine is not available in this build");
+          assert(false);
+          [[fallthrough]];
 #endif
         }
         case JSIEngineOverride::Chakra:
-        case JSIEngineOverride::ChakraCore:
         default: // TODO: Add other engines once supported
           m_devSettings->jsiRuntimeHolder =
               std::make_shared<Microsoft::JSI::ChakraRuntimeHolder>(m_devSettings, m_jsThread, nullptr, nullptr);
           break;
       }
       jsef = std::make_shared<OJSIExecutorFactory>(
-          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, m_turboModuleRegistry);
-    } else {
-      // We use the older non-JSI ChakraExecutor pipeline as a fallback as of
-      // now. This will go away once we completely move to JSI flow.
-      ChakraInstanceArgs instanceArgs;
-
-      instanceArgs.DebuggerBreakOnNextLine = m_devSettings->debuggerBreakOnNextLine;
-      instanceArgs.DebuggerPort = m_devSettings->debuggerPort;
-      instanceArgs.DebuggerRuntimeName = m_devSettings->debuggerRuntimeName;
-
-      instanceArgs.EnableDebugging = m_devSettings->useDirectDebugger;
-      instanceArgs.LoggingCallback = m_devSettings->loggingCallback;
+          m_devSettings->jsiRuntimeHolder, m_devSettings->loggingCallback, !m_devSettings->useFastRefresh);
+    }
+  }
 
-      instanceArgs.EnableNativePerformanceNow = m_devSettings->enableNativePerformanceNow;
-      instanceArgs.DebuggerConsoleRedirection = m_devSettings->debuggerConsoleRedirection;
+  m_innerInstance->initializeBridge(std::move(callback), jsef, m_jsThread, m_moduleRegistry);
 
-      // Disable bytecode caching with live reload as we don't make guarantees
-      // that the bundle version will change with edits
-      if (m_devSettings->liveReloadCallback == nullptr) {
-        instanceArgs.BundleUrlMetadataMap = m_devSettings->chakraBundleUrlMetadataMap;
-      }
-
-      if (!m_devSettings->useJITCompilation) {
-#if (defined(_MSC_VER) && !defined(WINRT))
-        instanceArgs.RuntimeAttributes = static_cast<JsRuntimeAttributes>(
-            instanceArgs.RuntimeAttributes | JsRuntimeAttributeDisableNativeCodeGeneration |
-            JsRuntimeAttributeDisableExecutablePageAllocation);
-#else
-        instanceArgs.RuntimeAttributes = static_cast<JsRuntimeAttributes>(
-            instanceArgs.RuntimeAttributes | JsRuntimeAttributeDisableNativeCodeGeneration);
+  // 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);
+      };
 
-      instanceArgs.MemoryTracker = m_devSettings->memoryTracker
-          ? m_devSettings->memoryTracker
-          : CreateMemoryTracker(std::shared_ptr<MessageQueueThread>{m_nativeQueue});
+      TurboModuleBinding::install(
+          *runtimeHolder->getRuntime(), std::function(binding), nullptr, longLivedObjectCollection);
 
-      jsef = std::make_shared<ChakraExecutorFactory>(std::move(instanceArgs));
-    }
+      // init TurboModule
+      for (const auto &moduleName : turboModuleManager->getEagerInitModuleNames()) {
+        turboModuleManager->getModule(moduleName);
+      }
+    });
   }
 
-  m_innerInstance->initializeBridge(
-      std::make_unique<BridgeUIBatchInstanceCallback>(m_innerInstance, m_uimanager, m_nativeQueue),
-      jsef,
-      m_jsThread,
-      m_moduleRegistry);
-
   // All JSI runtimes do support host objects and hence the native modules
   // proxy.
   const bool isNativeModulesProxyAvailable = ((m_devSettings->jsiRuntimeHolder != nullptr) ||
@@ -491,130 +561,85 @@ void InstanceImpl::loadBundleSync(std::string &&jsBundleRelativePath) {
 }
 
 void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool synchronously) {
-  // load JS
-  if (m_devSettings->useWebDebugger) {
-    // First attempt to get download the Js locally, to catch any bundling
-    // errors before attempting to load the actual script.
-    auto jsBundleString = m_devManager->GetJavaScriptFromServer(
-        m_devSettings->debugHost,
-        m_devSettings->debugBundlePath.empty() ? jsBundleRelativePath : m_devSettings->debugBundlePath,
-        m_devSettings->platformName);
-
-    if (m_devManager->HasException()) {
-      m_devSettings->errorCallback(jsBundleString);
-      return;
-    }
+  try {
+    if (m_devSettings->useWebDebugger || m_devSettings->liveReloadCallback != nullptr ||
+        m_devSettings->useFastRefresh) {
+      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);
+          });
 
-    try {
-      auto bundleUrl = DevServerHelper::get_BundleUrl(
-          m_devSettings->debugHost,
-          m_devSettings->debugBundlePath.empty() ? jsBundleRelativePath : m_devSettings->debugBundlePath,
-          m_devSettings->platformName,
-          /*dev*/ "true",
-          /*hot*/ "false");
-
-      m_innerInstance->loadScriptFromString(
-          std::make_unique<const JSBigStdString>(bundleUrl), bundleUrl, synchronously);
-    } catch (std::exception &e) {
-      m_devSettings->errorCallback(e.what());
-      return;
-    }
-  } else if (m_devSettings->liveReloadCallback != nullptr || m_devSettings->useFastRefresh) {
-    auto jsBundleString = m_devManager->GetJavaScriptFromServer(
-        m_devSettings->debugHost, jsBundleRelativePath, m_devSettings->platformName);
-
-    if (m_devManager->HasException()) {
-      m_devSettings->errorCallback(jsBundleString);
     } else {
-      m_innerInstance->loadScriptFromString(
-          std::make_unique<const JSBigStdString>(jsBundleString), jsBundleRelativePath, synchronously);
+      auto bundleString = Microsoft::ReactNative::JsBigStringFromPath(m_devSettings, jsBundleRelativePath);
+      m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(jsBundleRelativePath), synchronously);
     }
-  } else {
-    try {
-#if (defined(_MSC_VER) && !defined(WINRT))
-      auto fullBundleFilePath = GetJSBundleFilePath(m_jsBundleBasePath, jsBundleRelativePath);
-
-      // If fullBundleFilePath exists, load User bundle.
-      // Otherwise all bundles (User and Platform) are loaded through
-      // platformBundles.
-      if (PathFileExistsA(fullBundleFilePath.c_str())) {
-#if defined(_CHAKRACORE_H_)
-        auto bundleString = FileMappingBigString::fromPath(fullBundleFilePath);
-#else
-        auto bundleString = JSBigFileString::fromPath(fullBundleFilePath);
-#endif
-        m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(fullBundleFilePath), synchronously);
-      }
+  } catch (const std::exception &e) {
+    m_devSettings->errorCallback(e.what());
+  } catch (const winrt::hresult_error &hrerr) {
+    auto error = fmt::format("[0x{:0>8x}] {}", static_cast<uint32_t>(hrerr.code()), winrt::to_string(hrerr.message()));
 
-#else
-      std::string bundlePath =
-          (fs::path(m_devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).u8string();
-
-      auto bundleString = std::make_unique<::react::uwp::StorageFileBigString>(bundlePath);
-      m_innerInstance->loadScriptFromString(std::move(bundleString), jsBundleRelativePath, synchronously);
-#endif
-
-#if defined(_CHAKRACORE_H_)
-    } catch (const facebook::react::ChakraJSException &e) {
-      m_devSettings->errorCallback(std::string{e.what()} + "\r\n" + e.getStack());
-#endif
-    } catch (std::exception &e) {
-      m_devSettings->errorCallback(e.what());
-    }
+    m_devSettings->errorCallback(std::move(error));
   }
 }
 
 InstanceImpl::~InstanceImpl() {
+  if (shouldStartHermesInspector(*m_devSettings) && m_devSettings->jsiRuntimeHolder) {
+    m_devSettings->jsiRuntimeHolder->teardown();
+  }
   m_nativeQueue->quitSynchronous();
 }
 
-void InstanceImpl::AttachMeasuredRootView(IReactRootView *rootView, folly::dynamic &&initProps) noexcept {
-  if (m_devManager->HasException()) {
-    return;
+std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules(
+    std::shared_ptr<MessageQueueThread> nativeQueue) {
+  std::vector<std::unique_ptr<NativeModule>> modules;
+  if (m_devSettings->useTurboModulesOnly) {
+    return modules;
   }
 
-  rootView->ResetView();
-
-  auto rootTag = m_uimanager->AddMeasuredRootView(rootView);
-  rootView->SetTag(rootTag);
+  auto transitionalProps{ReactPropertyBagHelper::CreatePropertyBag()};
 
-  std::string jsMainModuleName = rootView->JSComponentName();
-  folly::dynamic params = folly::dynamic::array(
-      std::move(jsMainModuleName), folly::dynamic::object("initialProps", std::move(initProps))("rootTag", rootTag));
-  m_innerInstance->callJSFunction("AppRegistry", "runApplication", std::move(params));
-}
+  // These modules are instantiated separately in MSRN (Universal Windows).
+  // When there are module name collisions, the last one registered is used.
+  // If this code is enabled, we will have unused module instances.
+  // Also, MSRN has a different property bag mechanism incompatible with this method's transitionalProps variable.
+#if (defined(_MSC_VER) && !defined(WINRT))
 
-void InstanceImpl::DetachRootView(IReactRootView *rootView) noexcept {
-  if (m_devManager->HasException()) {
-    return;
+  // OC:8368383 - Memory leak under investigation.
+  if (!m_devSettings->useWebSocketTurboModule) {
+    modules.push_back(std::make_unique<CxxNativeModule>(
+        m_innerInstance,
+        Microsoft::React::GetWebSocketModuleName(),
+        [transitionalProps]() { return Microsoft::React::CreateWebSocketModule(transitionalProps); },
+        nativeQueue));
   }
 
-  auto rootTag = rootView->GetTag();
-  folly::dynamic params = folly::dynamic::array(rootTag);
-  m_innerInstance->callJSFunction("AppRegistry", "unmountApplicationComponentAtRootTag", std::move(params));
-
-  // Give the JS thread time to finish executing
-  m_jsThread->runOnQueueSync([]() {});
-}
+  // Applications using the Windows ABI feature should load the networking TurboModule variants instead.
+  if (!m_devSettings->omitNetworkingCxxModules) {
+    // Use in case the host app provides its a non-Blob-compatible HTTP module.
+    if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
+      modules.push_back(std::make_unique<CxxNativeModule>(
+          m_innerInstance,
+          Microsoft::React::GetHttpModuleName(),
+          [transitionalProps]() { return Microsoft::React::CreateHttpModule(transitionalProps); },
+          nativeQueue));
+
+      modules.push_back(std::make_unique<CxxNativeModule>(
+          m_innerInstance,
+          Microsoft::React::GetBlobModuleName(),
+          [transitionalProps]() { return Microsoft::React::CreateBlobModule(transitionalProps); },
+          nativeQueue));
+
+      modules.push_back(std::make_unique<CxxNativeModule>(
+          m_innerInstance,
+          Microsoft::React::GetFileReaderModuleName(),
+          [transitionalProps]() { return Microsoft::React::CreateFileReaderModule(transitionalProps); },
+          nativeQueue));
+    }
+  }
 
-std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules(
-    std::shared_ptr<MessageQueueThread> nativeQueue) {
-  std::vector<std::unique_ptr<NativeModule>> modules;
-// TODO: This is not included for UWP due to difficulties getting it working.
-// For now, we still use the old module
-//  written specifically for UWP. That one gets added later.
-#if (defined(_MSC_VER) && !defined(WINRT))
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      "WebSocketModule",
-      []() -> std::unique_ptr<xplat::module::CxxModule> { return std::make_unique<WebSocketModule>(); },
-      nativeQueue));
-#endif
-// TODO: This is not included for UWP because we have a different module which
-// is added later. However, this one is designed
-//  so that we can base a UWP version on it. We need to do that but is not high
-//  priority.
-#if (defined(_MSC_VER) && !defined(WINRT))
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       "Timing",
@@ -622,16 +647,25 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
       nativeQueue));
 #endif
 
+  uint32_t hermesBytecodeVersion = 0;
+#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+  hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
+#endif
+
   // TODO - Encapsulate this in a helpers, and make sure callers add it to their
   // list
   std::string bundleUrl = (m_devSettings->useWebDebugger || m_devSettings->liveReloadCallback)
       ? DevServerHelper::get_BundleUrl(
-            m_devSettings->debugHost,
+            m_devSettings->sourceBundleHost,
+            m_devSettings->sourceBundlePort,
             m_devSettings->debugBundlePath,
             m_devSettings->platformName,
-            "true" /*dev*/,
-            "false" /*hot*/)
-      : std::string();
+            m_devSettings->bundleAppId,
+            m_devSettings->devBundle,
+            m_devSettings->useFastRefresh,
+            m_devSettings->inlineSourceMap,
+            hermesBytecodeVersion)
+      : m_devSettings->bundleRootPath;
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       facebook::react::SourceCodeModule::Name,
@@ -665,13 +699,14 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
 
 void InstanceImpl::RegisterForReloadIfNecessary() noexcept {
   // setup polling for live reload
-  if (!m_devManager->HasException() && !m_devSettings->useFastRefresh && m_devSettings->liveReloadCallback != nullptr) {
-    m_devManager->StartPollingLiveReload(m_devSettings->debugHost, m_devSettings->liveReloadCallback);
+  if (!m_isInError && !m_devSettings->useFastRefresh && m_devSettings->liveReloadCallback != nullptr) {
+    m_devManager->StartPollingLiveReload(
+        m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort, m_devSettings->liveReloadCallback);
   }
 }
 
 void InstanceImpl::DispatchEvent(int64_t viewTag, std::string eventName, folly::dynamic &&eventData) {
-  if (m_devManager->HasException()) {
+  if (m_isInError) {
     return;
   }
 
@@ -680,7 +715,7 @@ void InstanceImpl::DispatchEvent(int64_t viewTag, std::string eventName, folly::
 }
 
 void InstanceImpl::invokeCallback(const int64_t callbackId, folly::dynamic &&params) {
-  if (m_devManager->HasException()) {
+  if (m_isInError) {
     return;
   }