react-native-windows 0.81.37 → 0.81.40

package/Microsoft.ReactNative.Cxx/ComponentView.Experimental.interop.h

@@ -3,6 +3,12 @@
 
 #pragma once
 
+// #include <tom.h>
+// #include <textserv.h>
+struct ITextDocument2;
+class ITextServices2;
+class ITextHost;
+
 namespace Microsoft::ReactNative::Composition::Experimental {
 
 // This interface will be removed once we complete internal transitions to ContentIsland, and new APIs for hosting
@@ -11,4 +17,10 @@ struct __declspec(uuid("2A60D68A-57B8-43CA-B1BA-2FAF0FCB344B")) IComponentViewIn
   virtual HWND GetHwndForParenting() noexcept = 0;
 };
 
+struct __declspec(uuid("ABA4F071-1C26-4D56-A608-75361ED21545")) ITextInputComponentInterop : IUnknown {
+  virtual HRESULT GetTextDocument(ITextDocument2 **textDocument) noexcept = 0;
+  virtual HRESULT GetTextServices(ITextServices2 **textServices) noexcept = 0;
+  virtual HRESULT GetTextHost(ITextHost **textHost) noexcept = 0;
+};
+
 } // namespace Microsoft::ReactNative::Composition::Experimental

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.81.37</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.81.40</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>81</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>37</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>40</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>a88d2a30cbd740bfa56b6525a9a29ce15e3bbb9b</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>be0af08d662d3d6a0583d77541b6abab8233aeca</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/PropertySheets/JSEngine.props

@@ -17,7 +17,7 @@
     <EnableDevServerHBCBundles Condition="'$(EnableDevServerHBCBundles)' == ''">false</EnableDevServerHBCBundles>
 
     <UseV8 Condition="'$(UseV8)' == ''">false</UseV8>
-    <V8Version Condition="'$(V8Version)' == ''">0.71.8</V8Version>
+    <V8Version Condition="'$(V8Version)' == ''">0.79.5</V8Version>
     <V8PackageName>ReactNative.V8Jsi.Windows</V8PackageName>
     <V8PackageName Condition="'$(V8AppPlatform)' != 'win32'">$(V8PackageName).UWP</V8PackageName>
     <V8Package>$(NuGetPackageRoot)\$(V8PackageName).$(V8Version)</V8Package>

package/PropertySheets/React.Cpp.props

@@ -139,7 +139,6 @@
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <ShowIncludes Condition="'$(ShowIncludes)'=='true'">true</ShowIncludes>
       <AdditionalOptions>/utf-8 %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalOptions Condition="'$(PlatformToolsetVersion)' != '' And $(PlatformToolsetVersion)&lt;145">%(AdditionalOptions) /await</AdditionalOptions>
       <ControlFlowGuard>Guard</ControlFlowGuard>
       <SpectreMitigation>Spectre</SpectreMitigation>
 

package/PropertySheets/WinUI.props

@@ -4,7 +4,8 @@
 
     <!--
       Internal versions are typically only located at: https://microsoft.visualstudio.com/DefaultCollection/ProjectReunion/_artifacts/feed/Project.Reunion.nuget.internal/NuGet/Microsoft.WindowsAppSDK/versions
-      For local testing of internal versions, modify WinUI3ExperimentalVersion, and comment out the additional nuget source in NuGet.Config
+      For local testing of internal versions, set WinUI3ExperimentalVersion and run
+      vnext\Scripts\EnableInternalWinAppSDKFeed.ps1 to add the internal source and its package mapping.
       When this version is updated, be sure to update the default for the enableInternalFeed parameter of /.ado/templates/enable-experimental-winui3.yml
     -->
     <WinUI3ExperimentalVersion Condition="'$(WinUI3ExperimentalVersion)'==''">1.8.251106002</WinUI3ExperimentalVersion>

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/Instance.cpp

