react-native-windows 0.0.0-canary.485 → 0.0.0-canary.486

package/.flowconfig

@@ -118,4 +118,4 @@ untyped-import
 untyped-type-import
 
 [version]
-^0.175.0
+^0.175.1

package/Libraries/Animated/nodes/AnimatedInterpolation.js

@@ -46,20 +46,23 @@ function createInterpolation(
   }
 
   const outputRange: Array<number> = (config.outputRange: any);
-  checkInfiniteRange('outputRange', outputRange);
 
   const inputRange = config.inputRange;
-  checkInfiniteRange('inputRange', inputRange);
-  checkValidInputRange(inputRange);
 
-  invariant(
-    inputRange.length === outputRange.length,
-    'inputRange (' +
-      inputRange.length +
-      ') and outputRange (' +
-      outputRange.length +
-      ') must have the same length',
-  );
+  if (__DEV__) {
+    checkInfiniteRange('outputRange', outputRange);
+    checkInfiniteRange('inputRange', inputRange);
+    checkValidInputRange(inputRange);
+
+    invariant(
+      inputRange.length === outputRange.length,
+      'inputRange (' +
+        inputRange.length +
+        ') and outputRange (' +
+        outputRange.length +
+        ') must have the same length',
+    );
+  }
 
   const easing = config.easing || linear;
 
