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

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -2,115 +2,125 @@
 // Licensed under the MIT License.
 
 #include "ReactInstanceWin.h"
-#include "MoveOnCopy.h"
-#include "MsoUtils.h"
 
-#include <Base/CoreNativeModules.h>
-#include <IUIManager.h>
+#include <AppModelHelpers.h>
+#include <CppRuntimeOptions.h>
+#include <CreateInstance.h>
+#include <CreateModules.h>
+#include <JSCallInvokerScheduler.h>
+#include <OInstance.h>
+#include <PackagerConnection.h>
+#include <QuirkSettings.h>
+#include <Shared/DevServerHelper.h>
 #include <Threading/MessageDispatchQueue.h>
-#include <XamlUIService.h>
-#include "ReactErrorProvider.h"
-
-#include "Microsoft.ReactNative/IReactNotificationService.h"
-#include "Microsoft.ReactNative/Threading/MessageQueueThreadFactory.h"
-
-#include "../../codegen/NativeAppStateSpec.g.h"
-#include "../../codegen/NativeClipboardSpec.g.h"
-#include "../../codegen/NativeDevSettingsSpec.g.h"
-#include "../../codegen/NativeDeviceInfoSpec.g.h"
-#include "../../codegen/NativeI18nManagerSpec.g.h"
-#include "../../codegen/NativeLogBoxSpec.g.h"
-#include "NativeModules.h"
-#include "NativeModulesProvider.h"
-#include "Unicode.h"
-
-#include <ReactWindowsCore/ViewManager.h>
+#include <Threading/MessageQueueThreadFactory.h>
+#include <TurboModuleManager.h>
+#include <Utils/Helpers.h>
+#include <Views/ViewManager.h>
+#include <appModel.h>
+#include <comUtil/qiCast.h>
 #include <dispatchQueue/dispatchQueue.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h>
+#include <winrt/Windows.Storage.h>
+#include <tuple>
+#include "BaseScriptStoreImpl.h"
+#include "ChakraRuntimeHolder.h"
+#include "CrashManager.h"
 #include "DevMenu.h"
+#include "DynamicWriter.h"
+#include "HermesRuntimeHolder.h"
 #include "IReactContext.h"
 #include "IReactDispatcher.h"
+#include "IReactNotificationService.h"
+#include "JSI/JSExecutorFactorySettings.h"
+#include "JsiApi.h"
+#include "Modules/DevSettingsModule.h"
+#include "Modules/ExceptionsManager.h"
+#include "Modules/PlatformConstantsWinModule.h"
+#include "Modules/ReactRootViewTagGenerator.h"
+#include "Modules/SampleTurboModule.h"
+#include "Modules/SourceCode.h"
+#include "Modules/StatusBarManager.h"
+#include "Modules/Timing.h"
+#include "MoveOnCopy.h"
+#include "MsoUtils.h"
+#include "NativeModules.h"
+#include "NativeModulesProvider.h"
+#include "ReactCoreInjection.h"
+#include "ReactErrorProvider.h"
+#include "RedBox.h"
+#include "Unicode.h"
+
+#ifdef USE_FABRIC
+#include <Fabric/Composition/UriImageManager.h>
+#include <Fabric/FabricUIManagerModule.h>
+#include <Fabric/WindowsComponentDescriptorRegistry.h>
+#include <SchedulerSettings.h>
+#include <jserrorhandler/JsErrorHandler.h>
+#include <react/nativemodule/core/ReactCommon/TurboModuleBinding.h>
+#include <react/renderer/componentregistry/componentNameByReactViewName.h>
+#include <react/renderer/componentregistry/native/NativeComponentRegistryBinding.h>
+#include <react/runtime/JSRuntimeFactory.h>
+#include <react/runtime/PlatformTimerRegistry.h>
+#include <react/runtime/TimerManager.h>
+#endif
+
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
+#include <LayoutService.h>
+#include <XamlUIService.h>
+#include "Modules/NativeUIManager.h"
+#include "Modules/PaperUIManagerModule.h"
+#endif
+
+#ifndef CORE_ABI
+#include <Utils/UwpPreparedScriptStore.h>
+#include <Utils/UwpScriptStore.h>
+#include "ConfigureBundlerDlg.h"
+#include "Modules/AccessibilityInfoModule.h"
 #include "Modules/AlertModule.h"
 #include "Modules/AppStateModule.h"
+#include "Modules/AppThemeModuleUwp.h"
 #include "Modules/ClipboardModule.h"
-#include "Modules/DevSettingsModule.h"
 #include "Modules/DeviceInfoModule.h"
 #include "Modules/I18nManagerModule.h"
+#include "Modules/LinkingManagerModule.h"
 #include "Modules/LogBoxModule.h"
-
-#include <Utils/UwpPreparedScriptStore.h>
-#include <Utils/UwpScriptStore.h>
-
-#if defined(USE_HERMES)
-#include "HermesRuntimeHolder.h"
-#endif // USE_HERMES
+#else
+#include "Modules/DesktopTimingModule.h"
+#endif
+#include "Modules/ExceptionsManager.h"
+#include "Modules/PlatformConstantsWinModule.h"
+#include "Modules/ReactRootViewTagGenerator.h"
+#include "Modules/SourceCode.h"
+#include "Modules/StatusBarManager.h"
+
+#if !defined(CORE_ABI) || defined(USE_FABRIC)
+#include <Modules/ImageViewManagerModule.h>
+#include "Modules/Animated/NativeAnimatedModule.h"
+#endif
 
 #if defined(USE_V8)
-#include <winrt/Windows.Storage.h>
-#include "BaseScriptStoreImpl.h"
+#include "JSI/V8RuntimeHolder.h"
 #include "V8JSIRuntimeHolder.h"
 #endif // USE_V8
 
-#include "RedBox.h"
-
-#include <tuple>
-#include "ChakraRuntimeHolder.h"
-
-namespace react::uwp {
+namespace Microsoft::ReactNative {
 
 void AddStandardViewManagers(
-    std::vector<std::unique_ptr<facebook::react::IViewManager>> &viewManagers,
-    std::shared_ptr<IReactInstance> const &instance) noexcept;
-
-void AddPolyesterViewManagers(
-    std::vector<std::unique_ptr<facebook::react::IViewManager>> &viewManagers,
-    std::shared_ptr<IReactInstance> const &instance) noexcept;
+    std::vector<std::unique_ptr<Microsoft::ReactNative::IViewManager>> &viewManagers,
+    const Mso::React::IReactContext &context) noexcept;
 
 std::shared_ptr<facebook::react::IUIManager> CreateUIManager2(
     Mso::React::IReactContext *context,
-    std::vector<react::uwp::NativeViewManager> &&viewManagers) noexcept;
+    std::vector<Microsoft::ReactNative::IViewManager> &&viewManagers) noexcept;
 
