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

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/CompositionAccessibilityProps.h

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+#include <optional>
+#include <unordered_map>
+
+namespace facebook::react {
+struct AccessibilityAnnotation {
+  std::string typeID{};
+  std::string typeName{};
+  std::string author{};
+  std::string dateTime{};
+  std::string target{};
+};
+
+constexpr bool operator==(const AccessibilityAnnotation &lhs, const AccessibilityAnnotation &rhs) {
+  return lhs.typeID == rhs.typeID && lhs.typeName == rhs.typeName && lhs.author == rhs.author &&
+      lhs.dateTime == rhs.dateTime && lhs.target == rhs.target;
+}
+
+constexpr bool operator!=(const AccessibilityAnnotation &lhs, const AccessibilityAnnotation &rhs) {
+  return !(rhs == lhs);
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, AccessibilityAnnotation &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto typeID = map.find("typeID");
+  if (typeID != map.end()) {
+    if (typeID->second.hasType<std::string>()) {
+      result.typeID = (std::string)typeID->second;
+    }
+  }
+
+  auto typeName = map.find("typeName");
+  if (typeName != map.end()) {
+    if (typeName->second.hasType<std::string>()) {
+      result.typeName = (std::string)typeName->second;
+    }
+  }
+
+  auto author = map.find("author");
+  if (author != map.end()) {
+    if (author->second.hasType<std::string>()) {
+      result.author = (std::string)author->second;
+    }
+  }
+
+  auto dateTime = map.find("dateTime");
+  if (dateTime != map.end()) {
+    if (dateTime->second.hasType<std::string>()) {
+      result.dateTime = (std::string)dateTime->second;
+    }
+  }
+
+  auto target = map.find("target");
+  if (target != map.end()) {
+    if (target->second.hasType<std::string>()) {
+      result.target = (std::string)target->second;
+    }
+  }
+}
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -20,6 +20,10 @@ HostPlatformViewProps::HostPlatformViewProps(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.windowsEvents
               : convertRawProp(context, rawProps, sourceProps.windowsEvents, {})),
+      accessibilityAnnotation(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.accessibilityAnnotation
+              : convertRawProp(context, rawProps, "accessibilityAnnotation", sourceProps.accessibilityAnnotation, {})),
       enableFocusRing(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.enableFocusRing
@@ -85,6 +89,7 @@ void HostPlatformViewProps::setProp(
     WINDOWS_VIEW_EVENT_CASE(MouseEnter);
     WINDOWS_VIEW_EVENT_CASE(MouseLeave);
     RAW_SET_PROP_SWITCH_CASE_BASIC(enableFocusRing);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityAnnotation);
     RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityPosInSet);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilitySetSize);

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -5,6 +5,7 @@
 
 #include <react/renderer/components/view/BaseViewProps.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include "CompositionAccessibilityProps.h"
 #include "KeyEvent.h"
 #include "WindowsViewEvents.h"
 