@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "Instance.h"
+
+#ifndef RCT_FIT_RM_OLD_RUNTIME
+
+#include "ErrorUtils.h"
+#include "JSBigString.h"
+#include "JSBundleType.h"
+#include "JSExecutor.h"
+#include "MessageQueueThread.h"
+#include "MethodCall.h"
+#include "NativeToJsBridge.h"
+#include "RAMBundleRegistry.h"
+#include "RecoverableError.h"
+#include "TraceSection.h"
+
+#include <cxxreact/JSIndexedRAMBundle.h>
+#include <folly/json.h>
+#include <react/debug/react_native_assert.h>
+
+#include <glog/logging.h>
+
+#include <condition_variable>
+#include <exception>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace facebook::react {
+
+Instance::~Instance() {
+  if (nativeToJsBridge_) {
+    nativeToJsBridge_->destroy();
+  }
+}
+
+void Instance::unregisterFromInspector() {
+  if (inspectorTarget_) {
+    assert(runtimeInspectorTarget_);
+    inspectorTarget_->unregisterRuntime(*runtimeInspectorTarget_);
+    assert(parentInspectorTarget_);
+    parentInspectorTarget_->unregisterInstance(*inspectorTarget_);
+    parentInspectorTarget_ = nullptr;
+    inspectorTarget_ = nullptr;
+  }
+}
+
+void Instance::initializeBridge(
+    std::unique_ptr<InstanceCallback> callback,
+    std::shared_ptr<JSExecutorFactory> jsef,
+    std::shared_ptr<MessageQueueThread> jsQueue,
+    std::shared_ptr<ModuleRegistry> moduleRegistry,
+    jsinspector_modern::HostTarget* parentInspectorTarget) {
+  callback_ = std::move(callback);
+  moduleRegistry_ = std::move(moduleRegistry);
+  parentInspectorTarget_ = parentInspectorTarget;
+
+  jsQueue->runOnQueueSync([this, &jsef, jsQueue]() mutable {
+    nativeToJsBridge_ = std::make_shared<NativeToJsBridge>(
+        jsef.get(), moduleRegistry_, jsQueue, callback_);
+
+    // If a parent inspector HostTarget is provided, perform inspector
+    // initialization synchronously.
+    if (parentInspectorTarget_ != nullptr) {
+      auto inspectorExecutor = parentInspectorTarget_->executorFromThis();
+      std::mutex inspectorInitializedMutex;
+      std::condition_variable inspectorInitializedCv;
+      bool inspectorInitialized = false;
+
+      // Schedule work on the inspector thread. NOTE: We expect this callback
+      // to always execute, given the invariant that `initializeBridge` (this
+      // method) completes before `unregisterFromInspector` is called.
+      // - On iOS, instance creation and invalidation both run on the main
+      //   queue (`RCTCxxBridge::start,invalidate` use `RCTAssertMainQueue`).
+      // - On Android, `ReactContext` must be initialized with a constructed
+      //   `CatalystInstance` (in which `Instance::initializeBridge` has
+      //   completed) before `destroy` can be called.
+      inspectorExecutor([this,
+                         &inspectorInitialized,
+                         &inspectorInitializedMutex,
+                         &inspectorInitializedCv](
+                            jsinspector_modern::HostTarget& hostTarget) {
+        // NOTE: By passing *this, we strongly assume the Instance will still
+        // be alive by the time this executes.
+        // - On iOS, instance creation is done synchronously
+        //   (`RCTCxxBridge::_initializeBridgeLocked`).
+        // - On Android, we explicitly wait for instance creation before
+        //   destruction (`ReactInstanceManager::mReactContextLock`).
+        inspectorTarget_ = &hostTarget.registerInstance(*this);
+        RuntimeExecutor runtimeExecutorIfJsi = getRuntimeExecutor();
+        runtimeInspectorTarget_ = &inspectorTarget_->registerRuntime(
+            nativeToJsBridge_->getInspectorTargetDelegate(),
+            runtimeExecutorIfJsi ? runtimeExecutorIfJsi : [](auto) {});
+
+        // Signal that initialization is complete
+        {
+          std::lock_guard lock(inspectorInitializedMutex);
+          inspectorInitialized = true;
+        }
+        inspectorInitializedCv.notify_one();
+      });
+
+      // Wait for the initialization work to complete
+      {
+        std::unique_lock lock(inspectorInitializedMutex);
+        inspectorInitializedCv.wait(
+            lock, [&inspectorInitialized] { return inspectorInitialized; });
+      }
+    }
+
+    // Initialize the JavaScript runtime after we've initialized the inspector
+    nativeToJsBridge_->initializeRuntime();
+
+    // After NativeToJsBridge is created, the jsi::Runtime should exist. Also,
+    // the JS message queue thread exists. So, it's safe to schedule all queued
+    // up JS calls.
+    jsCallInvoker_->setNativeToJsBridgeAndFlushCalls(nativeToJsBridge_);
+
+    std::scoped_lock lock(m_syncMutex);
+    m_syncReady = true;
+    m_syncCV.notify_all();
+  });
+
+  CHECK(nativeToJsBridge_);
+}
+
+void Instance::loadBundle(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> string,
+    std::string sourceURL) {
+  callback_->incrementPendingJSCalls();
+  TraceSection s("Instance::loadBundle", "sourceURL", sourceURL);
+  nativeToJsBridge_->loadBundle(
+      std::move(bundleRegistry), std::move(string), std::move(sourceURL));
+}
+
+void Instance::loadBundleSync(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> string,
+    std::string sourceURL) {
+  std::unique_lock<std::mutex> lock(m_syncMutex);
+  m_syncCV.wait(lock, [this] { return m_syncReady; });
+
+  TraceSection s("Instance::loadBundleSync", "sourceURL", sourceURL);
+  nativeToJsBridge_->loadBundleSync(
+      std::move(bundleRegistry), std::move(string), std::move(sourceURL));
+}
+
+void Instance::setSourceURL(std::string sourceURL) {
+  callback_->incrementPendingJSCalls();
+  TraceSection s("Instance::setSourceURL", "sourceURL", sourceURL);
+
+  nativeToJsBridge_->loadBundle(nullptr, nullptr, std::move(sourceURL));
+}
+
+void Instance::loadScriptFromString(
+    std::unique_ptr<const JSBigString> string,
+    std::string sourceURL,
+    bool loadSynchronously) {
+  TraceSection s("Instance::loadScriptFromString", "sourceURL", sourceURL);
+  if (loadSynchronously) {
+    loadBundleSync(nullptr, std::move(string), std::move(sourceURL));
+  } else {
+    loadBundle(nullptr, std::move(string), std::move(sourceURL));
+  }
+}
+
+void Instance::loadRAMBundleFromString(
+    std::unique_ptr<const JSBigString> script,
+    const std::string& sourceURL) {
+  auto bundle = std::make_unique<JSIndexedRAMBundle>(std::move(script));
+  auto startupScript = bundle->getStartupCode();
+  auto registry = RAMBundleRegistry::singleBundleRegistry(std::move(bundle));
+  loadRAMBundle(std::move(registry), std::move(startupScript), sourceURL, true);
+}
+
+void Instance::loadRAMBundleFromFile(
+    const std::string& sourcePath,
+    const std::string& sourceURL,
+    bool loadSynchronously) {
+  auto bundle = std::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
+  auto startupScript = bundle->getStartupCode();
+  auto registry = RAMBundleRegistry::multipleBundlesRegistry(
+      std::move(bundle), JSIndexedRAMBundle::buildFactory());
+  loadRAMBundle(
+      std::move(registry),
+      std::move(startupScript),
+      sourceURL,
+      loadSynchronously);
+}
+
+void Instance::loadRAMBundle(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string startupScriptSourceURL,
+    bool loadSynchronously) {
+  if (loadSynchronously) {
+    loadBundleSync(
+        std::move(bundleRegistry),
+        std::move(startupScript),
+        std::move(startupScriptSourceURL));
+  } else {
+    loadBundle(
+        std::move(bundleRegistry),
+        std::move(startupScript),
+        std::move(startupScriptSourceURL));
+  }
+}
+
+void Instance::setGlobalVariable(
+    std::string propName,
+    std::unique_ptr<const JSBigString> jsonValue) {
+  nativeToJsBridge_->setGlobalVariable(
+      std::move(propName), std::move(jsonValue));
+}
+
+void* Instance::getJavaScriptContext() {
+  return nativeToJsBridge_ ? nativeToJsBridge_->getJavaScriptContext()
+                           : nullptr;
+}
+
+bool Instance::isInspectable() {
+  return nativeToJsBridge_ ? nativeToJsBridge_->isInspectable() : false;
+}
+
+bool Instance::isBatchActive() {
+  return nativeToJsBridge_ ? nativeToJsBridge_->isBatchActive() : false;
+}
+
+void Instance::callJSFunction(
+    std::string&& module,
+    std::string&& method,
+    folly::dynamic&& params) {
+  callback_->incrementPendingJSCalls();
+  nativeToJsBridge_->callFunction(
+      std::move(module), std::move(method), std::move(params));
+}
+
+void Instance::callJSCallback(uint64_t callbackId, folly::dynamic&& params) {
+  TraceSection s("Instance::callJSCallback");
+  callback_->incrementPendingJSCalls();
+  nativeToJsBridge_->invokeCallback((double)callbackId, std::move(params));
+}
+
+void Instance::registerBundle(
+    uint32_t bundleId,
+    const std::string& bundlePath) {
+  nativeToJsBridge_->registerBundle(bundleId, bundlePath);
+}
+
+const ModuleRegistry& Instance::getModuleRegistry() const {
+  return *moduleRegistry_;
+}
+
+ModuleRegistry& Instance::getModuleRegistry() {
+  return *moduleRegistry_;
+}
+
+void Instance::handleMemoryPressure(int pressureLevel) {
+  if (nativeToJsBridge_) {
+    // This class resets `nativeToJsBridge_` only in the destructor,
+    // hence a race is not possible there.
+    nativeToJsBridge_->handleMemoryPressure(pressureLevel);
+  }
+}
+
+std::shared_ptr<CallInvoker> Instance::getJSCallInvoker() {
+  return std::static_pointer_cast<CallInvoker>(jsCallInvoker_);
+}
+
+namespace {
+// [Windows] A task on the JS queue can drop the last reference to the Instance.
+// ~Instance then calls NativeToJsBridge::destroy(), which deletes the executor
+// before the task returns, because runOnQueueSync runs inline on its own queue.
+// Call this on the JS queue before using the executor again.
+bool executorSurvivedTask(
+    const std::weak_ptr<NativeToJsBridge>& weakNativeToJsBridge) {
+  auto nativeToJsBridge = weakNativeToJsBridge.lock();
+  return nativeToJsBridge && nativeToJsBridge->hasExecutor();
+}
+} // namespace
+
+RuntimeExecutor Instance::getRuntimeExecutor() {
+  // HACK: RuntimeExecutor is not compatible with non-JSIExecutor, we return
+  // a null callback, which the caller should handle.
+  if (!getJavaScriptContext()) {
+    return nullptr;
+  }
+
+  std::weak_ptr<NativeToJsBridge> weakNativeToJsBridge = nativeToJsBridge_;
+  return [weakNativeToJsBridge](
+             std::function<void(jsi::Runtime & runtime)>&& callback) {
+    if (auto strongNativeToJsBridge = weakNativeToJsBridge.lock()) {
+      strongNativeToJsBridge->runOnExecutorQueue(
+          [callback = std::move(callback),
+           weakNativeToJsBridge](JSExecutor* executor) {
+            // Assumes the underlying executor is a JSIExecutor
+            jsi::Runtime* runtime =
+                (jsi::Runtime*)executor->getJavaScriptContext();
+            try {
+              react_native_assert(runtime != nullptr);
+              callback(*runtime);
+              if (executorSurvivedTask(weakNativeToJsBridge)) { // [Windows]
+                executor->flush();
+              }
+            } catch (jsi::JSError& originalError) {
+              handleJSError(*runtime, originalError, true);
+            }
+          });
+    }
+  };
+}
+
+std::shared_ptr<NativeMethodCallInvoker>
+Instance::getDecoratedNativeMethodCallInvoker(
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) {
+  return nativeToJsBridge_->getDecoratedNativeMethodCallInvoker(
+      nativeMethodCallInvoker);
+}
+
+void Instance::JSCallInvoker::setNativeToJsBridgeAndFlushCalls(
+    std::weak_ptr<NativeToJsBridge> nativeToJsBridge) {
+  std::scoped_lock guard(m_mutex);
+
+  m_shouldBuffer = false;
+  m_nativeToJsBridge = nativeToJsBridge;
+  while (m_workBuffer.size() > 0) {
+    scheduleAsync(std::move(m_workBuffer.front()));
+    m_workBuffer.pop_front();
+  }
+}
+
+void Instance::JSCallInvoker::invokeSync(CallFunc&& /*work*/) {
+  // TODO: Replace JS Callinvoker with RuntimeExecutor.
+  throw std::runtime_error(
+      "Synchronous native -> JS calls are currently not supported.");
+}
+
+void Instance::JSCallInvoker::invokeAsync(CallFunc&& work) noexcept {
+  std::scoped_lock guard(m_mutex);
+
+  /**
+   * Why is is necessary to queue up async work?
+   *
+   * 1. TurboModuleManager must be created synchronously after the Instance,
+   *    before we load the source code. This is when the NativeModule system
+   *    is initialized. RCTDevLoadingView shows bundle download progress.
+   * 2. TurboModuleManager requires a JS CallInvoker.
+   * 3. The JS CallInvoker requires the NativeToJsBridge, which is created on
+   *    the JS thread in Instance::initializeBridge.
+   *
+   * Therefore, although we don't call invokeAsync before the JS bundle is
+   * executed, this buffering is implemented anyways to ensure that work
+   * isn't discarded.
+   */
+  if (m_shouldBuffer) {
+    m_workBuffer.push_back(std::move(work));
+    return;
+  }
+
+  scheduleAsync(std::move(work));
+}
+
+void Instance::JSCallInvoker::scheduleAsync(CallFunc&& work) noexcept {
+  if (auto strongNativeToJsBridge = m_nativeToJsBridge.lock()) {
+    strongNativeToJsBridge->runOnExecutorQueue(
+        [work = std::move(work),
+         weakNativeToJsBridge = m_nativeToJsBridge](JSExecutor* executor) {
+          auto* runtime = (jsi::Runtime*)executor->getJavaScriptContext();
+          work(*runtime);
+          if (executorSurvivedTask(weakNativeToJsBridge)) { // [Windows]
+            executor->flush();
+          }
+        });
+  }
+}
+
+} // namespace facebook::react
+
+#endif // RCT_FIT_RM_OLD_RUNTIME

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/NativeToJsBridge.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#ifndef RCT_FIT_RM_OLD_RUNTIME
+
+#include <atomic>
+#include <functional>
+#include <map>
+#include <vector>
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/RuntimeExecutor.h>
+#include <cxxreact/JSExecutor.h>
+#include <jsinspector-modern/ReactCdp.h>
+
+namespace folly {
+struct dynamic;
+}
+
+namespace facebook::react {
+
+struct InstanceCallback;
+class JsToNativeBridge;
+class MessageQueueThread;
+class ModuleRegistry;
+class RAMBundleRegistry;
+
+// This class manages calls from native code to JS.  It also manages
+// executors and their threads.  All functions here can be called from
+// any thread.
+//
+// Except for loadBundleSync(), all void methods will queue
+// work to run on the jsQueue passed to the ctor, and return
+// immediately.
+class NativeToJsBridge {
+ public:
+  friend class JsToNativeBridge;
+
+  /**
+   * This must be called on the main JS thread.
+   */
+  NativeToJsBridge(
+      JSExecutorFactory* jsExecutorFactory,
+      std::shared_ptr<ModuleRegistry> registry,
+      std::shared_ptr<MessageQueueThread> jsQueue,
+      std::shared_ptr<InstanceCallback> callback);
+  virtual ~NativeToJsBridge();
+
+  /**
+   * Executes a function with the module ID and method ID and any additional
+   * arguments in JS.
+   */
+  void callFunction(
+      std::string&& module,
+      std::string&& method,
+      folly::dynamic&& args);
+
+  /**
+   * Invokes a callback with the cbID, and optional additional arguments in JS.
+   */
+  void invokeCallback(double callbackId, folly::dynamic&& args);
+
+  /**
+   * Sets global variables in the JS Context.
+   */
+  void initializeRuntime();
+
+  /**
+   * Starts the JS application.  If bundleRegistry is non-null, then it is
+   * used to fetch JavaScript modules as individual scripts.
+   * Otherwise, the script is assumed to include all the modules.
+   */
+  void loadBundle(
+      std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+      std::unique_ptr<const JSBigString> startupCode,
+      std::string sourceURL);
+  void loadBundleSync(
+      std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+      std::unique_ptr<const JSBigString> startupCode,
+      std::string sourceURL);
+
+  void registerBundle(uint32_t bundleId, const std::string& bundlePath);
+  void setGlobalVariable(
+      std::string propName,
+      std::unique_ptr<const JSBigString> jsonValue);
+  void* getJavaScriptContext();
+  bool isInspectable();
+  bool isBatchActive();
+
+  void handleMemoryPressure(int pressureLevel);
+
+  /**
+   * Synchronously tears down the bridge and the main executor.
+   */
+  void destroy();
+
+  // [Windows] Whether the executor still exists. Call only on the JS queue: the
+  // executor is created and deleted there, so this read doesn't race. The
+  // destructor can also delete it, but not while the caller holds a reference.
+  bool hasExecutor() const noexcept {
+    return m_executor != nullptr;
+  }
+
+  void runOnExecutorQueue(std::function<void(JSExecutor*)>&& task) noexcept;
+
+  /**
+   * NativeMethodCallInvoker is used by TurboModules to schedule work on the
+   * NativeModule thread(s).
+   */
+  std::shared_ptr<NativeMethodCallInvoker> getDecoratedNativeMethodCallInvoker(
+      std::shared_ptr<NativeMethodCallInvoker> nativeInvoker) const;
+
+  jsinspector_modern::RuntimeTargetDelegate& getInspectorTargetDelegate();
+
+ private:
+  // This is used to avoid a race condition where a proxyCallback gets queued
+  // after ~NativeToJsBridge(), on the same thread. In that case, the callback
+  // will try to run the task on m_callback which will have been destroyed
+  // within ~NativeToJsBridge(), thus causing a SIGSEGV.
+  std::shared_ptr<bool> m_destroyed;
+  std::shared_ptr<JsToNativeBridge> m_delegate;
+  std::unique_ptr<JSExecutor> m_executor;
+  std::shared_ptr<MessageQueueThread> m_executorMessageQueueThread;
+
+  // Memoize this on the JS thread, so that it can be inspected from
+  // any thread later.  This assumes inspectability doesn't change for
+  // a JSExecutor instance, which is true for all existing implementations.
+  bool m_inspectable;
+
+  // Keep track of whether the JS bundle containing the application logic causes
+  // exception when evaluated initially. If so, more calls to JS will very
+  // likely fail as well, so this flag can help prevent them.
+  bool m_applicationScriptHasFailure = false;
+
+#ifdef WITH_FBSYSTRACE
+  std::atomic<uint_least32_t> m_systraceCookie{0};
+#endif
+};
+
+} // namespace facebook::react
+
+#endif // RCT_FIT_RM_OLD_RUNTIME