-} // namespace react::uwp
+} // namespace Microsoft::ReactNative
 
 using namespace winrt::Microsoft::ReactNative;
 
 namespace Mso::React {
 
-//=============================================================================================
-// ReactContext implementation
-//=============================================================================================
-
-ReactContext::ReactContext(
-    Mso::WeakPtr<ReactInstanceWin> &&reactInstance,
-    IReactPropertyBag const &properties,
-    IReactNotificationService const &notifications) noexcept
-    : m_reactInstance{std::move(reactInstance)}, m_properties{properties}, m_notifications{notifications} {}
-
-void ReactContext::Destroy() noexcept {
-  if (auto notificationService = winrt::get_self<implementation::ReactNotificationService>(m_notifications)) {
-    notificationService->UnsubscribeAll();
-  }
-}
-
-IReactPropertyBag ReactContext::Properties() noexcept {
-  return m_properties;
-}
-
-IReactNotificationService ReactContext::Notifications() noexcept {
-  return m_notifications;
-}
-
-void ReactContext::CallJSFunction(std::string &&module, std::string &&method, folly::dynamic &&params) noexcept {
-  if (auto instance = m_reactInstance.GetStrongPtr()) {
-    instance->CallJsFunction(std::move(module), std::move(method), std::move(params));
-  }
-}
-
-void ReactContext::DispatchEvent(int64_t viewTag, std::string &&eventName, folly::dynamic &&eventData) noexcept {
-  if (auto instance = m_reactInstance.GetStrongPtr()) {
-    instance->DispatchEvent(viewTag, std::move(eventName), std::move(eventData));
-  }
-}
-
 //=============================================================================================
 // LoadedCallbackGuard ensures that the OnReactInstanceLoaded is always called.
 // It calls OnReactInstanceLoaded in destructor with a cancellation error.
@@ -136,10 +146,84 @@ struct LoadedCallbackGuard {
   Mso::CntPtr<ReactInstanceWin> m_reactInstance;
 };
 
+struct BridgeUIBatchInstanceCallback final : public facebook::react::InstanceCallback {
+  BridgeUIBatchInstanceCallback(Mso::WeakPtr<ReactInstanceWin> wkInstance) : m_wkInstance(wkInstance) {}
+  virtual ~BridgeUIBatchInstanceCallback() = default;
+  void onBatchComplete() override {
+    if (auto instance = m_wkInstance.GetStrongPtr()) {
+      auto state = instance->State();
+      if (state != ReactInstanceState::HasError && state != ReactInstanceState::Unloaded) {
+        if (instance->UseWebDebugger()) {
+          // While using a CxxModule for UIManager (which we do when running under webdebugger)
+          // We need to post the batch complete to the NativeQueue to ensure that the UIManager
+          // has posted everything from this batch into its queue before we complete the batch.
+          instance->m_jsDispatchQueue.Load().Post([wkInstance = m_wkInstance]() {
+            if (auto instance = wkInstance.GetStrongPtr()) {
+              instance->m_batchingUIThread->runOnQueue([wkInstance]() {
+                if (auto instance = wkInstance.GetStrongPtr()) {
+                  auto propBag = ReactPropertyBag(instance->m_reactContext->Properties());
+                  if (auto callback = propBag.Get(winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::
+                                                      UIBatchCompleteCallbackProperty())) {
+                    (*callback)(instance->m_reactContext->Properties());
+                  }
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
+                  if (auto uiManager = Microsoft::ReactNative::GetNativeUIManager(*instance->m_reactContext).lock()) {
+                    uiManager->onBatchComplete();
+                  }
+#endif
+                }
+              });
+
+              // 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 *>(instance->m_batchingUIThread.get());
+              if (batchingUIThread != nullptr) {
+                batchingUIThread->onBatchComplete();
+              }
+            }
+          });
+        } else {
+          instance->m_batchingUIThread->runOnQueue([wkInstance = m_wkInstance]() {
+            if (auto instance = wkInstance.GetStrongPtr()) {
+              auto propBag = ReactPropertyBag(instance->m_reactContext->Properties());
+              if (auto callback = propBag.Get(winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::
+                                                  UIBatchCompleteCallbackProperty())) {
+                (*callback)(instance->m_reactContext->Properties());
+              }
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
+              if (auto uiManager = Microsoft::ReactNative::GetNativeUIManager(*instance->m_reactContext).lock()) {
+                uiManager->onBatchComplete();
+              }
+#endif
+            }
+          });
+          // 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 *>(instance->m_batchingUIThread.get());
+          if (batchingUIThread != nullptr) {
+            batchingUIThread->onBatchComplete();
+          }
+        }
+      }
+    }
+  }
+  void incrementPendingJSCalls() override {}
+  void decrementPendingJSCalls() override {}
+
+  Mso::WeakPtr<ReactInstanceWin> m_wkInstance;
+  Mso::CntPtr<Mso::React::ReactContext> m_context;
+  std::weak_ptr<facebook::react::MessageQueueThread> m_uiThread;
+};
+
 //=============================================================================================
 // ReactInstanceWin implementation
 //=============================================================================================
 
+/*static*/ std::mutex ReactInstanceWin::s_registryMutex;
+/*static*/ std::vector<ReactInstanceWin *> ReactInstanceWin::s_instanceRegistry;
+
 ReactInstanceWin::ReactInstanceWin(
     IReactHost &reactHost,
     ReactOptions const &options,
@@ -150,7 +234,6 @@ ReactInstanceWin::ReactInstanceWin(
       m_weakReactHost{&reactHost},
       m_options{options},
       m_whenCreated{std::move(whenCreated)},
-      m_whenLoaded{std::move(whenLoaded)},
       m_isFastReloadEnabled(options.UseFastRefresh()),
       m_isLiveReloadEnabled(options.UseLiveReload()),
       m_updateUI{std::move(updateUI)},
@@ -160,214 +243,669 @@ ReactInstanceWin::ReactInstanceWin(
       m_reactContext{Mso::Make<ReactContext>(
           this,
           options.Properties,
-          winrt::make<implementation::ReactNotificationService>(options.Notifications))},
-      m_legacyInstance{
-          std::make_shared<react::uwp::UwpReactInstanceProxy>(Mso::WeakPtr<Mso::React::IReactInstance>{this})} {
+          winrt::make<implementation::ReactNotificationService>(options.Notifications))} {
+  // As soon as the bundle is loaded or failed to load, we set the m_whenLoaded promise value in JS queue.
+  // It then synchronously raises the OnInstanceLoaded event in the JS queue.
+  // Then, we notify the ReactHost about the load event in the internal queue.
+  m_whenLoaded.AsFuture()
+      .Then<Mso::Executors::Inline>(
+          [onLoaded = m_options.OnInstanceLoaded, reactContext = m_reactContext](Mso::Maybe<void> &&value) noexcept {
+            auto errCode = value.IsError() ? value.TakeError() : Mso::ErrorCode();
+            if (onLoaded) {
+              onLoaded.Get()->Invoke(reactContext, errCode);
+            }
+            return Mso::Maybe<void>(errCode);
+          })
+      .Then(Queue(), [whenLoaded = std::move(whenLoaded)](Mso::Maybe<void> &&value) noexcept {
+        whenLoaded.SetValue(std::move(value));
+      });
+
+  // When the JS queue is shutdown, we set the m_whenDestroyed promise value as the last work item in the JS queue.
+  // No JS queue work can be done after that for the instance.
+  // The promise continuation synchronously calls the OnInstanceDestroyed event.
+  // Then, the Destroy() method returns the m_whenDestroyedResult future to ReactHost to handle instance destruction.
+  m_whenDestroyedResult =
+      m_whenDestroyed.AsFuture().Then<Mso::Executors::Inline>([whenLoaded = m_whenLoaded,
+                                                               onDestroyed = m_options.OnInstanceDestroyed,
+                                                               // If the ReactHost has been released, this
+                                                               // instance might be the only thing keeping
+                                                               // the propertyBag alive.
+                                                               // We want it to remain alive for the
+                                                               // InstanceDestroyed callbacks
+                                                               propBag = m_options.Properties,
+                                                               reactContext = m_reactContext]() noexcept {
+        whenLoaded.TryCancel(); // It only has an effect if whenLoaded was not set before
+        Microsoft::ReactNative::HermesRuntimeHolder::storeTo(ReactPropertyBag(reactContext->Properties()), nullptr);
+        if (onDestroyed) {
+          onDestroyed.Get()->Invoke(reactContext);
+        }
+      });
+
+  // We notify the ReactHost immediately that the instance is created, but the
+  // OnInstanceCreated event is raised only after the internal react-native instance is ready and
+  // it starts handling JS queue work items.
   m_whenCreated.SetValue();
+
+  if (m_options.EnableDefaultCrashHandler()) {
+    CrashManager::RegisterCustomHandler();
+  }
+
+  {
+    std::scoped_lock lock{s_registryMutex};
+    s_instanceRegistry.push_back(this);
+  }
+}
+
+ReactInstanceWin::~ReactInstanceWin() noexcept {
+  std::scoped_lock lock{s_registryMutex};
+  auto it = std::find(s_instanceRegistry.begin(), s_instanceRegistry.end(), this);
+  if (it != s_instanceRegistry.end()) {
+    s_instanceRegistry.erase(it);
+  }
+
+  if (m_options.EnableDefaultCrashHandler()) {
+    CrashManager::UnregisterCustomHandler();
+  }
+}
+
+void ReactInstanceWin::InstanceCrashHandler(int fileDescriptor) noexcept {
+  if (!m_options.EnableDefaultCrashHandler()) {
+    return;
+  }
+
+  if (m_jsiRuntimeHolder) {
+    m_jsiRuntimeHolder->crashHandler(fileDescriptor);
+  }
+
+  // record additional information that could be useful for debugging crash dumps here
+  // (perhaps properties and settings or clues about the react tree)
+}
+
+/*static*/ void ReactInstanceWin::CrashHandler(int fileDescriptor) noexcept {
+  std::scoped_lock lock{s_registryMutex};
+  for (auto &entry : s_instanceRegistry) {
+    entry->InstanceCrashHandler(fileDescriptor);
+  }
 }
 
-ReactInstanceWin::~ReactInstanceWin() noexcept {}
+void ReactInstanceWin::LoadModules(
+    const std::shared_ptr<facebook::react::DevSettings> &devSettings,
+    const std::shared_ptr<winrt::Microsoft::ReactNative::NativeModulesProvider> &nativeModulesProvider,
+    const std::shared_ptr<winrt::Microsoft::ReactNative::TurboModulesProvider> &turboModulesProvider) noexcept {
+  auto registerTurboModule = [this, &nativeModulesProvider, &turboModulesProvider](
+                                 const wchar_t *name, const ReactModuleProvider &provider) noexcept {
+    if (m_options.UseWebDebugger()) {
+      nativeModulesProvider->AddModuleProvider(name, provider);
+    } else {
+      turboModulesProvider->AddModuleProvider(name, provider, false);
+    }
+  };
+
+#ifdef USE_FABRIC
+  if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
+    registerTurboModule(
+        L"FabricUIManagerBinding",
+        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::FabricUIManager>());
+  }
+#endif
+
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
+  if (!IsBridgeless()) {
+    registerTurboModule(
+        L"UIManager",
+        // TODO: Use MakeTurboModuleProvider after it satisfies ReactNativeSpecs::UIManagerSpec
+        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::UIManager>());
+  }
+#endif
+
+#ifndef CORE_ABI
+  registerTurboModule(
+      L"AccessibilityInfo",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AccessibilityInfo>());
+
+  registerTurboModule(
+      L"Alert", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::Alert>());
+
+  registerTurboModule(
+      L"Appearance", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::Appearance>());
+
+  registerTurboModule(
+      L"AppState", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AppState>());
+
+  registerTurboModule(
+      L"AppTheme", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AppTheme>());
+
+  registerTurboModule(
+      L"LogBox", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::LogBox>());
+
+  registerTurboModule(
+      L"Clipboard", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::Clipboard>());
+
+  registerTurboModule(
+      L"DeviceInfo", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DeviceInfo>());
+
+  registerTurboModule(
+      L"ImageLoader", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ImageLoader>());
+
+  registerTurboModule(
+      L"NativeAnimatedModule",
+      winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
+
+#elif defined(CORE_ABI) && defined(USE_FABRIC)
+  if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
+    registerTurboModule(
+        L"ImageLoader",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ImageLoader>());
+
+    registerTurboModule(
+        L"NativeAnimatedModule",
+        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
+  }
+#endif
+
+  if (!m_options.UseWebDebugger()) {
+    turboModulesProvider->AddModuleProvider(
+        L"SampleTurboModule",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::SampleTurboModule>(),
+        false);
+  }
+
+  if (devSettings->useTurboModulesOnly) {
+    ::Microsoft::ReactNative::ExceptionsManager::SetRedBoxHander(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), m_redboxHandler);
+    registerTurboModule(
+        L"ExceptionsManager",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ExceptionsManager>());
+
+    registerTurboModule(
+        L"StatusBarManager",
+        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::StatusBarManager>());
+
+    registerTurboModule(
+        L"PlatformConstants",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::PlatformConstants>());
+    uint32_t hermesBytecodeVersion = 0;
+#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
+    hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
+#endif
+
+    std::string bundleUrl = (devSettings->useWebDebugger || devSettings->liveReloadCallback)
+        ? facebook::react::DevServerHelper::get_BundleUrl(
+              devSettings->sourceBundleHost,
+              devSettings->sourceBundlePort,
+              devSettings->debugBundlePath,
+              devSettings->platformName,
+              devSettings->bundleAppId,
+              devSettings->devBundle,
+              devSettings->useFastRefresh,
+              devSettings->inlineSourceMap,
+              hermesBytecodeVersion)
+        : devSettings->bundleRootPath;
+    ::Microsoft::ReactNative::SourceCode::SetScriptUrl(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), bundleUrl);
+
+    registerTurboModule(
+        L"SourceCode", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::SourceCode>());
+  }
+
+  registerTurboModule(
+      L"DevSettings", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DevSettings>());
+
+#ifndef CORE_ABI
+  registerTurboModule(
+      L"I18nManager", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::I18nManager>());
+
+  registerTurboModule(
+      L"LinkingManager",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::LinkingManager>());
+
+  registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Timing>());
+#else
+
+#if defined(USE_FABRIC)
+  if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
+    registerTurboModule(
+        L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Timing>());
+  } else
+#endif
+  {
+    registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::facebook::react::Timing>());
+  }
+#endif
+
+  registerTurboModule(
+      ::Microsoft::React::GetWebSocketTurboModuleName(), ::Microsoft::React::GetWebSocketModuleProvider());
+
+  if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
+    registerTurboModule(::Microsoft::React::GetHttpTurboModuleName(), ::Microsoft::React::GetHttpModuleProvider());
+
+    registerTurboModule(::Microsoft::React::GetBlobTurboModuleName(), ::Microsoft::React::GetBlobModuleProvider());
+
+    registerTurboModule(
+        ::Microsoft::React::GetFileReaderTurboModuleName(), ::Microsoft::React::GetFileReaderModuleProvider());
+  }
+}
 
 //! Initialize() is called from the native queue.
 void ReactInstanceWin::Initialize() noexcept {
+#ifdef USE_FABRIC
+  if (IsBridgeless()) {
+    InitializeBridgeless();
+  } else
+#endif
+  {
+    InitializeWithBridge();
+  }
+}
+
+void ReactInstanceWin::InitDevMenu() noexcept {
+  Microsoft::ReactNative::DevMenuManager::InitDevMenu(m_reactContext, [weakReactHost = m_weakReactHost]() noexcept {
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
+    Microsoft::ReactNative::ShowConfigureBundlerDialog(weakReactHost);
+#endif // CORE_ABI
+  });
+}
+
+void ReactInstanceWin::InitUIDependentCalls() noexcept {
+#ifndef CORE_ABI
+  Microsoft::ReactNative::AppThemeHolder::InitAppThemeHolder(GetReactContext());
+  Microsoft::ReactNative::I18nManager::InitI18nInfo(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(Options().Properties));
+  Microsoft::ReactNative::Appearance::InitOnUIThread(GetReactContext());
+  Microsoft::ReactNative::DeviceInfoHolder::InitDeviceInfoHolder(GetReactContext());
+#endif // CORE_ABI
+}
+
+std::shared_ptr<facebook::react::DevSettings> ReactInstanceWin::CreateDevSettings() noexcept {
+  auto devSettings = std::make_shared<facebook::react::DevSettings>();
+  devSettings->useJITCompilation = m_options.EnableJITCompilation;
+  devSettings->sourceBundleHost = SourceBundleHost();
+  devSettings->sourceBundlePort = SourceBundlePort();
+  devSettings->inlineSourceMap = RequestInlineSourceMap();
+  devSettings->debugBundlePath = DebugBundlePath();
+  devSettings->liveReloadCallback = GetLiveReloadCallback();
+  devSettings->errorCallback = GetErrorCallback();
+  devSettings->loggingCallback = GetLoggingCallback();
+  m_redboxHandler = devSettings->redboxHandler = std::move(GetRedBoxHandler());
+  devSettings->useDirectDebugger = m_useDirectDebugger;
+  devSettings->debuggerBreakOnNextLine = m_debuggerBreakOnNextLine;
+  devSettings->debuggerPort = m_options.DeveloperSettings.DebuggerPort;
+  devSettings->debuggerRuntimeName = m_options.DeveloperSettings.DebuggerRuntimeName;
+  devSettings->useWebDebugger = m_useWebDebugger;
+  devSettings->useFastRefresh = m_isFastReloadEnabled;
+  devSettings->bundleRootPath = BundleRootPath();
+  devSettings->platformName =
+      winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetPlatformName(m_reactContext->Properties());
+  devSettings->waitingForDebuggerCallback = GetWaitingForDebuggerCallback();
+  devSettings->debuggerAttachCallback = GetDebuggerAttachCallback();
+  devSettings->enableDefaultCrashHandler = m_options.EnableDefaultCrashHandler();
+  devSettings->bundleAppId = BundleAppId();
+  devSettings->devBundle = RequestDevBundle();
+  devSettings->showDevMenuCallback = [weakThis = Mso::WeakPtr{this}]() noexcept {
+    if (auto strongThis = weakThis.GetStrongPtr()) {
+      strongThis->m_uiQueue->Post(
+          [context = strongThis->m_reactContext]() { Microsoft::ReactNative::DevMenuManager::Show(context); });
+    }
+  };
+
+  bool useRuntimeScheduler = winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetUseRuntimeScheduler(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()));
+
+  devSettings->useRuntimeScheduler = useRuntimeScheduler;
+
+  return devSettings;
+}
+
+Mso::DispatchQueueSettings CreateDispatchQueueSettings(
+    const winrt::Microsoft::ReactNative::IReactNotificationService &service) {
+  Mso::DispatchQueueSettings queueSettings{};
+  queueSettings.TaskStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherTaskStartingEventName(), nullptr, nullptr);
+  };
+  queueSettings.IdleWaitStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitStartingEventName(),
+        nullptr,
+        nullptr);
+  };
+  queueSettings.IdleWaitCompleted = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitCompletedEventName(),
+        nullptr,
+        nullptr);
+  };
+  return queueSettings;
+}
+
+std::unique_ptr<facebook::jsi::PreparedScriptStore> CreatePreparedScriptStore() noexcept {
+  std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
+  wchar_t tempPath[MAX_PATH];
+  if (GetTempPathW(static_cast<DWORD>(std::size(tempPath)), tempPath)) {
+    preparedScriptStore = std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+  }
+  return preparedScriptStore;
+}
+
+#ifdef USE_FABRIC
+
+typedef HRESULT(__stdcall *SetThreadDescriptionFn)(HANDLE, PCWSTR);
+void SetJSThreadDescription() noexcept {
+  // Office still supports Server 2016 so we need to use Run Time Dynamic Linking and cannot just use:
+  // ::SetThreadDescription(GetCurrentThread(), L"React-Native JavaScript Thread");
+
+  auto moduleHandle = GetModuleHandleW(L"kernelbase.dll");
+  // The description is just for developer experience, so we can skip it if kernelbase isn't already loaded
+  if (!moduleHandle)
+    return;
+
+  auto proc = GetProcAddress(moduleHandle, "SetThreadDescription");
+  if (!proc)
+    return;
+
+  reinterpret_cast<SetThreadDescriptionFn>(proc)(GetCurrentThread(), L"React-Native JavaScript Thread");
+}
+
+void ReactInstanceWin::InitializeBridgeless() noexcept {
+  InitUIQueue();
+
+  m_uiMessageThread.Exchange(std::make_shared<MessageDispatchQueue2>(
+      *m_uiQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
+
+  ReactPropertyBag(m_reactContext->Properties())
+      .Set(
+          winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueueProperty(),
+          [wkBatchingUIThread = std::weak_ptr<facebook::react::MessageQueueThread>(m_uiMessageThread.Load())](
+              winrt::Microsoft::ReactNative::ReactDispatcherCallback const &callback) {
+            if (auto batchingUIThread = wkBatchingUIThread.lock()) {
+              batchingUIThread->runOnQueue(callback);
+            }
+          });
+
+  InitDevMenu();
+  winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager::Install(
+      ReactPropertyBag(m_reactContext->Properties()), m_options.UriImageManager);
+
+  m_uiQueue->Post([this, weakThis = Mso::WeakPtr{this}]() noexcept {
+    // Objects that must be created on the UI thread
+    if (auto strongThis = weakThis.GetStrongPtr()) {
+      InitUIDependentCalls();
+
+      strongThis->Queue().Post([this, weakThis]() noexcept {
+        if (auto strongThis = weakThis.GetStrongPtr()) {
+          auto devSettings = strongThis->CreateDevSettings();
+          devSettings->useTurboModulesOnly = true;
+
+          try {
+            if (devSettings->useFastRefresh || devSettings->liveReloadCallback) {
+              Microsoft::ReactNative::PackagerConnection::CreateOrReusePackagerConnection(*devSettings);
+            }
+            // null moduleProvider since native modules are not supported in bridgeless
+            LoadModules(devSettings, nullptr, m_options.TurboModuleProvider);
+
+            auto jsDispatchQueue =
+                Mso::DispatchQueue::MakeLooperQueue(CreateDispatchQueueSettings(m_reactContext->Notifications()));
+            auto jsDispatcher =
+                winrt::make<winrt::Microsoft::ReactNative::implementation::ReactDispatcher>(Mso::Copy(jsDispatchQueue));
+            m_options.Properties.Set(ReactDispatcherHelper::JSDispatcherProperty(), jsDispatcher);
+            m_jsMessageThread.Exchange(std::make_shared<Mso::React::MessageDispatchQueue>(
+                jsDispatchQueue,
+                Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError),
+                Mso::Copy(m_whenDestroyed)));
+
+            m_jsMessageThread.Load()->runOnQueueSync([&]() {
+              SetJSThreadDescription();
+              auto timerRegistry =
+                  ::Microsoft::ReactNative::TimerRegistry::CreateTimerRegistry(m_reactContext->Properties());
+              auto timerRegistryRaw = timerRegistry.get();
+
+              auto timerManager = std::make_shared<facebook::react::TimerManager>(std::move(timerRegistry));
+              timerRegistryRaw->setTimerManager(timerManager);
+
+              auto jsErrorHandlingFunc = [this](
+                                             facebook::jsi::Runtime &runtime,
+                                             const facebook::react::JsErrorHandler::ProcessedError &error) noexcept {
+                OnJSError(runtime, std::move(error));
+              };
+
+              if (devSettings->useDirectDebugger) {
+                ::Microsoft::ReactNative::GetSharedDevManager()->EnsureHermesInspector(
+                    devSettings->sourceBundleHost, devSettings->sourceBundlePort);
+              }
+
+              m_jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
+                  devSettings, m_jsMessageThread.Load(), CreatePreparedScriptStore());
+              auto jsRuntime = std::make_unique<Microsoft::ReactNative::HermesJSRuntime>(m_jsiRuntimeHolder);
+              jsRuntime->getRuntime();
+              m_bridgelessReactInstance = std::make_unique<facebook::react::ReactInstance>(
+                  std::move(jsRuntime), m_jsMessageThread.Load(), timerManager, jsErrorHandlingFunc);
+
+              auto bufferedRuntimeExecutor = m_bridgelessReactInstance->getBufferedRuntimeExecutor();
+              timerManager->setRuntimeExecutor(bufferedRuntimeExecutor);
+
+              Microsoft::ReactNative::SchedulerSettings::SetRuntimeScheduler(
+                  winrt::Microsoft::ReactNative::ReactPropertyBag(m_options.Properties),
+                  m_bridgelessReactInstance->getRuntimeScheduler());
+            });
+
+            facebook::react::ReactInstance::JSRuntimeFlags options;
+            m_bridgelessReactInstance->initializeRuntime(options, [=](facebook::jsi::Runtime &runtime) {
+              auto logger = [loggingHook = GetLoggingCallback()](const std::string &message, unsigned int logLevel) {
+                if (loggingHook)
+                  loggingHook(static_cast<facebook::react::RCTLogLevel>(logLevel), message.c_str());
+              };
+              facebook::react::bindNativeLogger(runtime, logger);
+
+              auto turboModuleManager = std::make_shared<facebook::react::TurboModuleManager>(
+                  m_options.TurboModuleProvider,
+                  std::make_shared<facebook::react::RuntimeSchedulerCallInvoker>(
+                      m_bridgelessReactInstance->getRuntimeScheduler()));
+
+              auto binding =
+                  [turboModuleManager](const std::string &name) -> std::shared_ptr<facebook::react::TurboModule> {
+                return turboModuleManager->getModule(name);
+              };
+
+              // Use a legacy native module binding that always returns null
+              // This means that calls to NativeModules.XXX will always return null, rather than crashing on access
+              auto legacyNativeModuleBinding =
+                  [](const std::string & /*name*/) -> std::shared_ptr<facebook::react::TurboModule> { return nullptr; };
+
+              facebook::react::TurboModuleBinding::install(
+                  runtime,
+                  std::function(binding),
+                  std::function(legacyNativeModuleBinding),
+                  m_options.TurboModuleProvider->LongLivedObjectCollection());
+
+              auto componentDescriptorRegistry =
+                  Microsoft::ReactNative::WindowsComponentDescriptorRegistry::FromProperties(
+                      winrt::Microsoft::ReactNative::ReactPropertyBag(m_options.Properties));
+              auto hasComponentProvider = [componentDescriptorRegistry](const std::string &name) -> bool {
+                return componentDescriptorRegistry->hasComponentProvider(
+                    facebook::react::componentNameByReactViewName(name));
+              };
+              facebook::react::bindHasComponentProvider(runtime, std::move(hasComponentProvider));
+
+              // init TurboModule
+              for (const auto &moduleName : turboModuleManager->getEagerInitModuleNames()) {
+                turboModuleManager->getModule(moduleName);
+              }
+            });
+
+            m_options.TurboModuleProvider->SetReactContext(
+                winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
+
+            FireInstanceCreatedCallback();
+
+            LoadJSBundlesBridgeless(devSettings);
+            SetupHMRClient();
+
+          } catch (std::exception &e) {
+            OnErrorWithMessage(e.what());
+            OnErrorWithMessage("ReactInstanceWin: Failed to create React Instance.");
+          } catch (winrt::hresult_error const &e) {
+            OnErrorWithMessage(Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()));
+            OnErrorWithMessage("ReactInstanceWin: Failed to create React Instance.");
+          } catch (...) {
+            OnErrorWithMessage("ReactInstanceWin: Failed to create React Instance.");
+          }
+        }
+      });
+    }
+  });
+}
+#endif
+
+void ReactInstanceWin::FireInstanceCreatedCallback() noexcept {
+  // The InstanceCreated event can be used to augment the JS environment for all JS code.  So it needs to be
+  // triggered before any platform JS code is run. Using m_jsMessageThread instead of jsDispatchQueue avoids
+  // waiting for the JSCaller which can delay the event until after certain JS code has already run
+  m_jsMessageThread.Load()->runOnQueue(
+      [onCreated = m_options.OnInstanceCreated, reactContext = m_reactContext]() noexcept {
+        if (onCreated) {
+          onCreated.Get()->Invoke(reactContext);
+        }
+      });
+}
+
+void ReactInstanceWin::InitializeWithBridge() noexcept {
   InitJSMessageThread();
   InitNativeMessageThread();
-  InitUIMessageThread();
 
-  m_legacyReactInstance = std::make_shared<react::uwp::UwpReactInstanceProxy>(this);
+  InitUIQueue();
+  InitUIMessageThread();
 
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
   // InitUIManager uses m_legacyReactInstance
   InitUIManager();
+#endif
 
-  Microsoft::ReactNative::DevMenuManager::InitDevMenu(m_reactContext);
+  InitDevMenu();
+#ifdef USE_FABRIC
+  winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager::Install(
+      ReactPropertyBag(m_reactContext->Properties()), m_options.UriImageManager);
+#endif
 
-  Mso::PostFuture(
-      m_uiQueue,
-      [weakThis = Mso::WeakPtr{this}]() noexcept {
-        // Objects that must be created on the UI thread
+  m_uiQueue->Post([this, weakThis = Mso::WeakPtr{this}]() noexcept {
+    // Objects that must be created on the UI thread
+    if (auto strongThis = weakThis.GetStrongPtr()) {
+      InitUIDependentCalls();
+      strongThis->Queue().Post([this, weakThis]() noexcept {
         if (auto strongThis = weakThis.GetStrongPtr()) {
-          auto const &legacyInstance = strongThis->m_legacyReactInstance;
-          strongThis->m_appTheme =
-              std::make_shared<react::uwp::AppTheme>(legacyInstance, strongThis->m_uiMessageThread.LoadWithLock());
-          Microsoft::ReactNative::I18nManager::InitI18nInfo(
-              winrt::Microsoft::ReactNative::ReactPropertyBag(strongThis->Options().Properties));
-          strongThis->m_appearanceListener =
-              Mso::Make<react::uwp::AppearanceChangeListener>(legacyInstance, strongThis->m_uiQueue);
-          Microsoft::ReactNative::DeviceInfoHolder::InitDeviceInfoHolder(
-              winrt::Microsoft::ReactNative::ReactPropertyBag(strongThis->Options().Properties));
-        }
-      })
-      .Then(Queue(), [ this, weakThis = Mso::WeakPtr{this} ]() noexcept {
-        if (auto strongThis = weakThis.GetStrongPtr()) {
-          // auto cxxModulesProviders = GetCxxModuleProviders();
-
-          auto devSettings = std::make_shared<facebook::react::DevSettings>();
-          devSettings->useJITCompilation = m_options.EnableJITCompilation;
-          devSettings->debugHost = GetDebugHost();
-          devSettings->debugBundlePath = m_options.DeveloperSettings.SourceBundleName;
-          devSettings->liveReloadCallback = GetLiveReloadCallback();
-          devSettings->errorCallback = GetErrorCallback();
-          devSettings->loggingCallback = GetLoggingCallback();
-          m_redboxHandler = devSettings->redboxHandler = std::move(GetRedBoxHandler());
-          devSettings->useDirectDebugger = m_useDirectDebugger;
-          devSettings->debuggerBreakOnNextLine = m_debuggerBreakOnNextLine;
-          devSettings->debuggerPort = m_options.DeveloperSettings.DebuggerPort;
-          devSettings->debuggerRuntimeName = m_options.DeveloperSettings.DebuggerRuntimeName;
-          devSettings->useWebDebugger = m_useWebDebugger;
-          devSettings->useFastRefresh = m_isFastReloadEnabled;
-          // devSettings->memoryTracker = GetMemoryTracker();
-          devSettings->bundleRootPath =
-              m_options.BundleRootPath.empty() ? "ms-appx:///Bundle/" : m_options.BundleRootPath;
-          m_bundleRootPath = devSettings->bundleRootPath;
-
-          devSettings->waitingForDebuggerCallback = GetWaitingForDebuggerCallback();
-          devSettings->debuggerAttachCallback = GetDebuggerAttachCallback();
-
-          // Now that ReactNativeWindows is building outside devmain, it is missing
-          // fix given by PR https://github.com/microsoft/react-native-windows/pull/2624 causing
-          // regression. We're turning off console redirection till the fix is available in devmain.
-          // Bug https://office.visualstudio.com/DefaultCollection/OC/_workitems/edit/3441551 is tracking this
-          devSettings->debuggerConsoleRedirection =
-              false; // JSHost::ChangeGate::ChakraCoreDebuggerConsoleRedirection();
-
-          // Acquire default modules and then populate with custom modules
-          std::vector<facebook::react::NativeModuleDescription> cxxModules = react::uwp::GetCoreModules(
-              m_uiManager.Load(),
-              m_batchingUIThread,
-              m_uiMessageThread.Load(),
-              std::move(m_appTheme),
-              std::move(m_appearanceListener),
-              m_legacyReactInstance);
+          auto devSettings = strongThis->CreateDevSettings();
 
-          auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
+          auto getBoolProperty = [properties = ReactPropertyBag{m_options.Properties}](
+                                     const wchar_t *ns, const wchar_t *name, bool defaultValue) noexcept -> bool {
+            ReactPropertyId<bool> propId{ns == nullptr ? ReactPropertyNamespace() : ReactPropertyNamespace(ns), name};
+            std::optional<bool> propValue = properties.Get(propId);
+            return propValue.value_or(defaultValue);
+          };
 
-          nmp->AddModuleProvider(
-              L"Alert", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Alert>());
-
-          nmp->AddModuleProvider(
-              L"AppState",
-              winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                  ::Microsoft::ReactNative::AppState,
-                  ::Microsoft::ReactNativeSpecs::AppStateSpec>());
-
-          nmp->AddModuleProvider(
-              L"LogBox",
-              winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                  ::Microsoft::ReactNative::LogBox,
-                  ::Microsoft::ReactNativeSpecs::LogBoxSpec>());
-
-          if (m_options.UseWebDebugger()) {
-            nmp->AddModuleProvider(
-                L"Clipboard",
-                winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                    ::Microsoft::ReactNative::Clipboard,
-                    ::Microsoft::ReactNativeSpecs::ClipboardSpec>());
-          } else {
-            m_options.TurboModuleProvider->AddModuleProvider(
-                L"Clipboard",
-                winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                    ::Microsoft::ReactNative::Clipboard,
-                    ::Microsoft::ReactNativeSpecs::ClipboardSpec>());
-          }
+          devSettings->omitNetworkingCxxModules = getBoolProperty(nullptr, L"OmitNetworkingCxxModules", false);
+          devSettings->useWebSocketTurboModule = getBoolProperty(nullptr, L"UseWebSocketTurboModule", false);
+          devSettings->useTurboModulesOnly = getBoolProperty(L"DevSettings", L"UseTurboModulesOnly", false);
 
-          ::Microsoft::ReactNative::DevSettings::SetReload(
-              strongThis->Options(), [weakReactHost = m_weakReactHost]() noexcept {
-                if (auto reactHost = weakReactHost.GetStrongPtr()) {
-                  reactHost->ReloadInstance();
-                }
-              });
+          std::vector<facebook::react::NativeModuleDescription> cxxModules;
+          auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
+
+          LoadModules(devSettings, nmp, m_options.TurboModuleProvider);
 
-          nmp->AddModuleProvider(
-              L"DeviceInfo",
-              winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                  ::Microsoft::ReactNative::DeviceInfo,
-                  ::Microsoft::ReactNativeSpecs::DeviceInfoSpec>());
-
-          nmp->AddModuleProvider(
-              L"DevSettings",
-              winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                  ::Microsoft::ReactNative::DevSettings,
-                  ::Microsoft::ReactNativeSpecs::DevSettingsSpec>());
-
-          nmp->AddModuleProvider(
-              L"I18nManager",
-              winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-                  ::Microsoft::ReactNative::I18nManager,
-                  ::Microsoft::ReactNativeSpecs::I18nManagerSpec>());
-
-          auto modules = nmp->GetModules(m_reactContext, m_batchingUIThread);
+          auto modules = nmp->GetModules(m_reactContext, m_jsMessageThread.Load());
           cxxModules.insert(
               cxxModules.end(), std::make_move_iterator(modules.begin()), std::make_move_iterator(modules.end()));
 
           if (m_options.ModuleProvider != nullptr) {
             std::vector<facebook::react::NativeModuleDescription> customCxxModules =
-                m_options.ModuleProvider->GetModules(m_reactContext, m_batchingUIThread);
+                m_options.ModuleProvider->GetModules(m_reactContext, m_jsMessageThread.Load());
             cxxModules.insert(std::end(cxxModules), std::begin(customCxxModules), std::end(customCxxModules));
           }
 
-          if (m_options.UseJsi) {
-            std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
-            std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
+          std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
+          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
 
-            switch (m_options.JsiEngine) {
-              case react::uwp::JSIEngine::Hermes:
-#if defined(USE_HERMES)
-                devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::HermesRuntimeHolder>();
+          if (const auto jsExecutorFactoryDelegate =
+                  Microsoft::JSI::JSExecutorFactorySettings::GetJSExecutorFactoryDelegate(
+                      winrt::Microsoft::ReactNative::ReactPropertyBag(strongThis->Options().Properties))) {
+            devSettings->jsExecutorFactoryDelegate = jsExecutorFactoryDelegate;
+            if (m_options.JsiEngine() == JSIEngine::Hermes) {
+              devSettings->jsiEngineOverride = facebook::react::JSIEngineOverride::Hermes;
+            }
+          } else {
+            switch (m_options.JsiEngine()) {
+              case JSIEngine::Hermes: {
+                preparedScriptStore = CreatePreparedScriptStore();
+
+                auto hermesRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
+                    devSettings, m_jsMessageThread.Load(), std::move(preparedScriptStore));
+                Microsoft::ReactNative::HermesRuntimeHolder::storeTo(
+                    ReactPropertyBag(m_reactContext->Properties()), hermesRuntimeHolder);
+                devSettings->jsiRuntimeHolder = hermesRuntimeHolder;
                 break;
-#endif
-              case react::uwp::JSIEngine::V8:
+              }
+              case JSIEngine::V8:
 #if defined(USE_V8)
-                preparedScriptStore =
-                    std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationLocalFolder());
+              {
+                preparedScriptStore = CreatePreparedScriptStore();
+                bool enableMultiThreadSupport{false};
+#ifdef USE_FABRIC
+                enableMultiThreadSupport = Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties());
+#endif // USE_FABRIC
+
+                if (m_options.JsiEngineV8NodeApi()) {
+                  devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::V8RuntimeHolder>(
+                      devSettings, m_jsMessageThread.Load(), std::move(preparedScriptStore), enableMultiThreadSupport);
+                } else {
+                  devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
+                      devSettings,
+                      m_jsMessageThread.Load(),
+                      std::move(scriptStore),
+                      std::move(preparedScriptStore),
+                      enableMultiThreadSupport);
+                }
 
-                devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
-                    devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
                 break;
-#endif
-              case react::uwp::JSIEngine::Chakra:
+              }
+#endif // USE_V8
+              case JSIEngine::Chakra:
+#ifndef CORE_ABI
                 if (m_options.EnableByteCodeCaching || !m_options.ByteCodeFileUri.empty()) {
-                  scriptStore = std::make_unique<react::uwp::UwpScriptStore>();
-                  preparedScriptStore = std::make_unique<react::uwp::UwpPreparedScriptStore>(
+                  scriptStore = std::make_unique<Microsoft::ReactNative::UwpScriptStore>();
+                  preparedScriptStore = std::make_unique<Microsoft::ReactNative::UwpPreparedScriptStore>(
                       winrt::to_hstring(m_options.ByteCodeFileUri));
                 }
+#endif
                 devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::JSI::ChakraRuntimeHolder>(
                     devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
                 break;
             }
           }
 
+          m_jsiRuntimeHolder = devSettings->jsiRuntimeHolder;
+
           try {
             // We need to keep the instance wrapper alive as its destruction shuts down the native queue.
             m_options.TurboModuleProvider->SetReactContext(
                 winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
+
+            auto bundleRootPath = devSettings->bundleRootPath;
+            auto jsiRuntimeHolder = devSettings->jsiRuntimeHolder;
             auto instanceWrapper = facebook::react::CreateReactInstance(
-                std::string(), // bundleRootPath
+                std::shared_ptr<facebook::react::Instance>(strongThis->m_instance.Load()),
+                std::move(bundleRootPath), // bundleRootPath
                 std::move(cxxModules),
                 m_options.TurboModuleProvider,
-                m_uiManager.Load(),
+                m_options.TurboModuleProvider->LongLivedObjectCollection(),
+                m_reactContext->Properties(),
+                std::make_unique<BridgeUIBatchInstanceCallback>(weakThis),
                 m_jsMessageThread.Load(),
-                Mso::Copy(m_batchingUIThread),
+                m_nativeMessageThread.Load(),
                 std::move(devSettings));
 
-            m_instance.Exchange(Mso::Copy(instanceWrapper->GetInstance()));
             m_instanceWrapper.Exchange(std::move(instanceWrapper));
 
-            if (auto onCreated = m_options.OnInstanceCreated.Get()) {
-              onCreated->Invoke(*this);
-            }
-
+            FireInstanceCreatedCallback();
             LoadJSBundles();
-
-            if (m_options.UseDeveloperSupport() && State() != ReactInstanceState::HasError) {
-              folly::dynamic params = folly::dynamic::array(
-                  STRING(RN_PLATFORM),
-                  m_options.DeveloperSettings.SourceBundleName.empty() ? m_options.Identity
-                                                                       : m_options.DeveloperSettings.SourceBundleName,
-                  GetSourceBundleHost(),
-                  GetSourceBundlePort(),
-                  m_isFastReloadEnabled);
-              m_instance.Load()->callJSFunction("HMRClient", "setup", std::move(params));
-            }
+            SetupHMRClient();
 
           } catch (std::exception &e) {
             OnErrorWithMessage(e.what());
@@ -380,6 +918,22 @@ void ReactInstanceWin::Initialize() noexcept {
           }
         }
       });
+    };
+  });
+}
+
+void ReactInstanceWin::SetupHMRClient() noexcept {
+  if (UseDeveloperSupport() && State() != ReactInstanceState::HasError) {
+    folly::dynamic params = folly::dynamic::array(
+        winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetPlatformName(
+            m_reactContext->Properties()),
+        DebugBundlePath(),
+        SourceBundleHost(),
+        SourceBundlePort(),
+        m_isFastReloadEnabled,
+        "ws");
+    CallJsFunction("HMRClient", "setup", std::move(params));
+  }
 }
 
 void ReactInstanceWin::LoadJSBundles() noexcept {
@@ -405,70 +959,96 @@ void ReactInstanceWin::LoadJSBundles() noexcept {
   if (m_useWebDebugger || m_isFastReloadEnabled) {
     // Getting bundle from the packager, so do everything async.
     auto instanceWrapper = m_instanceWrapper.LoadWithLock();
-    instanceWrapper->loadBundle(Mso::Copy(m_options.Identity));
-
-    m_jsMessageThread.Load()->runOnQueue([
-      weakThis = Mso::WeakPtr{this},
-      loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})
-    ]() noexcept {
-      if (auto strongThis = weakThis.GetStrongPtr()) {
-        if (strongThis->State() != ReactInstanceState::HasError) {
-          strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
-        }
-      }
-    });
+    instanceWrapper->loadBundle(Mso::Copy(JavaScriptBundleFile()));
+
+    m_jsMessageThread.Load()->runOnQueue(
+        [weakThis = Mso::WeakPtr{this},
+         loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})]() noexcept {
+          if (auto strongThis = weakThis.GetStrongPtr()) {
+            if (strongThis->State() != ReactInstanceState::HasError) {
+              strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
+            }
+          }
+        });
   } else {
-    m_jsMessageThread.Load()->runOnQueue([
-      weakThis = Mso::WeakPtr{this},
-      loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})
-    ]() noexcept {
-      if (auto strongThis = weakThis.GetStrongPtr()) {
-        auto instance = strongThis->m_instance.LoadWithLock();
-        auto instanceWrapper = strongThis->m_instanceWrapper.LoadWithLock();
-        if (!instance || !instanceWrapper) {
-          return;
-        }
-
-        auto &options = strongThis->m_options;
-
-        try {
-          instanceWrapper->loadBundleSync(Mso::Copy(options.Identity));
-        } catch (...) {
-          strongThis->m_state = ReactInstanceState::HasError;
-          strongThis->AbandonJSCallQueue();
-          strongThis->OnReactInstanceLoaded(Mso::ExceptionErrorProvider().MakeErrorCode(std::current_exception()));
-          return;
-        }
+    m_jsMessageThread.Load()->runOnQueue(
+        [weakThis = Mso::WeakPtr{this},
+         loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})]() noexcept {
+          if (auto strongThis = weakThis.GetStrongPtr()) {
+            auto instance = strongThis->m_instance.LoadWithLock();
+            auto instanceWrapper = strongThis->m_instanceWrapper.LoadWithLock();
+            if (!instance || !instanceWrapper) {
+              return;
+            }
 
-        // All JS bundles successfully loaded.
-        strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
-      }
-    });
+            try {
+              instanceWrapper->loadBundleSync(Mso::Copy(strongThis->JavaScriptBundleFile()));
+              if (strongThis->State() != ReactInstanceState::HasError) {
+                strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
+              }
+            } catch (...) {
+              strongThis->OnReactInstanceLoaded(Mso::ExceptionErrorProvider().MakeErrorCode(std::current_exception()));
+            }
+          }
+        });
   }
 }
 
