react-native-windows 0.81.27 → 0.81.29

package/Scripts/rnw-dependencies.ps1

@@ -8,7 +8,7 @@ param(
     [string]$Check = [CheckId]::All,
 
     [Parameter(ValueFromRemainingArguments)]
-    [ValidateSet('appDev', 'rnwDev', 'buildLab', 'vs2022', 'clone')]
+    [ValidateSet('appDev', 'rnwDev', 'buildLab', 'vs2026', 'clone')]
     [String[]]$Tags = @('appDev'),
     [switch]$Enterprise = $false
 )
@@ -94,7 +94,6 @@ $vsComponents = @('Microsoft.Component.MSBuild',
     $vcToolsComponent,
     'Microsoft.VisualStudio.ComponentGroup.UWP.Support',
     'Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Core',
-    'Microsoft.VisualStudio.Component.Windows10SDK.19041',
     'Microsoft.VisualStudio.Component.Windows11SDK.22621');
 
 # UWP.VC is not needed to build the projects with msbuild, but the VS IDE requires it.
@@ -113,12 +112,12 @@ $wingetver = "1.7.11261";
 
 # The minimum VS version to check for
 # Note: For install to work, whatever min version you specify here must be met by the current package available on winget.
-$vsver = "17.11.0";
+$vsver = "18.6.1";
 
 # The exact .NET SDK version to check for
-$dotnetver = "8.0";
+$dotnetver = "10.0";
 # Version name of the winget package