package/Scripts/EnableInternalWinAppSDKFeed.ps1

@@ -9,11 +9,18 @@ Set-Location -Path $RepoRoot
 try
 {
     [xml] $nugetConfig = Get-Content "NuGet.Config"
-    $newFeed = $nugetConfig.configuration.packageSources.add.clone()
-    $newFeed.key = "Project.Reunion.nuget.internal";
-    $newFeed.value = "https://microsoft.pkgs.visualstudio.com/ProjectReunion/_packaging/Project.Reunion.nuget.internal/nuget/v3/index.json";
-    $nugetConfig.configuration.packageSources.AppendChild($newFeed)
-    $nugetConfig.Save("NuGet.Config")
+    $feedKey = "Project.Reunion.nuget.internal"
+    $newFeed = $nugetConfig.CreateElement("add")
+    $newFeed.SetAttribute("key", $feedKey)
+    $newFeed.SetAttribute("value", "https://microsoft.pkgs.visualstudio.com/ProjectReunion/_packaging/Project.Reunion.nuget.internal/nuget/v3/index.json")
+    [void] $nugetConfig.configuration.packageSources.AppendChild($newFeed)
+    $mapping = $nugetConfig.CreateElement("packageSource")
+    $mapping.SetAttribute("key", $feedKey)
+    $pattern = $nugetConfig.CreateElement("package")
+    $pattern.SetAttribute("pattern", "*")
+    [void] $mapping.AppendChild($pattern)
+    [void] $nugetConfig.configuration.packageSourceMapping.AppendChild($mapping)
+    $nugetConfig.Save("$RepoRoot\NuGet.Config")
 }
 finally
 {

package/Scripts/NuGetRestoreForceEvaluateAllSolutions.ps1

@@ -19,8 +19,8 @@ function Restore-Solution([string] $solution, [string[]] $extraArgs) {
 
 try {
     # Some node_modules packages ship a NuGet.Config that re-adds the public nuget.org feed. That
-    # breaks the repo's single-ADO-feed compliance and trips corporate network blocks on api.nuget.org.
-    # Strip any nuget.org source so restore only uses the repo's ADO feed.
+    # bypasses the approved source policy and trips corporate network blocks on api.nuget.org.
+    # Strip any nuget.org source so restore uses the approved sources and mappings in the root NuGet.Config.
     Get-ChildItem -File -Recurse -Path $RepoRoot -Filter NuGet.Config -ErrorAction SilentlyContinue |
         Where-Object { $_.FullName -match '\\node_modules\\' } | ForEach-Object {
             $configPath = $_.FullName

package/Shared/Networking/WinRTWebSocketResource.h

@@ -10,6 +10,7 @@
 #include "IWebSocketResource.h"
 
 // Standard Library
+#include <coroutine>
 #include <future>
 #include <mutex>
 #include <queue>
@@ -27,12 +28,7 @@ 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;