-void ReactInstanceWin::OnReactInstanceLoaded(const Mso::ErrorCode &errorCode) noexcept {
-  if (!m_isLoaded) {
-    Queue().InvokeElsePost([ weakThis = Mso::WeakPtr{this}, errorCode ]() noexcept {
-      if (auto strongThis = weakThis.GetStrongPtr()) {
-        if (!strongThis->m_isLoaded) {
-          strongThis->m_isLoaded = true;
-          if (!errorCode) {
-            strongThis->m_state = ReactInstanceState::Loaded;
-            strongThis->DrainJSCallQueue();
-          } else {
-            strongThis->m_state = ReactInstanceState::HasError;
-            strongThis->AbandonJSCallQueue();
-          }
+#ifdef USE_FABRIC
+void ReactInstanceWin::LoadJSBundlesBridgeless(std::shared_ptr<facebook::react::DevSettings> devSettings) noexcept {
+  if (m_isFastReloadEnabled) {
+    // Getting bundle from the packager, so do everything async.
 
-          if (auto onLoaded = strongThis->m_options.OnInstanceLoaded.Get()) {
-            onLoaded->Invoke(*strongThis, errorCode);
+    ::Microsoft::ReactNative::LoadRemoteUrlScript(
+        devSettings,
+        ::Microsoft::ReactNative::GetSharedDevManager(),
+        Mso::Copy(JavaScriptBundleFile()),
+        [=](std::unique_ptr<const facebook::react::JSBigStdString> script, const std::string &sourceURL) {
+          m_bridgelessReactInstance->loadScript(std::move(script), sourceURL);
+        });
+
+    m_jsMessageThread.Load()->runOnQueue(
+        [weakThis = Mso::WeakPtr{this},
+         loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})]() noexcept {
+          if (auto strongThis = weakThis.GetStrongPtr()) {
+            if (strongThis->State() != ReactInstanceState::HasError) {
+              strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
+            }
+          }
+        });
+  } else {
+    auto bundleString = ::Microsoft::ReactNative::JsBigStringFromPath(devSettings, Mso::Copy(JavaScriptBundleFile()));
+    m_bridgelessReactInstance->loadScript(std::move(bundleString), Mso::Copy(JavaScriptBundleFile()));
+
+    m_jsMessageThread.Load()->runOnQueue(
+        [weakThis = Mso::WeakPtr{this},
+         loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})]() noexcept {
+          if (auto strongThis = weakThis.GetStrongPtr()) {
+            try {
+              if (strongThis->State() != ReactInstanceState::HasError) {
+                strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
+              }
+            } catch (...) {
+              strongThis->OnReactInstanceLoaded(Mso::ExceptionErrorProvider().MakeErrorCode(std::current_exception()));
+            }
           }
+        });
+  }
+}
+#endif
 
-          strongThis->m_whenLoaded.SetValue();
-        }
-      }
-    });
+void ReactInstanceWin::OnReactInstanceLoaded(const Mso::ErrorCode &errorCode) noexcept {
+  bool isLoadedExpected = false;
+  if (m_isLoaded.compare_exchange_strong(isLoadedExpected, true)) {
+    if (!errorCode) {
+      m_state = ReactInstanceState::Loaded;
+      m_whenLoaded.SetValue();
+      DrainJSCallQueue();
+    } else {
+      m_state = ReactInstanceState::HasError;
+      m_whenLoaded.SetError(errorCode);
+      OnError(errorCode);
+    }
   }
 }
 