-$wingetDotNetVer = "8";
+$wingetDotNetVer = "10";
 
 $v = [System.Environment]::OSVersion.Version;
 if ($env:Agent_BuildDirectory) {
@@ -242,9 +241,9 @@ function InstallVS {
 
         if ($Enterprise) {
             # The CI machines need the enterprise version of VS as that is what is hardcoded in all the scripts
-            WinGetInstall Microsoft.VisualStudio.2022.Enterprise
+            WinGetInstall Microsoft.VisualStudio.Enterprise
         } else {
-            WinGetInstall Microsoft.VisualStudio.2022.Community
+            WinGetInstall Microsoft.VisualStudio.Community
         }
 
         $vsWhere = Get-VSWhere;
@@ -458,8 +457,8 @@ $requirements = @(
     },
     @{
         Id=[CheckId]::VSUWP;
-        Name = "Visual Studio 2022 (>= $vsver) & req. components";
-        Tags = @('appDev', 'vs2022');
+        Name = "Visual Studio 2026 (>= $vsver) & req. components";
+        Tags = @('appDev', 'vs2026');
         Valid = { CheckVS; }
         Install = { InstallVS };
         HasVerboseOutput = $true;
@@ -469,7 +468,7 @@ $requirements = @(
         Name = 'Node.js (LTS, >= 22.0)';
         Tags = @('appDev');
         Valid = { CheckNode; }
-        Install = { WinGetInstall OpenJS.NodeJS.LTS "22.14.0" };
+        Install = { WinGetInstall OpenJS.NodeJS.22  "22.22.0"};
         HasVerboseOutput = $true;
     },
     @{
@@ -491,7 +490,7 @@ $requirements = @(
             $downloadPath = "$env:TEMP\WindowsApplicationDriver.msi"
             Write-Verbose "Downloading WinAppDriver from $url";
             Invoke-WebRequest -UseBasicParsing $url -OutFile $downloadPath
-            
+
             # SDL Compliance: Verify signature (Work Item 58386093)
             $signature = Get-AuthenticodeSignature $downloadPath
             if ($signature.Status -ne "Valid") {
@@ -499,10 +498,10 @@ $requirements = @(
                 throw "WinAppDriver signature verification failed"
             }
             if ($signature.SignerCertificate.Subject -notlike "*Microsoft*") {
-                Remove-Item $downloadPath -ErrorAction SilentlyContinue  
+                Remove-Item $downloadPath -ErrorAction SilentlyContinue
                 throw "WinAppDriver not signed by Microsoft"
             }
-            
+
             & $downloadPath /q
             Remove-Item $downloadPath -ErrorAction SilentlyContinue
         };
@@ -600,6 +599,9 @@ function WinGetInstall {
         Write-Verbose "Executing `winget install `"$wingetPackage`"";
         & winget install "$wingetPackage" --accept-source-agreements --accept-package-agreements
     }
+
+    # Refresh PATH environment variable to pick up newly installed tools
+    $env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
  }
 
 function IsElevated {
@@ -685,6 +687,17 @@ foreach ($req in $filteredRequirements)
                     $LASTEXITCODE = 0;
                     $outputFromInstall = Invoke-Command $req.Install -ErrorAction Stop;
 
+                    # Re-validate after install attempt - winget may return non-zero for "already installed"
+                    $validAfterInstall = $false;
+                    try {
+                        $validAfterInstall = Invoke-Command $req.Valid;
+                    } catch { }
+
+                    if ($validAfterInstall) {
+                        $Installed++;
+                        continue; # go to the next item
+                    }
+
                     if ($LASTEXITCODE -ne 0) {
                         throw "Last exit code was non-zero: $LASTEXITCODE - $outputFromInstall";
                     }
@@ -723,4 +736,4 @@ if ($NeedsRerun -ne 0) {
     $Tags | Out-File $MarkerFile;
     if (!$ShellInvocation) { Read-Host 'Press Enter to exit' }
     exit 0;
-}
+}

package/Shared/DevSettings.h

@@ -116,6 +116,8 @@ struct DevSettings {
   // Enable concurrent mode by installing runtimeScheduler
   bool useRuntimeScheduler{false};
 
+  bool hermesSetExplicitMicrotasks{true};
+
   // The HostTarget instance for Fusebox
   facebook::react::jsinspector_modern::HostTarget *inspectorHostTarget;
 };

package/Shared/DevSupportManager.cpp

@@ -35,7 +35,6 @@
 #include <cxxreact/MessageQueueThread.h>
 #pragma warning(pop)
 
-#include <future>
 #include <mutex>
 
 #include <AppModel.h>
@@ -49,61 +48,59 @@ using namespace facebook::react;
 
 namespace Microsoft::ReactNative {
 
-std::future<std::pair<std::string, bool>> GetJavaScriptFromServerAsync(const std::string &url) {
-  winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter filter;
-  filter.CacheControl().ReadBehavior(winrt::Windows::Web::Http::Filters::HttpCacheReadBehavior::NoCache);
-  winrt::Windows::Web::Http::HttpClient httpClient(filter);
-  winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IBuffer> GetJavaScriptFromServerAsync(
+    const std::string &url) {
+  try {
+    winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter filter;
+    filter.CacheControl().ReadBehavior(winrt::Windows::Web::Http::Filters::HttpCacheReadBehavior::NoCache);
+    winrt::Windows::Web::Http::HttpClient httpClient(filter);
+    winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
 
-  co_await winrt::resume_background();
+    co_await winrt::resume_background();
 
-  winrt::Windows::Web::Http::HttpRequestMessage request(winrt::Windows::Web::Http::HttpMethod::Get(), uri);
-  auto asyncRequest = httpClient.SendRequestAsync(request);
+    winrt::Windows::Web::Http::HttpRequestMessage request(winrt::Windows::Web::Http::HttpMethod::Get(), uri);
+    auto asyncRequest = httpClient.SendRequestAsync(request);
 #ifdef DEFAULT_CPPWINRT_EXCEPTIONS
-  try {
     winrt::Windows::Web::Http::HttpResponseMessage response = co_await asyncRequest;
-  } catch (winrt::hresult_error const &e) {
-    co_return std::make_pair(
-        Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()).c_str(), false);
-  }
 #else
-  co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
-      winrt::Windows::Web::Http::HttpResponseMessage,
-      winrt::Windows::Web::Http::HttpProgress>>{asyncRequest};
-
-  HRESULT hr = asyncRequest.ErrorCode();
-  if (FAILED(hr)) {
-    std::string error;
-    if (hr == WININET_E_CANNOT_CONNECT) {
-      error = fmt::format("A connection with the server {} could not be established.\n\nIs the packager running?", url);
-    } else {
-      error = fmt::format("Error 0x{:x} downloading {}.", static_cast<int>(asyncRequest.ErrorCode()), url);
+    co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
+        winrt::Windows::Web::Http::HttpResponseMessage,
+        winrt::Windows::Web::Http::HttpProgress>>{asyncRequest};
+
+    HRESULT hr = asyncRequest.ErrorCode();
+    if (FAILED(hr)) {
+      std::string error;
+      if (hr == WININET_E_CANNOT_CONNECT) {
+        error =
+            fmt::format("A connection with the server {} could not be established.\n\nIs the packager running?", url);
+      } else {
+        error = fmt::format("Error 0x{:x} downloading {}.", static_cast<int>(asyncRequest.ErrorCode()), url);
+      }
+      throw winrt::hresult_error(E_FAIL, winrt::to_hstring(error));
     }
-    co_return std::make_pair(error, false);
-  }
 
-  winrt::Windows::Web::Http::HttpResponseMessage response = asyncRequest.GetResults();
+    winrt::Windows::Web::Http::HttpResponseMessage response = asyncRequest.GetResults();
 #endif
 
-  winrt::Windows::Storage::Streams::IBuffer buffer = co_await response.Content().ReadAsBufferAsync();
-  auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
-
-  reader.UnicodeEncoding(winrt::Windows::Storage::Streams::UnicodeEncoding::Utf8);
-  uint32_t len = reader.UnconsumedBufferLength();
-  std::string result;
-  if (len > 0 || response.IsSuccessStatusCode()) {
-    std::string data;
-    data.resize(len);
-    auto buf = reinterpret_cast<uint8_t *>(data.data());
-    static_assert(
-        sizeof(buf[0]) == sizeof(data[0]), "perf optimization relies on uint8_t and char being the same size");
-    reader.ReadBytes(winrt::array_view(buf, buf + len));
-    result = std::move(data);
-  } else {
-    result = fmt::format("HTTP Error {} downloading {}.", static_cast<int>(response.StatusCode()), url);
-  }
+    winrt::Windows::Storage::Streams::IBuffer buffer = co_await response.Content().ReadAsBufferAsync();
+
+    if (!response.IsSuccessStatusCode()) {
+      std::string error;
+      if (buffer.Length() > 0) {
+        auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
+        error.resize(buffer.Length());
+        auto buf = reinterpret_cast<uint8_t *>(error.data());
+        reader.ReadBytes(winrt::array_view(buf, buf + buffer.Length()));
+      } else {
+        error = fmt::format("HTTP Error {} downloading {}.", static_cast<int>(response.StatusCode()), url);
+      }
+      throw winrt::hresult_error(E_FAIL, winrt::to_hstring(error));
+    }
 
-  co_return std::make_pair(std::move(result), response.IsSuccessStatusCode());
+    co_return buffer;
+  } catch (winrt::hresult_error const &) {
+    throw;
+  }
 }
 
 void LaunchDevTools(const facebook::react::DevSettings &settings) {
@@ -219,7 +216,8 @@ std::string GetPackageName(const std::string &bundleAppId) {
   return packageName;
 }
 
-std::future<winrt::Windows::Web::Http::HttpStatusCode> PollForLiveReload(const std::string &url) {
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Web::Http::HttpStatusCode> PollForLiveReload(
+    const std::string &url) {
   winrt::Windows::Web::Http::HttpClient httpClient;
   winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
   httpClient.DefaultRequestHeaders().Connection().TryParseAdd(L"keep-alive");
@@ -349,7 +347,16 @@ std::pair<std::string, bool> GetJavaScriptFromServer(
       inlineSourceMap,
       hermesBytecodeVersion);
   try {
-    return GetJavaScriptFromServerAsync(bundleUrl).get();
+    auto buffer = GetJavaScriptFromServerAsync(bundleUrl).get();
+    std::string result(buffer.Length(), '\0');
+    if (!result.empty()) {
+      auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
+      reader.ReadBytes(winrt::array_view<uint8_t>{
+          reinterpret_cast<uint8_t *>(&result[0]), reinterpret_cast<uint8_t *>(&result[result.length()])});
+    }
+    return std::make_pair(std::move(result), true);
+  } catch (std::exception const &e) {
+    return std::make_pair(std::string{"Error: "} + e.what(), false);
   } catch (winrt::hresult_error const &e) {
     return std::make_pair(
         "Error: " + Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()), false);

package/Shared/DevSupportManager.h

@@ -10,7 +10,6 @@
 #include <winrt/Windows.Networking.Sockets.h>
 #include <atomic>
 #include <functional>
-#include <future>
 #include <memory>
 #include <string>
 

package/Shared/Hermes/HermesSamplingProfiler.cpp

@@ -32,10 +32,8 @@ auto resume_in_dispatcher(const IReactDispatcher &dispatcher) noexcept {
 
     void await_resume() const noexcept {}
 
-    void await_suspend(std::experimental::coroutine_handle<> resume) noexcept {
-      callback_ = [context = resume.address()]() noexcept {
-        std::experimental::coroutine_handle<>::from_address(context)();
-      };
+    void await_suspend(std::coroutine_handle<> resume) noexcept {
+      callback_ = [context = resume.address()]() noexcept { std::coroutine_handle<>::from_address(context)(); };
       dispatcher_.Post(std::move(callback_));
     }
 

package/Shared/HermesRuntimeHolder.cpp

@@ -271,8 +271,7 @@ void HermesRuntimeHolder::initRuntime() noexcept {
   CRASH_ON_ERROR(api.jsr_create_config(&config));
   CRASH_ON_ERROR(api.hermes_config_enable_default_crash_handler(config, devSettings->enableDefaultCrashHandler));
   CRASH_ON_ERROR(api.jsr_config_enable_inspector(config, devSettings->useDirectDebugger));
-  CRASH_ON_ERROR(api.jsr_config_set_explicit_microtasks(
-      config, facebook::react::ReactNativeFeatureFlags::enableBridgelessArchitecture()));
+  CRASH_ON_ERROR(api.jsr_config_set_explicit_microtasks(config, devSettings->hermesSetExplicitMicrotasks));
 
   if (m_jsQueue) {
     HermesTaskRunner::Create(config, m_jsQueue);

package/Shared/Modules/IWebSocketModuleContentHandler.h

@@ -18,11 +18,26 @@ namespace Microsoft::React {
 struct IWebSocketModuleContentHandler {
   virtual ~IWebSocketModuleContentHandler() noexcept {}
 
+  /// Returns true if this handler should process messages for the given socket.
+  virtual bool CanHandleSocket(int64_t socketId) noexcept = 0;
+
   virtual void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
 
   virtual void ProcessMessage(
       std::vector<uint8_t> &&message,
       winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
+
+  /// Check CanHandleSocket() then ProcessMessage() in one call.
+  /// Returns true if the message was handled.
+  virtual bool TryProcessMessage(
+      int64_t socketId,
+      std::string &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
+
+  virtual bool TryProcessMessage(
+      int64_t socketId,
+      std::vector<uint8_t> &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.cpp

@@ -84,6 +84,7 @@ shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id,
     if (auto prop = propBag.Get(BlobModuleContentHandlerPropertyId()))
       contentHandler = prop.Value().lock();
 
+    bool handled = false;
     if (contentHandler) {
       if (isBinary) {
         auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
@@ -91,11 +92,15 @@ shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id,
         CryptographicBuffer::CopyToByteArray(buffer, arr);
         auto data = vector<uint8_t>(arr.begin(), arr.end());
 
-        contentHandler->ProcessMessage(std::move(data), args);
+        handled = contentHandler->TryProcessMessage(id, std::move(data), args);
       } else {
-        contentHandler->ProcessMessage(string{message}, args);
+        handled = contentHandler->TryProcessMessage(id, string{message}, args);
       }
-    } else {
+    }
+    // When the content handler processes the message, it takes ownership of the
+    // payload and populates args itself (e.g. as a blob reference), so we only
+    // fall back to setting args["data"] when no handler claimed the message.
+    if (!handled) {
       args["data"] = message;
     }
 

package/Shared/Networking/DefaultBlobResource.cpp

@@ -221,6 +221,11 @@ BlobWebSocketModuleContentHandler::BlobWebSocketModuleContentHandler(shared_ptr<
 
 #pragma region IWebSocketModuleContentHandler
 
+bool BlobWebSocketModuleContentHandler::CanHandleSocket(int64_t socketId) noexcept /*override*/ {
+  scoped_lock lock{m_mutex};
+  return m_socketIds.find(socketId) != m_socketIds.end();
+}
+
 void BlobWebSocketModuleContentHandler::ProcessMessage(
     string &&message,
     msrn::JSValueObject &params) noexcept /*override*/
@@ -241,6 +246,38 @@ void BlobWebSocketModuleContentHandler::ProcessMessage(
   params[blobKeys.Type] = blobKeys.Blob;
 }
 
+bool BlobWebSocketModuleContentHandler::TryProcessMessage(
+    int64_t socketId,
+    string &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  scoped_lock lock{m_mutex};
+  if (m_socketIds.find(socketId) == m_socketIds.end())
+    return false;
+
+  params[blobKeys.Data] = std::move(message);
+  return true;
+}
+
+bool BlobWebSocketModuleContentHandler::TryProcessMessage(
+    int64_t socketId,
+    vector<uint8_t> &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  scoped_lock lock{m_mutex};
+  if (m_socketIds.find(socketId) == m_socketIds.end())
+    return false;
+
+  auto blob = msrn::JSValueObject{
+      {blobKeys.Offset, 0},
+      {blobKeys.Size, message.size()},
+      {blobKeys.BlobId, m_blobPersistor->StoreMessage(std::move(message))}};
+
+  params[blobKeys.Data] = std::move(blob);
+  params[blobKeys.Type] = blobKeys.Blob;
+  return true;
+}
+
 #pragma endregion IWebSocketModuleContentHandler
 
 void BlobWebSocketModuleContentHandler::Register(int64_t socketID) noexcept {

package/Shared/Networking/DefaultBlobResource.h

@@ -51,11 +51,23 @@ class BlobWebSocketModuleContentHandler final : public IWebSocketModuleContentHa
 
 #pragma region IWebSocketModuleContentHandler
 
+  bool CanHandleSocket(int64_t socketId) noexcept override;
+
   void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
 
   void ProcessMessage(std::vector<uint8_t> &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept
       override;
 
+  bool TryProcessMessage(
+      int64_t socketId,
+      std::string &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
+
+  bool TryProcessMessage(
+      int64_t socketId,
+      std::vector<uint8_t> &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
+
 #pragma endregion IWebSocketModuleContentHandler
 
   void Register(int64_t socketID) noexcept;

package/Shared/Networking/WinRTWebSocketResource.h

@@ -27,8 +27,12 @@ class WinRTWebSocketResource2 : public IWebSocketResource,
     void operator=(const TaskSequencer &) = delete;
 
    private:
+// `experimental` is deprecated starting Visual Studio 2026
+#if _MSC_VER >= 1951
+    using CoroHandle = std::coroutine_handle<>;
+#else
     using CoroHandle = std::experimental::coroutine_handle<>;
-
+#endif
     struct Suspender {
       CoroHandle m_handle;