@@ -276,16 +279,10 @@ function findRange(input: number, inputRange: $ReadOnlyArray<number>) {
 
 function checkValidInputRange(arr: $ReadOnlyArray<number>) {
   invariant(arr.length >= 2, 'inputRange must have at least 2 elements');
+  const message =
+    'inputRange must be monotonically non-decreasing ' + String(arr);
   for (let i = 1; i < arr.length; ++i) {
-    invariant(
-      arr[i] >= arr[i - 1],
-      /* $FlowFixMe[incompatible-type] (>=0.13.0) - In the addition expression
-       * below this comment, one or both of the operands may be something that
-       * doesn't cleanly convert to a string, like undefined, null, and object,
-       * etc. If you really mean this implicit string conversion, you can do
-       * something like String(myThing) */
-      'inputRange must be monotonically non-decreasing ' + arr,
-    );
+    invariant(arr[i] >= arr[i - 1], message);
   }
 }
 

package/Libraries/Components/View/ViewPropTypes.js

@@ -14,6 +14,7 @@ import type {
   BlurEvent,
   FocusEvent,
   MouseEvent,
+  PointerEvent,
   PressEvent,
   Layout,
   LayoutEvent,
@@ -84,8 +85,28 @@ type DirectEventProps = $ReadOnly<{|
 |}>;
 
 type MouseEventProps = $ReadOnly<{|
-  onMouseEnter?: (event: MouseEvent) => void,
-  onMouseLeave?: (event: MouseEvent) => void,
+  onMouseEnter?: ?(event: MouseEvent) => void,
+  onMouseLeave?: ?(event: MouseEvent) => void,
+|}>;
+
+type PointerEventProps = $ReadOnly<{|
+  onPointerEnter?: ?(event: PointerEvent) => void,
+  onPointerLeave?: ?(event: PointerEvent) => void,
+  onPointerMove?: ?(event: PointerEvent) => void,
+  onPointerCancel?: ?(e: PointerEvent) => void,
+  onPointerCancelCapture?: ?(e: PointerEvent) => void,
+  onPointerDown?: ?(e: PointerEvent) => void,
+  onPointerDownCapture?: ?(e: PointerEvent) => void,
+  onPointerUp?: ?(e: PointerEvent) => void,
+  onPointerUpCapture?: ?(e: PointerEvent) => void,
+
+  // FIXME: these events are temporary while we converge pointer event handling
+  onPointerEnter2?: ?(e: PointerEvent) => void,
+  onPointerEnter2Capture?: ?(e: PointerEvent) => void,
+  onPointerLeave2?: ?(e: PointerEvent) => void,
+  onPointerLeave2Capture?: ?(e: PointerEvent) => void,
+  onPointerMove2?: ?(e: PointerEvent) => void,
+  onPointerMove2Capture?: ?(e: PointerEvent) => void,
 |}>;
 
 type TouchEventProps = $ReadOnly<{|
@@ -99,20 +120,6 @@ type TouchEventProps = $ReadOnly<{|
   onTouchStartCapture?: ?(e: PressEvent) => void,
 |}>;
 
-type PointerEventCallbackProps = $ReadOnly<{|
-  onPointerCancel?: ?(e: PointerEvent) => void,
-  onPointerCancelCapture?: ?(e: PointerEvent) => void,
-  onPointerDown?: ?(e: PointerEvent) => void,
-  onPointerDownCapture?: ?(e: PointerEvent) => void,
-  onPointerEnter2?: ?(e: PointerEvent) => void,
-  onPointerLeave2?: ?(e: PointerEvent) => void,
-  onPointerEnter2Capture?: ?(e: PointerEvent) => void,
-  onPointerLeave2Capture?: ?(e: PointerEvent) => void,
-  onPointerMove2Capture?: ?(e: PointerEvent) => void,
-  onPointerUp?: ?(e: PointerEvent) => void,
-  onPointerUpCapture?: ?(e: PointerEvent) => void,
-|}>;
-
 /**
  * For most touch interactions, you'll simply want to wrap your component in
  * `TouchableHighlight` or `TouchableOpacity`. Check out `Touchable.js`,
@@ -395,8 +402,8 @@ export type ViewProps = $ReadOnly<{|
   ...DirectEventProps,
   ...GestureResponderEventProps,
   ...MouseEventProps,
+  ...PointerEventProps,
   ...TouchEventProps,
-  ...PointerEventCallbackProps,
   ...AndroidViewProps,
   ...IOSViewProps,
 

package/Libraries/Components/View/ViewPropTypes.windows.js

@@ -14,6 +14,7 @@ import type {
   BlurEvent,
   FocusEvent,
   MouseEvent,
+  PointerEvent,
   PressEvent,
   Layout,
   LayoutEvent,
@@ -85,8 +86,28 @@ type DirectEventProps = $ReadOnly<{|
 |}>;
 
 type MouseEventProps = $ReadOnly<{|
-  onMouseEnter?: (event: MouseEvent) => void,
-  onMouseLeave?: (event: MouseEvent) => void,
+  onMouseEnter?: ?(event: MouseEvent) => void,
+  onMouseLeave?: ?(event: MouseEvent) => void,
+|}>;
+
+type PointerEventProps = $ReadOnly<{|
+  onPointerEnter?: ?(event: PointerEvent) => void,
+  onPointerLeave?: ?(event: PointerEvent) => void,
+  onPointerMove?: ?(event: PointerEvent) => void,
+  onPointerCancel?: ?(e: PointerEvent) => void,
+  onPointerCancelCapture?: ?(e: PointerEvent) => void,
+  onPointerDown?: ?(e: PointerEvent) => void,
+  onPointerDownCapture?: ?(e: PointerEvent) => void,
+  onPointerUp?: ?(e: PointerEvent) => void,
+  onPointerUpCapture?: ?(e: PointerEvent) => void,
+
+  // FIXME: these events are temporary while we converge pointer event handling
+  onPointerEnter2?: ?(e: PointerEvent) => void,
+  onPointerEnter2Capture?: ?(e: PointerEvent) => void,
+  onPointerLeave2?: ?(e: PointerEvent) => void,
+  onPointerLeave2Capture?: ?(e: PointerEvent) => void,
+  onPointerMove2?: ?(e: PointerEvent) => void,
+  onPointerMove2Capture?: ?(e: PointerEvent) => void,
 |}>;
 
 type TouchEventProps = $ReadOnly<{|
@@ -100,20 +121,6 @@ type TouchEventProps = $ReadOnly<{|
   onTouchStartCapture?: ?(e: PressEvent) => void,
 |}>;
 
-type PointerEventCallbackProps = $ReadOnly<{|
-  onPointerCancel?: ?(e: PointerEvent) => void,
-  onPointerCancelCapture?: ?(e: PointerEvent) => void,
-  onPointerDown?: ?(e: PointerEvent) => void,
-  onPointerDownCapture?: ?(e: PointerEvent) => void,
-  onPointerEnter2?: ?(e: PointerEvent) => void,
-  onPointerLeave2?: ?(e: PointerEvent) => void,
-  onPointerEnter2Capture?: ?(e: PointerEvent) => void,
-  onPointerLeave2Capture?: ?(e: PointerEvent) => void,
-  onPointerMove2Capture?: ?(e: PointerEvent) => void,
-  onPointerUp?: ?(e: PointerEvent) => void,
-  onPointerUpCapture?: ?(e: PointerEvent) => void,
-|}>;
-
 /**
  * For most touch interactions, you'll simply want to wrap your component in
  * `TouchableHighlight` or `TouchableOpacity`. Check out `Touchable.js`,
@@ -443,8 +450,8 @@ export type ViewProps = $ReadOnly<{|
   ...DirectEventProps,
   ...GestureResponderEventProps,
   ...MouseEventProps,
+  ...PointerEventProps,
   ...TouchEventProps,
-  ...PointerEventCallbackProps,
   ...AndroidViewProps,
   ...IOSViewProps,
   ...WindowsViewProps, // [Windows]

package/Libraries/Core/ReactNativeVersion.js

@@ -13,5 +13,5 @@ exports.version = {
   major: 0,
   minor: 0,
   patch: 0,
-  prerelease: '20220404-2009-d5da70e17',
+  prerelease: '20220411-2010-f503b2120',
 };

package/Libraries/NativeComponent/PlatformBaseViewConfig.js

@@ -363,6 +363,32 @@ const PlatformBaseViewConfig: PartialViewConfigWithoutName =
               captured: 'onTouchEndCapture',
             },
           },
+
+          // Pointer Events
+          topPointerCancel: {
+            phasedRegistrationNames: {
+              captured: 'onPointerCancelCapture',
+              bubbled: 'onPointerCancel',
+            },
+          },
+          topPointerDown: {
+            phasedRegistrationNames: {
+              captured: 'onPointerDownCapture',
+              bubbled: 'onPointerDown',
+            },
+          },
+          topPointerMove2: {
+            phasedRegistrationNames: {
+              captured: 'onPointerMove2Capture',
+              bubbled: 'onPointerMove2',
+            },
+          },
+          topPointerUp: {
+            phasedRegistrationNames: {
+              captured: 'onPointerUpCapture',
+              bubbled: 'onPointerUp',
+            },
+          },
         },
         directEventTypes: {
           topAccessibilityAction: {

package/Libraries/Text/TextProps.js

@@ -12,6 +12,7 @@
 
 import type {
   LayoutEvent,
+  PointerEvent,
   PressEvent,
   TextLayoutEvent,
 } from '../Types/CoreEventTypes';
@@ -31,10 +32,18 @@ export type PressRetentionOffset = $ReadOnly<{|
   right: number,
 |}>;
 
+type PointerEventProps = $ReadOnly<{|
+  onPointerEnter?: (event: PointerEvent) => void,
+  onPointerLeave?: (event: PointerEvent) => void,
+  onPointerMove?: (event: PointerEvent) => void,
+|}>;
+
 /**
  * @see https://reactnative.dev/docs/text#reference
  */
 export type TextProps = $ReadOnly<{|
+  ...PointerEventProps,
+
   /**
    * Indicates whether the view is an accessibility element.
    *

package/Libraries/Utilities/Appearance.js

@@ -91,12 +91,4 @@ module.exports = {
   addChangeListener(listener: AppearanceListener): EventSubscription {
     return eventEmitter.addListener('change', listener);
   },
-
-  /**
-   * @deprecated Use `remove` on the EventSubscription from `addEventListener`.
-   */
-  removeChangeListener(listener: AppearanceListener): void {
-    // NOTE: This will report a deprecation notice via `console.error`.
-    eventEmitter.removeListener('change', listener);
-  },
 };

package/Libraries/Utilities/HMRClient.js

@@ -292,7 +292,7 @@ function registerBundleEntryPoints(client) {
 
 function flushEarlyLogs(client) {
   try {
-    pendingLogs.forEach(([level: LogLevel, data: Array<mixed>]) => {
+    pendingLogs.forEach(([level, data]) => {
       HMRClient.log(level, data);
     });
   } finally {

package/Mso/src/dispatchQueue/threadPoolScheduler_win.cpp

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
+#include <utility>
 #include "dispatchQueue/dispatchQueue.h"
 #include "queueService.h"
 
@@ -29,6 +30,13 @@ struct ThreadPoolSchedulerWin : Mso::UnknownObject<IDispatchQueueScheduler> {
   void Shutdown() noexcept override;
   void AwaitTermination() noexcept override;
 
+ public: // Used by test APIs
+  static void EnableThreadPoolWorkTracking(bool enable) noexcept;
+  static void WaitForThreadPoolWorkCompletion() noexcept;
+
+ private: // Used by test APIs
+  static void TrackThreadPoolWork(const std::shared_ptr<TP_WORK> &work) noexcept;
+
  private:
   struct ThreadAccessGuard {
     ThreadAccessGuard(ThreadPoolSchedulerWin *scheduler) noexcept;
@@ -42,12 +50,29 @@ struct ThreadPoolSchedulerWin : Mso::UnknownObject<IDispatchQueueScheduler> {
   };
 
  private:
-  std::unique_ptr<TP_WORK, ThreadPoolWorkDeleter> m_threadPoolWork;
+  std::shared_ptr<TP_WORK> m_threadPoolWork;
   Mso::WeakPtr<IDispatchQueueService> m_queue;
   const uint32_t m_maxThreads{1};
   std::atomic<uint32_t> m_usedThreads{0};
 
   constexpr static uint32_t MaxConcurrentThreads{64};
+
+ private:
+  static std::mutex s_threadPoolWorkMutex;
+  static bool s_enableThreadPoolWorkTracking;
+  static std::vector<std::shared_ptr<TP_WORK>> s_trackedThreadPoolWork;
+};
+
+// Track the ThreadPoolSchedulerWin instance used by current thread.
+// We use it to avoid a deadlock on queue shutdown.
+struct ThreadPoolSchedulerWinContext {
+  ThreadPoolSchedulerWinContext(ThreadPoolSchedulerWin *scheduler) noexcept;
+  ~ThreadPoolSchedulerWinContext() noexcept;
+  static ThreadPoolSchedulerWin *CurrentScheduler() noexcept;
+
+ private:
+  static thread_local ThreadPoolSchedulerWin *tls_scheduler;
+  ThreadPoolSchedulerWin *m_prevScheduler{nullptr};
 };
 
 //=============================================================================
@@ -64,9 +89,15 @@ void ThreadPoolWorkDeleter::operator()(TP_WORK *tpWork) noexcept {
 // ThreadPoolSchedulerWin implementation
 //=============================================================================
 
+std::mutex ThreadPoolSchedulerWin::s_threadPoolWorkMutex;
+bool ThreadPoolSchedulerWin::s_enableThreadPoolWorkTracking{false};
+std::vector<std::shared_ptr<TP_WORK>> ThreadPoolSchedulerWin::s_trackedThreadPoolWork;
+
 ThreadPoolSchedulerWin::ThreadPoolSchedulerWin(uint32_t maxThreads) noexcept
-    : m_threadPoolWork{::CreateThreadpoolWork(WorkCallback, this, nullptr)},
-      m_maxThreads{maxThreads == 0 ? MaxConcurrentThreads : maxThreads} {}
+    : m_threadPoolWork{::CreateThreadpoolWork(WorkCallback, this, nullptr), ThreadPoolWorkDeleter{}},
+      m_maxThreads{maxThreads == 0 ? MaxConcurrentThreads : maxThreads} {
+  TrackThreadPoolWork(m_threadPoolWork);
+}
 
 ThreadPoolSchedulerWin::~ThreadPoolSchedulerWin() noexcept {
   AwaitTermination();
@@ -78,6 +109,7 @@ ThreadPoolSchedulerWin::~ThreadPoolSchedulerWin() noexcept {
     _Inout_ PTP_WORK /*work*/) {
   // The ThreadPoolSchedulerWin is alive here because m_threadPoolWork must be completed before it is destroyed.
   ThreadPoolSchedulerWin *self = static_cast<ThreadPoolSchedulerWin *>(context);
+  ThreadPoolSchedulerWinContext schedulerContext(self);
 
   if (auto queue = self->m_queue.GetStrongPtr()) {
     auto endTime = std::chrono::steady_clock::now() + 100ms;
@@ -129,7 +161,38 @@ void ThreadPoolSchedulerWin::Shutdown() noexcept {
 }
 
 void ThreadPoolSchedulerWin::AwaitTermination() noexcept {
-  ::WaitForThreadpoolWorkCallbacks(m_threadPoolWork.get(), false);
+  // Avoid deadlock when the dispatch queue and ThreadPoolSchedulerWin are released from inside of a task.
+  if (ThreadPoolSchedulerWinContext::CurrentScheduler() != this) {
+    ::WaitForThreadpoolWorkCallbacks(m_threadPoolWork.get(), false);
+  }
+}
+
+void ThreadPoolSchedulerWin::EnableThreadPoolWorkTracking(bool enable) noexcept {
+  std::vector<std::shared_ptr<TP_WORK>> tpWorkToStopTracking;
+  {
+    std::scoped_lock lock{s_threadPoolWorkMutex};
+    s_enableThreadPoolWorkTracking = enable;
+    // Reset all previously tracked work
+    tpWorkToStopTracking = std::move(s_trackedThreadPoolWork);
+  }
+}
+
+void ThreadPoolSchedulerWin::WaitForThreadPoolWorkCompletion() noexcept {
+  std::vector<std::shared_ptr<TP_WORK>> tpWorkToTrack;
+  {
+    std::scoped_lock lock{s_threadPoolWorkMutex};
+    tpWorkToTrack = std::move(s_trackedThreadPoolWork);
+  }
+  for (std::shared_ptr<TP_WORK> &tpWork : tpWorkToTrack) {
+    ::WaitForThreadpoolWorkCallbacks(tpWork.get(), false);
+  }
+}
+
+void ThreadPoolSchedulerWin::TrackThreadPoolWork(const std::shared_ptr<TP_WORK> &tpWork) noexcept {
+  std::scoped_lock lock{s_threadPoolWorkMutex};
+  if (s_enableThreadPoolWorkTracking) {
+    s_trackedThreadPoolWork.push_back(tpWork);
+  }
 }
 
 //=============================================================================
@@ -151,6 +214,23 @@ ThreadPoolSchedulerWin::ThreadAccessGuard::~ThreadAccessGuard() noexcept {
   return tls_scheduler == scheduler;
 }
 
+//=============================================================================
+// ThreadPoolSchedulerWinContext implementation
+//=============================================================================
+
+thread_local ThreadPoolSchedulerWin *ThreadPoolSchedulerWinContext::tls_scheduler{nullptr};
+
+ThreadPoolSchedulerWinContext::ThreadPoolSchedulerWinContext(ThreadPoolSchedulerWin *scheduler) noexcept
+    : m_prevScheduler(std::exchange(tls_scheduler, scheduler)) {}
+
+ThreadPoolSchedulerWinContext::~ThreadPoolSchedulerWinContext() noexcept {
+  std::exchange(tls_scheduler, m_prevScheduler);
+}
+
+ThreadPoolSchedulerWin *ThreadPoolSchedulerWinContext::CurrentScheduler() noexcept {
+  return tls_scheduler;
+}
+
 //=============================================================================
 // DispatchQueueStatic::MakeThreadPoolScheduler implementation
 //=============================================================================
@@ -160,4 +240,16 @@ ThreadPoolSchedulerWin::ThreadAccessGuard::~ThreadAccessGuard() noexcept {
   return Mso::Make<ThreadPoolSchedulerWin, IDispatchQueueScheduler>(maxThreads);
 }
 
+//=============================================================================
+// Test specific functions
+//=============================================================================
+
+void Test_ThreadPoolSchedulerWin_EnableThreadPoolWorkTracking(bool enable) noexcept {
+  ThreadPoolSchedulerWin::EnableThreadPoolWorkTracking(enable);
+}
+
+void Test_ThreadPoolSchedulerWin_WaitForThreadPoolWorkCompletion() noexcept {
+  ThreadPoolSchedulerWin::WaitForThreadPoolWorkCompletion();
+}
+
 } // namespace Mso

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,7 +10,7 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.485</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.486</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>

package/Shared/DevSupportManager.cpp

@@ -33,6 +33,7 @@
 #pragma warning(pop)
 
 #include <future>
+#include <mutex>
 
 #include <AppModel.h>
 
@@ -239,37 +240,32 @@ void DevSupportManager::StopPollingLiveReload() {
   m_cancellation_token = true;
 }
 
-void DevSupportManager::StartInspector(
+void DevSupportManager::EnsureHermesInspector(
     [[maybe_unused]] const std::string &packagerHost,
     [[maybe_unused]] const uint16_t packagerPort) noexcept {
 #ifdef HERMES_ENABLE_DEBUGGER
-  std::string packageName("RNW");
-  wchar_t fullName[PACKAGE_FULL_NAME_MAX_LENGTH]{};
-  UINT32 size = ARRAYSIZE(fullName);
-  if (SUCCEEDED(GetCurrentPackageFullName(&size, fullName))) {
-    // we are in an unpackaged app
-    packageName = winrt::to_string(fullName);
-  }
+  static std::once_flag once;
+  std::call_once(once, [this, &packagerHost, packagerPort]() {
+    std::string packageName("RNW");
+    wchar_t fullName[PACKAGE_FULL_NAME_MAX_LENGTH]{};
+    UINT32 size = ARRAYSIZE(fullName);
+    if (SUCCEEDED(GetCurrentPackageFullName(&size, fullName))) {
+      // we are in an unpackaged app
+      packageName = winrt::to_string(fullName);
+    }
 
-  std::string deviceName("RNWHost");
-  auto hostNames = winrt::Windows::Networking::Connectivity::NetworkInformation::GetHostNames();
-  if (hostNames && hostNames.First() && hostNames.First().Current()) {
-    deviceName = winrt::to_string(hostNames.First().Current().DisplayName());
-  }
+    std::string deviceName("RNWHost");
+    auto hostNames = winrt::Windows::Networking::Connectivity::NetworkInformation::GetHostNames();
+    if (hostNames && hostNames.First() && hostNames.First().Current()) {
+      deviceName = winrt::to_string(hostNames.First().Current().DisplayName());
+    }
 
-  m_inspectorPackagerConnection = std::make_shared<InspectorPackagerConnection>(
-      facebook::react::DevServerHelper::get_InspectorDeviceUrl(packagerHost, packagerPort, deviceName, packageName),
-      m_BundleStatusProvider);
-  m_inspectorPackagerConnection->connectAsync();
-#endif
-}
+    m_inspectorPackagerConnection = std::make_shared<InspectorPackagerConnection>(
+        facebook::react::DevServerHelper::get_InspectorDeviceUrl(packagerHost, packagerPort, deviceName, packageName),
+        m_BundleStatusProvider);
+    m_inspectorPackagerConnection->connectAsync();
+  });
 
-void DevSupportManager::StopInspector() noexcept {
-#ifdef HERMES_ENABLE_DEBUGGER
-  if (m_inspectorPackagerConnection) {
-    m_inspectorPackagerConnection->disconnectAsync();
-    m_inspectorPackagerConnection = nullptr;
-  }
 #endif
 }
 

package/Shared/DevSupportManager.h

@@ -50,8 +50,7 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
       std::function<void()> onChangeCallback) override;
   virtual void StopPollingLiveReload() override;
 
-  virtual void StartInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
-  virtual void StopInspector() noexcept override;
+  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
   virtual void UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept override;
 
  private:

package/Shared/HermesRuntimeHolder.cpp

@@ -74,7 +74,15 @@ class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::R
 } // namespace
 
 void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  HermesShim::hermesCrashHandler(static_cast<facebook::hermes::HermesRuntime &>(*m_runtime), fileDescriptor);
+  HermesShim::hermesCrashHandler(*m_hermesRuntime, fileDescriptor);
+}
+
+void HermesRuntimeHolder::teardown() noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
+  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
+    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
+  }
+#endif
 }
 
 facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
@@ -84,43 +92,44 @@ facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcep
 std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
   std::call_once(m_once_flag, [this]() { initRuntime(); });
 
-  if (!m_runtime)
+  if (!m_hermesRuntime)
     std::terminate();
 
   // Make sure that the runtime instance is not consumed from multiple threads.
   if (m_own_thread_id != std::this_thread::get_id())
     std::terminate();
 
-  return m_runtime;
+  return m_hermesRuntime;
 }
 
 HermesRuntimeHolder::HermesRuntimeHolder(
     std::shared_ptr<facebook::react::DevSettings> devSettings,
     std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept
-    : m_devSettings(std::move(devSettings)), m_jsQueue(std::move(jsQueue)) {}
+    : m_weakDevSettings(devSettings), m_jsQueue(std::move(jsQueue)) {}
 
 void HermesRuntimeHolder::initRuntime() noexcept {
-  auto hermesRuntime = makeHermesRuntimeSystraced(m_devSettings->enableDefaultCrashHandler);
-
-  facebook::hermes::HermesRuntime &hermesRuntimeRef = *hermesRuntime;
+  auto devSettings = m_weakDevSettings.lock();
+  if (!devSettings)
+    std::terminate();
 
-  m_runtime = std::move(hermesRuntime);
+  m_hermesRuntime = makeHermesRuntimeSystraced(devSettings->enableDefaultCrashHandler);
   m_own_thread_id = std::this_thread::get_id();
 
 #ifdef HERMES_ENABLE_DEBUGGER
-  if (m_devSettings->useDirectDebugger) {
-    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_runtime, hermesRuntimeRef, m_jsQueue);
+  if (devSettings->useDirectDebugger) {
+    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_hermesRuntime, *m_hermesRuntime, m_jsQueue);
     facebook::hermes::inspector::chrome::enableDebugging(
         std::move(adapter),
-        m_devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : m_devSettings->debuggerRuntimeName);
+        devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : devSettings->debuggerRuntimeName);
   }
 #endif
 
   // Add js engine information to Error.prototype so in error reporting we
   // can send this information.
-  auto errorPrototype =
-      m_runtime->global().getPropertyAsObject(*m_runtime, "Error").getPropertyAsObject(*m_runtime, "prototype");
-  errorPrototype.setProperty(*m_runtime, "jsEngine", "hermes");
+  auto errorPrototype = m_hermesRuntime->global()
+                            .getPropertyAsObject(*m_hermesRuntime, "Error")
+                            .getPropertyAsObject(*m_hermesRuntime, "prototype");
+  errorPrototype.setProperty(*m_hermesRuntime, "jsEngine", "hermes");
 }
 
 } // namespace react

package/Shared/HermesRuntimeHolder.h

@@ -9,6 +9,10 @@
 
 #include <DevSettings.h>
 
+namespace facebook::hermes {
+class HermesRuntime;
+}
+
 namespace facebook {
 namespace react {
 
@@ -19,18 +23,20 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
 
   void crashHandler(int fileDescriptor) noexcept override;
 
+  void teardown() noexcept override;
+
   HermesRuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,
       std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept;
 
  private:
   void initRuntime() noexcept;
-  std::shared_ptr<facebook::jsi::Runtime> m_runtime;
+  std::shared_ptr<facebook::hermes::HermesRuntime> m_hermesRuntime;
 
   std::once_flag m_once_flag;
   std::thread::id m_own_thread_id;
 
-  std::shared_ptr<facebook::react::DevSettings> m_devSettings;
+  std::weak_ptr<facebook::react::DevSettings> m_weakDevSettings;
   std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
 };
 

package/Shared/IDevSupportManager.h

@@ -22,8 +22,7 @@ struct IDevSupportManager {
       std::function<void()> onChangeCallback) = 0;
   virtual void StopPollingLiveReload() = 0;
 
-  virtual void StartInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
-  virtual void StopInspector() noexcept = 0;
+  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
   virtual void UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept = 0;
 };
 

package/Shared/JSI/RuntimeHolder.h

@@ -18,6 +18,8 @@ struct RuntimeHolderLazyInit {
   virtual std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept = 0;
   virtual facebook::react::JSIEngineOverride getRuntimeType() noexcept = 0;
 
+  virtual void teardown() noexcept {};
+
   // You can call this when a crash happens to attempt recording additional data
   // The fd supplied is a raw file stream an implementation might write JSON to
   virtual void crashHandler(int fileDescriptor) noexcept {};

package/Shared/OInstance.cpp

@@ -254,7 +254,7 @@ InstanceImpl::InstanceImpl(
 #endif
 
   if (shouldStartHermesInspector(*m_devSettings)) {
-    m_devManager->StartInspector(m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort);
+    m_devManager->EnsureHermesInspector(m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort);
   }
 
   // Default (common) NativeModules
@@ -532,8 +532,8 @@ void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool s
 }
 
 InstanceImpl::~InstanceImpl() {
-  if (shouldStartHermesInspector(*m_devSettings)) {
-    m_devManager->StopInspector();
+  if (shouldStartHermesInspector(*m_devSettings) && m_devSettings->jsiRuntimeHolder) {
+    m_devSettings->jsiRuntimeHolder->teardown();
   }
   m_nativeQueue->quitSynchronous();
 }

package/jest/preprocessor_DO_NOT_USE.js

@@ -30,7 +30,7 @@ babelRegisterOnly([]);
 
 const transformer = require('metro-react-native-babel-transformer');
 module.exports = {
-  process(src /*: string */, file /*: string */) /*: string */ {
+  process(src /*: string */, file /*: string */) /*: {code: string, ...} */ {
     if (nodeFiles.test(file)) {
       // node specific transforms only
       return babelTransformSync(src, {
@@ -38,7 +38,7 @@ module.exports = {
         sourceType: 'script',
         ...nodeOptions,
         ast: false,
-      }).code;
+      });
     }
 
     const {ast} = transformer.transform({
@@ -111,7 +111,7 @@ module.exports = {
         sourceMaps: true,
       },
       src,
-    ).code;
+    );
   },
 
   getCacheKey: (createCacheKeyFunction([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.485",
+  "version": "0.0.0-canary.486",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
     "@react-native-community/cli-platform-android": "^7.0.1",
     "@react-native-community/cli-platform-ios": "^7.0.1",
     "@react-native-windows/cli": "0.0.0-canary.125",
-    "@react-native-windows/virtualized-list": "0.0.0-canary.38",
+    "@react-native-windows/virtualized-list": "0.0.0-canary.39",
     "@react-native/assets": "1.0.0",
     "@react-native/normalize-color": "2.0.0",
     "@react-native/polyfills": "2.0.0",
@@ -39,22 +39,22 @@
     "invariant": "^2.2.4",
     "jsc-android": "^250230.2.1",
     "memoize-one": "^5.0.0",
-    "metro-react-native-babel-transformer": "0.70.0",
-    "metro-runtime": "0.70.0",
-    "metro-source-map": "0.70.0",
+    "metro-react-native-babel-transformer": "0.70.1",
+    "metro-runtime": "0.70.1",
+    "metro-source-map": "0.70.1",
     "nullthrows": "^1.1.1",
     "pretty-format": "^26.5.2",
     "promise": "^8.0.3",
     "react-devtools-core": "4.24.0",
     "react-native-codegen": "^0.0.14",
-    "react-native-gradle-plugin": "^0.0.5",
+    "react-native-gradle-plugin": "^0.0.6",
     "react-refresh": "^0.4.0",
     "react-shallow-renderer": "16.14.1",
     "regenerator-runtime": "^0.13.2",
     "scheduler": "^0.20.2",
     "source-map-support": "^0.5.19",
     "stacktrace-parser": "^0.1.3",
-    "use-subscription": "^1.0.0",
+    "use-subscription": ">=1.0.0 <1.6.0",
     "whatwg-fetch": "^3.0.0",
     "ws": "^6.1.4"
   },
@@ -69,13 +69,13 @@
     "@types/react-native": "^0.66.17",
     "eslint": "^7.32.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "flow-bin": "^0.175.0",
+    "flow-bin": "^0.175.1",
     "jscodeshift": "^0.13.1",
     "just-scripts": "^1.3.3",
     "metro-config": "^0.67.0",
     "prettier": "^2.4.1",
     "react": "17.0.2",
-    "react-native": "0.0.0-20220404-2009-d5da70e17",
+    "react-native": "0.0.0-20220411-2010-f503b2120",
     "react-native-platform-override": "^1.6.9",
     "react-refresh": "^0.4.0",
     "react-shallow-renderer": "16.14.1",
@@ -83,7 +83,7 @@
   },
   "peerDependencies": {
     "react": "17.0.2",
-    "react-native": "0.0.0-20220404-2009-d5da70e17"
+    "react-native": "0.0.0-20220411-2010-f503b2120"
   },
   "beachball": {
     "defaultNpmTag": "canary",