@@ -28,6 +29,7 @@ class HostPlatformViewProps : public BaseViewProps {
   int accessibilitySetSize{0};
   std::string accessibilityLiveRegion{"none"};
   int accessibilityLevel{0};
+  std::optional<AccessibilityAnnotation> accessibilityAnnotation{};
 
   // std::optional<std::string> overflowAnchor{};
   std::optional<std::string> tooltip{};

package/Microsoft.ReactNative/JsiApi.cpp

@@ -553,6 +553,14 @@ bool JsiRuntime::DrainMicrotasks(int32_t maxMicrotasksHint) try {
   throw;
 }
 
+void JsiRuntime::QueueMicrotask(JsiObjectRef callback) try {
+  auto funcPtr = RuntimeAccessor::AsPointerValue(callback);
+  auto const &jsiFunc = RuntimeAccessor::AsFunction(&funcPtr);
+  m_runtimeAccessor->queueMicrotask(jsiFunc);
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
 JsiObjectRef JsiRuntime::Global() try {
   return PointerAccessor::MakeJsiObjectData(m_runtimeAccessor->global());
 } catch (JSI_SET_ERROR) {

package/Microsoft.ReactNative/JsiApi.h

@@ -77,6 +77,7 @@ struct JsiRuntime : JsiRuntimeT<JsiRuntime> {
   ReactNative::JsiPreparedJavaScript PrepareJavaScript(IJsiByteBuffer const &buffer, hstring const &sourceUrl);
   JsiValueRef EvaluatePreparedJavaScript(ReactNative::JsiPreparedJavaScript const &js);
   bool DrainMicrotasks(int32_t maxMicrotasksHint);
+  void QueueMicrotask(JsiObjectRef callback);
   JsiObjectRef Global();
   hstring Description();
   bool IsInspectable();

package/Microsoft.ReactNative/JsiApi.idl

@@ -249,6 +249,7 @@ namespace Microsoft.ReactNative
     JsiPreparedJavaScript PrepareJavaScript(IJsiByteBuffer buffer, String sourceUrl);
     JsiValueRef EvaluatePreparedJavaScript(JsiPreparedJavaScript js);
     Boolean DrainMicrotasks(Int32 maxMicrotasksHint);
+    void QueueMicrotask(JsiObjectRef callback);
     JsiObjectRef Global { get; };
     String Description { get; };
     Boolean IsInspectable { get; };

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj

@@ -201,7 +201,7 @@
     <ClInclude Include="DynamicWriter.h">
       <DependentUpon>IJSValueWriter.idl</DependentUpon>
     </ClInclude>
-    <ClInclude Include="JSDispatcherWriter.h">
+    <ClInclude Include="CallInvokerWriter.h">
       <DependentUpon>IJSValueWriter.idl</DependentUpon>
     </ClInclude>
     <ClInclude Include="HResult.h" />

package/Microsoft.ReactNative/QuirkSettings.cpp

@@ -77,22 +77,6 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> UseRuntimeSchedulerProperty
   return propId;
 }
 
-winrt::Microsoft::ReactNative::ReactPropertyId<bool> IsBridgelessProperty() noexcept {
-  winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{L"ReactNative", L"IsBridgeless"};
-
-  return propId;
-}
-
-/*static*/ bool QuirkSettings::GetIsBridgeless(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept {
-  return properties.Get(IsBridgelessProperty()).value_or(false);
-}
-
-/*static*/ void QuirkSettings::SetIsBridgeless(
-    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
-    bool value) noexcept {
-  properties.Set(IsBridgelessProperty(), value);
-}
-
 #pragma region IDL interface
 
 /*static*/ void QuirkSettings::SetMatchAndroidAndIOSStretchBehavior(

package/Microsoft.ReactNative/QuirkSettings.h

@@ -39,9 +39,6 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static bool GetMapWindowDeactivatedToAppStateInactive(
       winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
-  static bool GetIsBridgeless(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
-  static void SetIsBridgeless(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties, bool value) noexcept;
-
 #pragma region Public API - part of IDL interface
   static void SetMatchAndroidAndIOSStretchBehavior(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,

package/Microsoft.ReactNative/ReactHost/ReactHost.cpp

@@ -6,6 +6,8 @@
 #include <ReactPropertyBag.h>
 #include <winrt/Windows.Foundation.h>
 
+#include <CppRuntimeOptions.h>
+
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 
@@ -283,7 +285,15 @@ bool ReactOptions::EnableDefaultCrashHandler() const noexcept {
 class ReactNativeWindowsFeatureFlags : public facebook::react::ReactNativeFeatureFlagsDefaults {
  public:
   bool disableEventLoopOnBridgeless() override {
-    return true; // Disable event loop until we are on a JSI version that supports microtasks
+    return Microsoft::React::GetRuntimeOptionBool("ReactFeatureFlag.enableEventLoopOnBridgeless");
+  }
+
+  bool enableBridgelessArchitecture() override {
+#ifdef USE_FABRIC
+    return true;
+#else
+    return false;
+#endif
   }
 
   bool enableCppPropsIteratorSetter() override {

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -350,12 +350,10 @@ void ReactInstanceWin::LoadModules(
 #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>());
-  }
+  registerTurboModule(
+      L"UIManager",
+      // TODO: Use MakeTurboModuleProvider after it satisfies ReactNativeSpecs::UIManagerSpec
+      winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::UIManager>());
 #endif
 
 #ifndef CORE_ABI
@@ -489,7 +487,7 @@ void ReactInstanceWin::LoadModules(
 //! Initialize() is called from the native queue.
 void ReactInstanceWin::Initialize() noexcept {
 #ifdef USE_FABRIC
-  if (IsBridgeless()) {
+  if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
     InitializeBridgeless();
   } else
 #endif
@@ -649,9 +647,9 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
                 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)));
+                jsDispatchQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
+
+            m_jsDispatchQueue.Exchange(std::move(jsDispatchQueue));
 
             m_jsMessageThread.Load()->runOnQueueSync([&]() {
               SetJSThreadDescription();
@@ -688,54 +686,62 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
                   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();
+            facebook::react::ReactInstance::JSRuntimeFlags options;
+            m_bridgelessReactInstance->initializeRuntime(
+                options,
+                [=, onCreated = m_options.OnInstanceCreated, reactContext = m_reactContext](
+                    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);
+                  }
+
+                  if (onCreated) {
+                    onCreated.Get()->Invoke(reactContext);
+                  }
+                });
 
             LoadJSBundlesBridgeless(devSettings);
             SetupHMRClient();
@@ -1081,6 +1087,7 @@ Mso::Future<void> ReactInstanceWin::Destroy() noexcept {
 
 #ifdef USE_FABRIC
   if (m_bridgelessReactInstance) {
+    auto jsDispatchQueue = m_jsDispatchQueue.Exchange(nullptr);
     if (auto jsMessageThread = m_jsMessageThread.Exchange(nullptr)) {
       jsMessageThread->runOnQueueSync([&]() noexcept {
         {
@@ -1092,9 +1099,12 @@ Mso::Future<void> ReactInstanceWin::Destroy() noexcept {
         }
         this->m_bridgelessReactInstance = nullptr;
         jsMessageThread->quitSynchronous();
+        if (jsDispatchQueue) {
+          jsDispatchQueue.Shutdown(PendingTaskAction::Complete);
+        }
+        m_whenDestroyed.SetValue();
       });
     }
-    m_jsDispatchQueue.Exchange(nullptr);
   }
 #endif
 
@@ -1161,11 +1171,6 @@ void ReactInstanceWin::InitUIMessageThread() noexcept {
       });
 }
 
-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<Microsoft::ReactNative::IViewManager>> viewManagers;

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -136,7 +136,6 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   std::shared_ptr<Mso::React::IRedBoxHandler> GetRedBoxHandler() noexcept;
   std::function<void()> GetWaitingForDebuggerCallback() noexcept;
   std::function<void()> GetDebuggerAttachCallback() noexcept;
-  bool IsBridgeless() noexcept;
 
   void OnError(const Mso::ErrorCode &errorcode) noexcept;
   void OnErrorWithMessage(const std::string &errorMessage) noexcept;

package/Microsoft.ReactNative/TurboModulesProvider.cpp

@@ -9,7 +9,7 @@
 #include "TurboModulesProvider.h"
 #include <ReactCommon/TurboModuleUtils.h>
 #include <react/bridging/EventEmitter.h>
-#include "JSDispatcherWriter.h"
+#include "CallInvokerWriter.h"
 #include "JSValueWriter.h"
 #include "JsiApi.h"
 #include "JsiReader.h"
@@ -202,7 +202,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                 runtime,
                 propName,
                 0,
-                [jsDispatcher = m_reactContext.JSDispatcher(),
+                [jsInvoker = jsInvoker_,
                  method = methodInfo.Method,
                  longLivedObjectCollection = m_longLivedObjectCollection](
                     facebook::jsi::Runtime &rt,
@@ -214,7 +214,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                     auto jsiRuntimeHolder = LongLivedJsiRuntime::CreateWeak(strongLongLivedObjectCollection, rt);
                     method(
                         winrt::make<JsiReader>(rt, args, argCount - 1),
-                        winrt::make<JSDispatcherWriter>(jsDispatcher, jsiRuntimeHolder),
+                        winrt::make<CallInvokerWriter>(jsInvoker, jsiRuntimeHolder),
                         MakeCallback(rt, strongLongLivedObjectCollection, args[argCount - 1]),
                         nullptr);
                   }
@@ -225,7 +225,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                 runtime,
                 propName,
                 0,
-                [jsDispatcher = m_reactContext.JSDispatcher(),
+                [jsInvoker = jsInvoker_,
                  method = methodInfo.Method,
                  longLivedObjectCollection = m_longLivedObjectCollection](
                     facebook::jsi::Runtime &rt,
@@ -242,9 +242,9 @@ class TurboModuleImpl : public facebook::react::TurboModule {
 
                     method(
                         winrt::make<JsiReader>(rt, args, argCount - 2),
-                        winrt::make<JSDispatcherWriter>(jsDispatcher, jsiRuntimeHolder),
+                        winrt::make<CallInvokerWriter>(jsInvoker, jsiRuntimeHolder),
                         [weakCallback1, weakCallback2, jsiRuntimeHolder](const IJSValueWriter &writer) noexcept {
-                          writer.as<JSDispatcherWriter>()->WithResultArgs(
+                          writer.as<CallInvokerWriter>()->WithResultArgs(
                               [weakCallback1, weakCallback2, jsiRuntimeHolder](
                                   facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t count) {
                                 if (auto callback1 = weakCallback1.lock()) {
@@ -260,7 +260,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                               });
                         },
                         [weakCallback1, weakCallback2, jsiRuntimeHolder](const IJSValueWriter &writer) noexcept {
-                          writer.as<JSDispatcherWriter>()->WithResultArgs(
+                          writer.as<CallInvokerWriter>()->WithResultArgs(
                               [weakCallback1, weakCallback2, jsiRuntimeHolder](
                                   facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t count) {
                                 if (auto callback2 = weakCallback2.lock()) {
@@ -283,7 +283,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                 runtime,
                 propName,
                 0,
-                [jsDispatcher = m_reactContext.JSDispatcher(),
+                [jsInvoker = jsInvoker_,
                  method = methodInfo.Method,
                  longLivedObjectCollection = m_longLivedObjectCollection](
                     facebook::jsi::Runtime &rt,
@@ -293,7 +293,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                   if (auto strongLongLivedObjectCollection = longLivedObjectCollection.lock()) {
                     auto jsiRuntimeHolder = LongLivedJsiRuntime::CreateWeak(strongLongLivedObjectCollection, rt);
                     auto argReader = winrt::make<JsiReader>(rt, args, count);
-                    auto argWriter = winrt::make<JSDispatcherWriter>(jsDispatcher, jsiRuntimeHolder);
+                    auto argWriter = winrt::make<CallInvokerWriter>(jsInvoker, jsiRuntimeHolder);
                     return facebook::react::createPromiseAsJSIValue(
                         rt,
                         [method, argReader, argWriter, strongLongLivedObjectCollection, jsiRuntimeHolder](
@@ -306,7 +306,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                               argReader,
                               argWriter,
                               [weakResolve, weakReject, jsiRuntimeHolder](const IJSValueWriter &writer) {
-                                writer.as<JSDispatcherWriter>()->WithResultArgs(
+                                writer.as<CallInvokerWriter>()->WithResultArgs(
                                     [weakResolve, weakReject, jsiRuntimeHolder](
                                         facebook::jsi::Runtime &runtime,
                                         facebook::jsi::Value const *args,
@@ -325,7 +325,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
                                     });
                               },
                               [weakResolve, weakReject, jsiRuntimeHolder](const IJSValueWriter &writer) {
-                                writer.as<JSDispatcherWriter>()->WithResultArgs(
+                                writer.as<CallInvokerWriter>()->WithResultArgs(
                                     [weakResolve, weakReject, jsiRuntimeHolder](
                                         facebook::jsi::Runtime &runtime,
                                         facebook::jsi::Value const *args,
@@ -438,7 +438,7 @@ class TurboModuleImpl : public facebook::react::TurboModule {
     auto weakCallback =
         LongLivedJsiFunction::CreateWeak(longLivedObjectCollection, rt, callback.getObject(rt).getFunction(rt));
     return [weakCallback = std::move(weakCallback)](const IJSValueWriter &writer) noexcept {
-      writer.as<JSDispatcherWriter>()->WithResultArgs(
+      writer.as<CallInvokerWriter>()->WithResultArgs(
           [weakCallback](facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t count) {
             if (auto callback = weakCallback.lock()) {
               callback->Value().call(rt, args, count);

package/Microsoft.ReactNative/Utils/LocalBundleReader.cpp

@@ -54,38 +54,44 @@ std::string GetBundleFromEmbeddedResource(const winrt::Windows::Foundation::Uri
 }
 
 std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::wstring bundleUri) {
-  co_await winrt::resume_background();
-
-  winrt::Windows::Storage::StorageFile file{nullptr};
-
-  // Supports "ms-appx://" or "ms-appdata://"
-  if (bundleUri.starts_with(L"ms-app")) {
-    winrt::Windows::Foundation::Uri uri(bundleUri);
-    file = co_await winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
-  } else if (bundleUri.starts_with(L"resource://")) {
-    winrt::Windows::Foundation::Uri uri(bundleUri);
-    co_return GetBundleFromEmbeddedResource(uri);
-  } else {
-    file = co_await winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(bundleUri);
+  try {
+    co_await winrt::resume_background();
+
+    winrt::Windows::Storage::StorageFile file{nullptr};
+
+    // Supports "ms-appx://" or "ms-appdata://"
+    if (bundleUri.starts_with(L"ms-app")) {
+      winrt::Windows::Foundation::Uri uri(bundleUri);
+      file = co_await winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
+    } else if (bundleUri.starts_with(L"resource://")) {
+      winrt::Windows::Foundation::Uri uri(bundleUri);
+      co_return GetBundleFromEmbeddedResource(uri);
+    } else {
+      file = co_await winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(bundleUri);
+    }
+
+    // Read the buffer manually to avoid a Utf8 -> Utf16 -> Utf8 encoding
+    // roundtrip.
+    auto fileBuffer{co_await winrt::Windows::Storage::FileIO::ReadBufferAsync(file)};
+    auto dataReader{winrt::Windows::Storage::Streams::DataReader::FromBuffer(fileBuffer)};
+
+    // No need to use length + 1, STL guarantees that string storage is null-terminated.
+    std::string script(fileBuffer.Length(), '\0');
+
+    // Construct the array_view to slice into the first fileBuffer.Length bytes.
+    // DataReader.ReadBytes will read as many bytes as are present in the
+    // array_view. The backing string has fileBuffer.Length() + 1 bytes, without
+    // an explicit end it will read 1 byte to many and throw.
+    dataReader.ReadBytes(winrt::array_view<uint8_t>{
+        reinterpret_cast<uint8_t *>(&script[0]), reinterpret_cast<uint8_t *>(&script[script.length()])});
+    dataReader.Close();
+
+    co_return script;
+  }
+  // RuntimeScheduler only handles std::exception or jsi::JSError
+  catch (winrt::hresult_error const &e) {
+    throw std::exception(winrt::to_string(e.message()).c_str());
   }
-
-  // Read the buffer manually to avoid a Utf8 -> Utf16 -> Utf8 encoding
-  // roundtrip.
-  auto fileBuffer{co_await winrt::Windows::Storage::FileIO::ReadBufferAsync(file)};
-  auto dataReader{winrt::Windows::Storage::Streams::DataReader::FromBuffer(fileBuffer)};
-
-  // No need to use length + 1, STL guarantees that string storage is null-terminated.
-  std::string script(fileBuffer.Length(), '\0');
-
-  // Construct the array_view to slice into the first fileBuffer.Length bytes.
-  // DataReader.ReadBytes will read as many bytes as are present in the
-  // array_view. The backing string has fileBuffer.Length() + 1 bytes, without
-  // an explicit end it will read 1 byte to many and throw.
-  dataReader.ReadBytes(winrt::array_view<uint8_t>{
-      reinterpret_cast<uint8_t *>(&script[0]), reinterpret_cast<uint8_t *>(&script[script.length()])});
-  dataReader.Close();
-
-  co_return script;
 }
 
 std::string LocalBundleReader::LoadBundle(const std::wstring &bundlePath) {

package/Microsoft.ReactNative.Cxx/ApiLoaders/JSRuntimeApi.cpp

@@ -9,6 +9,7 @@ EXTERN_C_START
 extern napi_status NAPI_CDECL default_jsr_open_napi_env_scope(napi_env env, jsr_napi_env_scope *scope);
 extern napi_status NAPI_CDECL default_jsr_close_napi_env_scope(napi_env env, jsr_napi_env_scope scope);
 extern napi_status NAPI_CDECL default_jsr_get_description(napi_env env, const char **result);
+extern napi_status NAPI_CDECL default_jsr_queue_microtask(napi_env env, napi_value callback);
 extern napi_status NAPI_CDECL default_jsr_drain_microtasks(napi_env env, int32_t max_count_hint, bool *result);
 extern napi_status NAPI_CDECL default_jsr_is_inspectable(napi_env env, bool *result);
 

package/Microsoft.ReactNative.Cxx/ApiLoaders/JSRuntimeApi.inc

@@ -17,6 +17,7 @@
 JSR_FUNC(jsr_collect_garbage)
 JSR_FUNC(jsr_config_enable_gc_api)
 JSR_FUNC(jsr_config_enable_inspector)
+JSR_FUNC(jsr_config_set_explicit_microtasks)
 JSR_FUNC(jsr_config_set_inspector_break_on_start)
 JSR_FUNC(jsr_config_set_inspector_port)
 JSR_FUNC(jsr_config_set_inspector_runtime_name)
@@ -33,6 +34,7 @@ JSR_FUNC(jsr_runtime_get_node_api_env)
 
 // The JS runtime functions needed for JSI.
 JSR_JSI_FUNC(jsr_close_napi_env_scope)
+JSR_JSI_FUNC(jsr_queue_microtask)
 JSR_JSI_FUNC(jsr_drain_microtasks)
 JSR_JSI_FUNC(jsr_get_description)
 JSR_JSI_FUNC(jsr_is_inspectable)

package/Microsoft.ReactNative.Cxx/ApiLoaders/NodeApi_posix.cpp

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-#include "LibLoader.h"
+#include "NodeApi.h"
 
 namespace Microsoft::NodeApiJsi {