@@ -477,32 +1057,48 @@ Mso::Future<void> ReactInstanceWin::Destroy() noexcept {
   VerifyIsInQueueElseCrash();
 
   if (m_isDestroyed) {
-    return m_whenDestroyed.AsFuture();
+    return m_whenDestroyedResult;
   }
 
   m_isDestroyed = true;
   m_state = ReactInstanceState::Unloaded;
   AbandonJSCallQueue();
 
-  if (!m_isLoaded) {
-    OnReactInstanceLoaded(Mso::CancellationErrorProvider().MakeErrorCode(true));
-  }
-
-  if (auto onDestroyed = m_options.OnInstanceDestroyed.Get()) {
-    onDestroyed->Invoke(*this);
-  }
-
   // Make sure that the instance is not destroyed yet
   if (auto instance = m_instance.Exchange(nullptr)) {
+    {
+      // Release the JSI runtime
+      std::scoped_lock lock{m_mutex};
+      m_jsiRuntimeHolder = nullptr;
+      m_jsiRuntime = nullptr;
+    }
     // Release the message queues before the ui manager and instance.
     m_nativeMessageThread.Exchange(nullptr);
     m_jsMessageThread.Exchange(nullptr);
-    m_uiManager.Exchange(nullptr);
     m_instanceWrapper.Exchange(nullptr);
     m_jsDispatchQueue.Exchange(nullptr);
   }
 
-  return m_whenDestroyed.AsFuture();
+#ifdef USE_FABRIC
+  if (m_bridgelessReactInstance) {
+    if (auto jsMessageThread = m_jsMessageThread.Exchange(nullptr)) {
+      jsMessageThread->runOnQueueSync([&]() noexcept {
+        {
+          // Release the JSI runtime
+          std::scoped_lock lock{m_mutex};
+
+          this->m_jsiRuntimeHolder = nullptr;
+          this->m_jsiRuntime = nullptr;
+        }
+        this->m_bridgelessReactInstance = nullptr;
+        jsMessageThread->quitSynchronous();
+      });
+    }
+    m_jsDispatchQueue.Exchange(nullptr);
+  }
+#endif
+
+  return m_whenDestroyedResult;
 }
 
 const ReactOptions &ReactInstanceWin::Options() const noexcept {
@@ -514,17 +1110,20 @@ ReactInstanceState ReactInstanceWin::State() const noexcept {
 }
 
 void ReactInstanceWin::InitJSMessageThread() noexcept {
-  auto jsDispatchQueue = Mso::DispatchQueue::MakeLooperQueue();
+  m_instance.Exchange(std::make_shared<facebook::react::Instance>());
 
-  // Create MessageQueueThread for the DispatchQueue
-  VerifyElseCrashSz(jsDispatchQueue, "m_jsDispatchQueue must not be null");
+  auto scheduler = Mso::MakeJSCallInvokerScheduler(
+      CreateDispatchQueueSettings(m_reactContext->Notifications()),
+      m_instance.Load()->getJSCallInvoker(),
+      Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError),
+      Mso::Copy(m_whenDestroyed));
+  auto jsDispatchQueue = Mso::DispatchQueue::MakeCustomQueue(Mso::CntPtr(scheduler));
 
   auto jsDispatcher =
       winrt::make<winrt::Microsoft::ReactNative::implementation::ReactDispatcher>(Mso::Copy(jsDispatchQueue));
   m_options.Properties.Set(ReactDispatcherHelper::JSDispatcherProperty(), jsDispatcher);
 
-  m_jsMessageThread.Exchange(std::make_shared<MessageDispatchQueue>(
-      jsDispatchQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError), Mso::Copy(m_whenDestroyed)));
+  m_jsMessageThread.Exchange(qi_cast<Mso::IJSCallInvokerQueueScheduler>(scheduler.Get())->GetMessageQueue());
   m_jsDispatchQueue.Exchange(std::move(jsDispatchQueue));
 }
 
@@ -534,34 +1133,63 @@ void ReactInstanceWin::InitNativeMessageThread() noexcept {
       std::make_shared<MessageDispatchQueue>(Queue(), Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
 }
 
-void ReactInstanceWin::InitUIMessageThread() noexcept {
-  // Native queue was already given us in constructor.
-  m_uiQueue = winrt::Microsoft::ReactNative::implementation::ReactDispatcher::GetUIDispatchQueue(m_options.Properties);
+void ReactInstanceWin::InitUIQueue() noexcept {
+  m_uiQueue = winrt::Microsoft::ReactNative::implementation::ReactDispatcher::GetUIDispatchQueue2(m_options.Properties);
   VerifyElseCrashSz(m_uiQueue, "No UI Dispatcher provided");
-  m_uiMessageThread.Exchange(
-      std::make_shared<MessageDispatchQueue>(m_uiQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
+}
 
-  m_batchingUIThread = react::uwp::MakeBatchingQueueThread(m_uiMessageThread.Load());
+void ReactInstanceWin::InitUIMessageThread() noexcept {
+  m_uiMessageThread.Exchange(std::make_shared<MessageDispatchQueue2>(
+      *m_uiQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
+
+  auto batchingUIThread = Microsoft::ReactNative::MakeBatchingQueueThread(m_uiMessageThread.Load());
+  m_batchingUIThread = batchingUIThread;
+
+  ReactPropertyBag(m_reactContext->Properties())
+      .Set(
+          winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueueProperty(),
+          [wkBatchingUIThread = std::weak_ptr<facebook::react::BatchingMessageQueueThread>(batchingUIThread)](
+              winrt::Microsoft::ReactNative::ReactDispatcherCallback const &callback) {
+            if (auto batchingUIThread = wkBatchingUIThread.lock()) {
+              batchingUIThread->runOnQueue(callback);
+            }
+          });
+
+  m_jsDispatchQueue.Load().Post(
+      [batchingUIThread, instance = std::weak_ptr<facebook::react::Instance>(m_instance.Load())]() noexcept {
+        batchingUIThread->decoratedNativeCallInvokerReady(instance);
+      });
+}
+
+bool ReactInstanceWin::IsBridgeless() noexcept {
+  return winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetIsBridgeless(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()));
 }
 
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
 void ReactInstanceWin::InitUIManager() noexcept {
-  std::vector<std::unique_ptr<facebook::react::IViewManager>> viewManagers;
+  std::vector<std::unique_ptr<Microsoft::ReactNative::IViewManager>> viewManagers;
 
   // Custom view managers
   if (m_options.ViewManagerProvider) {
-    viewManagers = m_options.ViewManagerProvider->GetViewManagers(m_reactContext, m_legacyReactInstance);
+    viewManagers = m_options.ViewManagerProvider->GetViewManagers(m_reactContext);
   }
 
-  react::uwp::AddStandardViewManagers(viewManagers, m_legacyReactInstance);
-  react::uwp::AddPolyesterViewManagers(viewManagers, m_legacyReactInstance);
+  Microsoft::ReactNative::AddStandardViewManagers(viewManagers, *m_reactContext);
+
+  auto uiManagerSettings = std::make_unique<Microsoft::ReactNative::UIManagerSettings>(
+      m_batchingUIThread, m_uiMessageThread.Load(), std::move(viewManagers));
+  Microsoft::ReactNative::UIManager::SetSettings(m_reactContext->Properties(), std::move(uiManagerSettings));
 
-  auto uiManager = react::uwp::CreateUIManager2(m_reactContext.Get(), std::move(viewManagers));
-  auto wkUIManger = std::weak_ptr<facebook::react::IUIManager>(uiManager);
   m_reactContext->Properties().Set(
       implementation::XamlUIService::XamlUIServiceProperty().Handle(),
-      winrt::make<implementation::XamlUIService>(std::move(wkUIManger), m_reactContext));
-  m_uiManager.Exchange(std::move(uiManager));
+      winrt::make<implementation::XamlUIService>(m_reactContext));
+
+  m_reactContext->Properties().Set(
+      implementation::LayoutService::LayoutServiceProperty().Handle(),
+      winrt::make<implementation::LayoutService>(m_reactContext));
 }
+#endif
 
 facebook::react::NativeLoggingHook ReactInstanceWin::GetLoggingCallback() noexcept {
   if (m_options.OnLogging) {
@@ -571,7 +1199,7 @@ facebook::react::NativeLoggingHook ReactInstanceWin::GetLoggingCallback() noexce
   } else {
     // When no logging callback was specified, use a default one in DEBUG builds
 #if DEBUG
-    return [telemetryTag{m_options.Identity}](facebook::react::RCTLogLevel logLevel, const char *message) {
+    return [telemetryTag{JavaScriptBundleFile()}](facebook::react::RCTLogLevel logLevel, const char *message) {
       std::ostringstream ss;
       ss << "ReactNative ['" << telemetryTag << "'] (";
       switch (logLevel) {
@@ -603,9 +1231,14 @@ facebook::react::NativeLoggingHook ReactInstanceWin::GetLoggingCallback() noexce
 std::shared_ptr<IRedBoxHandler> ReactInstanceWin::GetRedBoxHandler() noexcept {
   if (m_options.RedBoxHandler) {
     return m_options.RedBoxHandler;
-  } else if (m_options.UseDeveloperSupport()) {
+#ifndef CORE_ABI
+  } else if (UseDeveloperSupport()) {
     auto localWkReactHost = m_weakReactHost;
-    return CreateDefaultRedBoxHandler(std::move(localWkReactHost), Mso::Copy(m_uiQueue));
+    return CreateDefaultRedBoxHandler(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()),
+        std::move(localWkReactHost),
+        *m_uiQueue);
+#endif
   } else {
     return {};
   }
@@ -619,29 +1252,6 @@ std::function<void()> ReactInstanceWin::GetLiveReloadCallback() noexcept {
   return std::function<void()>{};
 }
 
-std::string ReactInstanceWin::GetSourceBundleHost() noexcept {
-  const ReactDevOptions &devOptions = m_options.DeveloperSettings;
-  return !devOptions.SourceBundleHost.empty() ? devOptions.SourceBundleHost : "localhost";
-}
-
-std::string ReactInstanceWin::GetSourceBundlePort() noexcept {
-  const ReactDevOptions &devOptions = m_options.DeveloperSettings;
-  return !devOptions.SourceBundlePort.empty() ? devOptions.SourceBundlePort : "8081";
-}
-
-std::string ReactInstanceWin::GetDebugHost() noexcept {
-  std::string debugHost;
-  const ReactDevOptions &devOptions = m_options.DeveloperSettings;
-  if (!devOptions.DebugHost.empty()) {
-    debugHost = devOptions.DebugHost;
-  } else {
-    debugHost = GetSourceBundleHost();
-    debugHost.append(":");
-    debugHost.append(GetSourceBundlePort());
-  }
-  return debugHost;
-}
-
 std::string ReactInstanceWin::GetBytecodeFileName() noexcept {
   // use bytecode caching if enabled and not debugging
   // (ChakraCore debugging does not work when bytecode caching is enabled)
@@ -656,23 +1266,55 @@ std::function<void(std::string)> ReactInstanceWin::GetErrorCallback() noexcept {
 }
 
 void ReactInstanceWin::OnErrorWithMessage(const std::string &errorMessage) noexcept {
+  OnError(Mso::React::ReactErrorProvider().MakeErrorCode(Mso::React::ReactError{errorMessage.c_str()}));
+}
+
+void ReactInstanceWin::OnError(const Mso::ErrorCode &errorCode) noexcept {
   m_state = ReactInstanceState::HasError;
   AbandonJSCallQueue();
 
   if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
     ErrorInfo errorInfo;
-    errorInfo.Message = errorMessage;
+    errorInfo.Message = errorCode.ToString();
     errorInfo.Id = 0;
     m_redboxHandler->showNewError(std::move(errorInfo), ErrorType::Native);
   }
 
-  OnError(Mso::React::ReactErrorProvider().MakeErrorCode(Mso::React::ReactError{errorMessage.c_str()}));
+  InvokeInQueue([this, errorCode]() noexcept { m_options.OnError(errorCode); });
+
   m_updateUI();
 }
 
-void ReactInstanceWin::OnError(const Mso::ErrorCode &errorCode) noexcept {
-  InvokeInQueue([ this, errorCode ]() noexcept { m_options.OnError(errorCode); });
+#ifdef USE_FABRIC
+void ReactInstanceWin::OnJSError(
+    facebook::jsi::Runtime &runtime,
+    const facebook::react::JsErrorHandler::ProcessedError &error) noexcept {
+  ErrorInfo errorInfo;
+  errorInfo.Message = error.message;
+  auto errorCode = Mso::React::ReactErrorProvider().MakeErrorCode(Mso::React::ReactError{errorInfo.Message.c_str()});
+
+  for (const facebook::react::JsErrorHandler::ProcessedError::StackFrame &frame : error.stack) {
+    errorInfo.Callstack.push_back(
+        {frame.file.value(), frame.methodName, frame.lineNumber.value(), frame.column.value()});
+  }
+
+  errorInfo.Id = error.id;
+
+  bool isFatal = error.isFatal;
+
+  m_state = ReactInstanceState::HasError;
+  AbandonJSCallQueue();
+
+  OnReactInstanceLoaded(errorCode);
+  if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
+    m_redboxHandler->showNewError(std::move(errorInfo), isFatal ? ErrorType::JSFatal : ErrorType::JSSoft);
+  }
+
+  InvokeInQueue([this, errorCode]() noexcept { m_options.OnError(errorCode); });
+
+  m_updateUI();
 }
+#endif
 
 void ReactInstanceWin::OnLiveReload() noexcept {
   if (auto reactHost = m_weakReactHost.GetStrongPtr()) {
@@ -725,7 +1367,12 @@ void ReactInstanceWin::DrainJSCallQueue() noexcept {
       }
     }
 
-    if (auto instance = m_instance.LoadWithLock()) {
+#ifdef USE_FABRIC
+    if (m_bridgelessReactInstance) {
+      m_bridgelessReactInstance->callFunctionOnModule(entry.ModuleName, entry.MethodName, std::move(entry.Args));
+    } else
+#endif
+        if (auto instance = m_instance.LoadWithLock()) {
       instance->callJSFunction(std::move(entry.ModuleName), std::move(entry.MethodName), std::move(entry.Args));
     }
   }
@@ -759,7 +1406,12 @@ void ReactInstanceWin::CallJsFunction(
   }
 
   if (shouldCall) {
-    if (auto instance = m_instance.LoadWithLock()) {
+#ifdef USE_FABRIC
+    if (m_bridgelessReactInstance) {
+      m_bridgelessReactInstance->callFunctionOnModule(moduleName, method, std::move(params));
+    } else
+#endif
+        if (auto instance = m_instance.LoadWithLock()) {
       instance->callJSFunction(std::move(moduleName), std::move(method), std::move(params));
     }
   }
@@ -770,20 +1422,33 @@ void ReactInstanceWin::DispatchEvent(int64_t viewTag, std::string &&eventName, f
   CallJsFunction("RCTEventEmitter", "receiveEvent", std::move(params));
 }
 
-facebook::react::INativeUIManager *ReactInstanceWin::NativeUIManager() noexcept {
-  return m_uiManager.LoadWithLock()->getNativeUIManager();
-}
+winrt::Microsoft::ReactNative::JsiRuntime ReactInstanceWin::JsiRuntime() noexcept {
+  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> jsiRuntimeHolder;
+  {
+    std::scoped_lock lock{m_mutex};
+    if (m_jsiRuntime) {
+      return m_jsiRuntime;
+    } else {
+      jsiRuntimeHolder = m_jsiRuntimeHolder;
+    }
+  }
 
-std::shared_ptr<facebook::react::Instance> ReactInstanceWin::GetInnerInstance() noexcept {
-  return m_instance.LoadWithLock();
-}
+  auto jsiRuntime = jsiRuntimeHolder ? jsiRuntimeHolder->getRuntime() : nullptr;
 
-std::string ReactInstanceWin::GetBundleRootPath() noexcept {
-  return m_bundleRootPath.empty() ? m_options.BundleRootPath : m_bundleRootPath;
+  {
+    std::scoped_lock lock{m_mutex};
+    if (!m_jsiRuntime && jsiRuntime) {
+      // Set only if other thread did not do it yet.
+      m_jsiRuntime =
+          winrt::Microsoft::ReactNative::implementation::JsiRuntime::GetOrCreate(jsiRuntimeHolder, jsiRuntime);
+    }
+
+    return m_jsiRuntime;
+  }
 }
 
-std::shared_ptr<react::uwp::IReactInstance> ReactInstanceWin::UwpReactInstance() noexcept {
-  return m_legacyInstance;
+std::shared_ptr<facebook::react::Instance> ReactInstanceWin::GetInnerInstance() noexcept {
+  return m_instance.LoadWithLock();
 }
 
 bool ReactInstanceWin::IsLoaded() const noexcept {
@@ -792,16 +1457,55 @@ bool ReactInstanceWin::IsLoaded() const noexcept {
 
 void ReactInstanceWin::AttachMeasuredRootView(
     facebook::react::IReactRootView *rootView,
-    folly::dynamic &&initialProps) noexcept {
-  if (auto instanceWrapper = m_instanceWrapper.LoadWithLock()) {
-    instanceWrapper->AttachMeasuredRootView(rootView, std::move(initialProps));
+    const winrt::Microsoft::ReactNative::JSValueArgWriter &initialProps,
+    bool useFabric) noexcept {
+  if (State() == ReactInstanceState::HasError)
+    return;
+
+  assert(!useFabric);
+#ifndef CORE_ABI
+  if (!useFabric || m_useWebDebugger) {
+    int64_t rootTag = -1;
+
+#if !defined(CORE_ABI) && !defined(USE_FABRIC)
+    if (auto uiManager = Microsoft::ReactNative::GetNativeUIManager(*m_reactContext).lock()) {
+      rootTag = uiManager->AddMeasuredRootView(rootView);
+      rootView->SetTag(rootTag);
+    } else {
+      assert(false);
+    }
+#endif
+
+    std::string jsMainModuleName = rootView->JSComponentName();
+    folly::dynamic params = folly::dynamic::array(
+        std::move(jsMainModuleName),
+        folly::dynamic::object("initialProps", DynamicWriter::ToDynamic(initialProps))("rootTag", rootTag)(
+            "fabric", false));
+    CallJsFunction("AppRegistry", "runApplication", std::move(params));
   }
+#endif
 }
 
-void ReactInstanceWin::DetachRootView(facebook::react::IReactRootView *rootView) noexcept {
-  if (auto instanceWrapper = m_instanceWrapper.LoadWithLock()) {
-    instanceWrapper->DetachRootView(rootView);
+void ReactInstanceWin::DetachRootView(facebook::react::IReactRootView *rootView, bool useFabric) noexcept {
+  if (State() == ReactInstanceState::HasError)
+    return;
+
+  auto rootTag = rootView->GetTag();
+  folly::dynamic params = folly::dynamic::array(rootTag);
+
+#ifdef USE_FABRIC
+  if (useFabric && !m_useWebDebugger) {
+    auto uiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
+        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()));
+    uiManager->stopSurface(static_cast<facebook::react::SurfaceId>(rootTag));
+  } else
+#endif
+  {
+    CallJsFunction("AppRegistry", "unmountApplicationComponentAtRootTag", std::move(params));
   }
+
+  // Give the JS thread time to finish executing
+  m_jsMessageThread.Load()->runOnQueueSync([]() {});
 }
 
 Mso::CntPtr<IReactInstanceInternal> MakeReactInstance(
@@ -814,12 +1518,71 @@ Mso::CntPtr<IReactInstanceInternal> MakeReactInstance(
       reactHost, std::move(options), std::move(whenCreated), std::move(whenLoaded), std::move(updateUI));
 }
 
-#if defined(USE_V8)
-std::string ReactInstanceWin::getApplicationLocalFolder() {
-  auto local = winrt::Windows::Storage::ApplicationData::Current().LocalFolder().Path();
+bool ReactInstanceWin::UseWebDebugger() const noexcept {
+  return m_useWebDebugger;
+}
 
-  return Microsoft::Common::Unicode::Utf16ToUtf8(local.c_str(), local.size()) + "\\";
+bool ReactInstanceWin::UseFastRefresh() const noexcept {
+  return m_isFastReloadEnabled;
+}
+
+bool ReactInstanceWin::UseDirectDebugger() const noexcept {
+  return m_useDirectDebugger;
+}
+
+bool ReactInstanceWin::DebuggerBreakOnNextLine() const noexcept {
+  return m_debuggerBreakOnNextLine;
+}
+
+uint16_t ReactInstanceWin::DebuggerPort() const noexcept {
+  return m_options.DeveloperSettings.DebuggerPort;
+}
+
+std::string ReactInstanceWin::DebugBundlePath() const noexcept {
+  return m_options.DeveloperSettings.SourceBundleName.empty() ? m_options.Identity
+                                                              : m_options.DeveloperSettings.SourceBundleName;
+}
+
+std::string ReactInstanceWin::BundleRootPath() const noexcept {
+  return m_options.BundleRootPath.empty() ? "ms-appx:///Bundle/" : m_options.BundleRootPath;
+}
+
+std::string ReactInstanceWin::SourceBundleHost() const noexcept {
+  return m_options.DeveloperSettings.SourceBundleHost.empty() ? facebook::react::DevServerHelper::DefaultPackagerHost
+                                                              : m_options.DeveloperSettings.SourceBundleHost;
+}
+
+uint16_t ReactInstanceWin::SourceBundlePort() const noexcept {
+  return m_options.DeveloperSettings.SourceBundlePort ? m_options.DeveloperSettings.SourceBundlePort
+                                                      : facebook::react::DevServerHelper::DefaultPackagerPort;
+}
+
+bool ReactInstanceWin::RequestInlineSourceMap() const noexcept {
+  return m_options.DeveloperSettings.RequestInlineSourceMap;
+}
+
+JSIEngine ReactInstanceWin::JsiEngine() const noexcept {
+  return m_options.JsiEngine();
+}
+
+std::string ReactInstanceWin::JavaScriptBundleFile() const noexcept {
+  return m_options.Identity;
+}
+
+std::string ReactInstanceWin::BundleAppId() const noexcept {
+  return m_options.DeveloperSettings.BundleAppId;
+}
+
+bool ReactInstanceWin::RequestDevBundle() const noexcept {
+  return m_options.DeveloperSettings.DevBundle;
+}
+
+bool ReactInstanceWin::UseDeveloperSupport() const noexcept {
+  return m_options.UseDeveloperSupport();
+}
+
+Mso::React::IReactContext &ReactInstanceWin::GetReactContext() const noexcept {
+  return *m_reactContext;
 }
-#endif
 
 } // namespace Mso::React