react-native-windows 0.80.1 → 0.80.6

package/Microsoft.ReactNative/ReactHost/ReactHost.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <jsinspector-modern/HostTarget.h>
 #include <mutex>
 #include <unordered_map>
 #include "AsyncActionQueue.h"
@@ -15,6 +16,7 @@
 
 namespace Mso::React {
 
+class ReactInspectorHostTargetDelegate;
 class ReactViewHost;
 
 //! ReactHost manages lifetime of ReactNative instance.
@@ -52,9 +54,6 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
 
   Mso::CntPtr<AsyncActionQueue> ActionQueue() const noexcept;
 
-  Mso::Future<void> LoadInQueue(ReactOptions &&options) noexcept;
-  Mso::Future<void> UnloadInQueue(size_t unloadActionId) noexcept;
-
   void Close() noexcept;
   bool IsClosed() const noexcept;
 
@@ -64,6 +63,12 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   template <class TCallback>
   Mso::Future<void> PostInQueue(TCallback &&callback) noexcept;
 
+ private:
+  enum class UnloadReason {
+    Unload,
+    CloseHost,
+  };
+
  private:
   friend MakePolicy;
   ReactHost(Mso::DispatchQueue const &queue) noexcept;
@@ -75,9 +80,18 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   void ForEachViewHost(const Mso::FunctorRef<void(ReactViewHost &)> &action) noexcept;
 
   AsyncAction MakeLoadInstanceAction(ReactOptions &&options) noexcept;
-  AsyncAction MakeUnloadInstanceAction() noexcept;
+  AsyncAction MakeUnloadInstanceAction(UnloadReason reason) noexcept;
+
+  Mso::Future<void> LoadInQueue(ReactOptions &&options) noexcept;
+  Mso::Future<void> UnloadInQueue(UnloadReason reason, size_t unloadActionId) noexcept;
+
+  void OnDebuggerResume() noexcept;
+  bool IsInspectable() noexcept;
+  void AddInspectorPage() noexcept;
+  void RemoveInspectorPage() noexcept;
 
  private:
+  friend class ReactInspectorHostTargetDelegate;
   mutable std::mutex m_mutex;
   const Mso::InvokeElsePostExecutor m_executor{Queue()};
   const Mso::ActiveReadableField<Mso::CntPtr<AsyncActionQueue>> m_actionQueue{
@@ -92,6 +106,10 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   size_t m_pendingUnloadActionId{0};
   size_t m_nextUnloadActionId{0};
   const Mso::ActiveField<bool> m_isInstanceUnloading{false, Queue()};
+
+  const std::shared_ptr<facebook::react::jsinspector_modern::HostTargetDelegate> m_inspectorHostTargetDelegate;
+  const std::shared_ptr<facebook::react::jsinspector_modern::HostTarget> m_inspectorHostTarget;
+  const Mso::ActiveField<std::optional<int32_t>> m_inspectorPageId{Queue()};
 };
 
 //! Implements a cross-platform host for a React view

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -66,6 +66,7 @@
 #include <react/runtime/PlatformTimerRegistry.h>
 #include <react/runtime/TimerManager.h>
 #include <react/threading/MessageQueueThreadImpl.h>
+#include "Inspector/ReactInspectorThread.h"
 #endif
 
 #if !defined(CORE_ABI) && !defined(USE_FABRIC)
@@ -553,6 +554,8 @@ std::shared_ptr<facebook::react::DevSettings> ReactInstanceWin::CreateDevSetting
 
   devSettings->useRuntimeScheduler = useRuntimeScheduler;
 
+  devSettings->inspectorHostTarget = m_options.InspectorHostTarget;
+
   return devSettings;
 }
 
@@ -664,16 +667,21 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
               };
 
               if (devSettings->useDirectDebugger) {
-                ::Microsoft::ReactNative::GetSharedDevManager()->EnsureHermesInspector(
-                    devSettings->sourceBundleHost, devSettings->sourceBundlePort);
+                ::Microsoft::ReactNative::GetSharedDevManager()->EnsureInspectorPackagerConnection(
+                    devSettings->sourceBundleHost, devSettings->sourceBundlePort, devSettings->bundleAppId);
               }
 
               m_jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
                   devSettings, jsMessageThread, CreatePreparedScriptStore());
               auto jsRuntime = std::make_unique<Microsoft::ReactNative::HermesJSRuntime>(m_jsiRuntimeHolder);
               jsRuntime->getRuntime();
-              m_bridgelessReactInstance = std::make_unique<facebook::react::ReactInstance>(
-                  std::move(jsRuntime), jsMessageThread, timerManager, jsErrorHandlingFunc);
+
+              m_bridgelessReactInstance = std::make_shared<facebook::react::ReactInstance>(
+                  std::move(jsRuntime),
+                  jsMessageThread,
+                  timerManager,
+                  jsErrorHandlingFunc,
+                  m_options.InspectorHostTarget);
 
               auto bufferedRuntimeExecutor = m_bridgelessReactInstance->getBufferedRuntimeExecutor();
               timerManager->setRuntimeExecutor(bufferedRuntimeExecutor);
@@ -695,6 +703,7 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
                 winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
 
             facebook::react::ReactInstance::JSRuntimeFlags options;
+
             m_bridgelessReactInstance->initializeRuntime(
                 options,
                 [=, onCreated = m_options.OnInstanceCreated, reactContext = m_reactContext](
@@ -748,7 +757,6 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
 
             LoadJSBundlesBridgeless(devSettings);
             SetupHMRClient();
-
           } catch (std::exception &e) {
             OnErrorWithMessage(e.what());
             OnErrorWithMessage("ReactInstanceWin: Failed to create React Instance.");
@@ -1092,6 +1100,17 @@ Mso::Future<void> ReactInstanceWin::Destroy() noexcept {
   if (m_bridgelessReactInstance) {
     if (auto jsMessageThread = m_jsMessageThread.Exchange(nullptr)) {
       jsMessageThread->runOnQueueSync([&]() noexcept {
+        // Unregister from inspector BEFORE shutting down JS thread
+        if (m_bridgelessReactInstance && m_options.InspectorHostTarget) {
+          Mso::React::MessageDispatchQueue messageDispatchQueue{
+              ::Microsoft::ReactNative::ReactInspectorThread::Instance(), nullptr};
+          messageDispatchQueue.runOnQueueSync(
+              [weakBridgelessReactInstance = std::weak_ptr(m_bridgelessReactInstance)]() {
+                if (auto bridgelessReactInstance = weakBridgelessReactInstance.lock()) {
+                  bridgelessReactInstance->unregisterFromInspector();
+                }
+              });
+        }
         {
           // Release the JSI runtime
           std::scoped_lock lock{m_mutex};

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -205,7 +205,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
 
 #ifdef USE_FABRIC
   // Bridgeless
-  std::unique_ptr<facebook::react::ReactInstance> m_bridgelessReactInstance;
+  std::shared_ptr<facebook::react::ReactInstance> m_bridgelessReactInstance;
 #endif
 
   std::atomic<ReactInstanceState> m_state{ReactInstanceState::Loading};

package/Microsoft.ReactNative/ReactRootView.cpp

@@ -5,14 +5,19 @@
 #include "ReactRootView.g.cpp"
 
 #include <QuirkSettings.h>
+#include <ReactHost/DebuggerNotifications.h>
 #include <ReactHost/MsoUtils.h>
+#include <UI.Text.h>
+#include <UI.Xaml.Controls.Primitives.h>
 #include <UI.Xaml.Input.h>
 #include <UI.Xaml.Media.Media3D.h>
 #include <Utils/Helpers.h>
 #include <dispatchQueue/dispatchQueue.h>
 #include <winrt/Windows.UI.Core.h>
+#include "InstanceManager.h"
 #include "ReactNativeHost.h"
 #include "ReactViewInstance.h"
+#include "Utils/KeyboardUtils.h"
 #include "XamlUtils.h"
 
 #include <winrt/Microsoft.UI.Xaml.Controls.h>
@@ -34,6 +39,7 @@ ReactRootView::ReactRootView() noexcept : m_uiQueue(Mso::DispatchQueue::GetCurre
   UpdatePerspective();
   Loaded([this](auto &&, auto &&) {
     ::Microsoft::ReactNative::SetCompositor(::Microsoft::ReactNative::GetCompositor(*this));
+    SetupDevToolsShortcut();
   });
 }
 
@@ -45,6 +51,20 @@ void ReactRootView::ReactNativeHost(ReactNative::ReactNativeHost const &value) n
   if (m_reactNativeHost != value) {
     ReactViewHost(nullptr);
     m_reactNativeHost = value;
+    const auto weakThis = this->get_weak();
+    ::Microsoft::ReactNative::DebuggerNotifications::SubscribeShowDebuggerPausedOverlay(
+        m_reactNativeHost.InstanceSettings().Notifications(),
+        m_reactNativeHost.InstanceSettings().UIDispatcher(),
+        [weakThis](std::string message, std::function<void()> onResume) {
+          if (auto strongThis = weakThis.get()) {
+            strongThis->ShowDebuggerPausedOverlay(message, onResume);
+          }
+        },
+        [weakThis]() {
+          if (auto strongThis = weakThis.get()) {
+            strongThis->HideDebuggerPausedOverlay();
+          }
+        });
     ReloadView();
   }
 }
@@ -283,6 +303,65 @@ void ReactRootView::EnsureLoadingUI() noexcept {
   }
 }
 
+void ReactRootView::HideDebuggerPausedOverlay() noexcept {
+  m_isDebuggerPausedOverlayOpen = false;
+  if (m_debuggerPausedFlyout) {
+    m_debuggerPausedFlyout.Hide();
+    m_debuggerPausedFlyout = nullptr;
+  }
+}
+
+void ReactRootView::ShowDebuggerPausedOverlay(
+    const std::string &message,
+    const std::function<void()> &onResume) noexcept {
+  // Initialize content
+  const xaml::Controls::Grid contentGrid;
+  xaml::Controls::ColumnDefinition messageColumnDefinition;
+  xaml::Controls::ColumnDefinition buttonColumnDefinition;
+  messageColumnDefinition.MinWidth(60);
+  buttonColumnDefinition.MinWidth(36);
+  contentGrid.ColumnDefinitions().Append(messageColumnDefinition);
+  contentGrid.ColumnDefinitions().Append(buttonColumnDefinition);
+  xaml::Controls::TextBlock messageBlock;
+  messageBlock.Text(winrt::to_hstring(message));
+  messageBlock.FontWeight(winrt::Windows::UI::Text::FontWeights::SemiBold());
+  xaml::Controls::FontIcon resumeGlyph;
+  resumeGlyph.FontFamily(xaml::Media::FontFamily(L"Segoe MDL2 Assets"));
+  resumeGlyph.Foreground(xaml::Media::SolidColorBrush(winrt::Colors::Green()));
+  resumeGlyph.Glyph(L"\uF5B0");
+  resumeGlyph.HorizontalAlignment(xaml::HorizontalAlignment::Right);
+  resumeGlyph.PointerReleased([onResume](auto &&...) { onResume(); });
+  xaml::Controls::Grid::SetColumn(resumeGlyph, 1);
+  contentGrid.Children().Append(messageBlock);
+  contentGrid.Children().Append(resumeGlyph);
+
+  // Configure flyout
+  m_isDebuggerPausedOverlayOpen = true;
+  xaml::Style flyoutStyle(
+      {XAML_NAMESPACE_STR L".Controls.FlyoutPresenter", winrt::Windows::UI::Xaml::Interop::TypeKind::Metadata});
+  flyoutStyle.Setters().Append(winrt::Setter(
+      xaml::Controls::Control::CornerRadiusProperty(), winrt::box_value(xaml::CornerRadius{12, 12, 12, 12})));
+  flyoutStyle.Setters().Append(winrt::Setter(
+      xaml::Controls::Control::BackgroundProperty(),
+      winrt::box_value(xaml::Media::SolidColorBrush{FromArgb(255, 255, 255, 193)})));
+  flyoutStyle.Setters().Append(
+      winrt::Setter(xaml::FrameworkElement::MarginProperty(), winrt::box_value(xaml::Thickness{0, 12, 0, 0})));
+  m_debuggerPausedFlyout = xaml::Controls::Flyout{};
+  m_debuggerPausedFlyout.FlyoutPresenterStyle(flyoutStyle);
+  m_debuggerPausedFlyout.LightDismissOverlayMode(xaml::Controls::LightDismissOverlayMode::On);
+  m_debuggerPausedFlyout.Content(contentGrid);
+
+  // Disable light dismiss
+  m_debuggerPausedFlyout.Closing([weakThis = this->get_weak()](auto &&, const auto &args) {
+    if (auto strongThis = weakThis.get()) {
+      args.Cancel(strongThis->m_isDebuggerPausedOverlayOpen);
+    }
+  });
+
+  // Show flyout
+  m_debuggerPausedFlyout.ShowAt(*this);
+}
+
 void ReactRootView::ShowInstanceLoaded() noexcept {
   if (m_xamlRootView) {
     ClearLoadingUI();
@@ -481,4 +560,33 @@ void ReactRootView::RemoveChildAt(uint32_t index) {
   Children().RemoveAt(RNIndexToXamlIndex(index));
 }
 
+bool IsCtrlShiftI(winrt::Windows::System::VirtualKey key) noexcept {
+  return (
+      key == winrt::Windows::System::VirtualKey::I &&
+      ::Microsoft::ReactNative::IsModifiedKeyPressed(
+          winrt::CoreWindow::GetForCurrentThread(), winrt::Windows::System::VirtualKey::Shift) &&
+      ::Microsoft::ReactNative::IsModifiedKeyPressed(
+          winrt::CoreWindow::GetForCurrentThread(), winrt::Windows::System::VirtualKey::Control));
+}
+
+void ReactRootView::SetupDevToolsShortcut() noexcept {
+  if (auto xamlRoot = XamlRoot()) {
+    if (std::find(m_subscribedDebuggerRoots.begin(), m_subscribedDebuggerRoots.end(), xamlRoot) ==
+        m_subscribedDebuggerRoots.end()) {
+      if (auto rootContent = xamlRoot.Content()) {
+        m_subscribedDebuggerRoots.push_back(xamlRoot);
+        rootContent.KeyDown(
+            [weakThis = this->get_weak()](const auto & /*sender*/, const xaml::Input::KeyRoutedEventArgs &args) {
+              if (const auto strongThis = weakThis.get()) {
+                if (IsCtrlShiftI(args.Key())) {
+                  ::Microsoft::ReactNative::GetSharedDevManager()->OpenDevTools(
+                      winrt::to_string(strongThis->m_reactNativeHost.InstanceSettings().BundleAppId()));
+                }
+              };
+            });
+      }
+    }
+  }
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactRootView.h

@@ -72,6 +72,7 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   bool m_isPerspectiveEnabled{true};
   bool m_isInitialized{false};
   bool m_isJSViewAttached{false};
+  bool m_isDebuggerPausedOverlayOpen{false};
   Mso::DispatchQueue m_uiQueue;
   int64_t m_rootTag{-1};
   std::unique_ptr<Mso::React::ReactOptions> m_reactOptions;
@@ -84,9 +85,11 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   std::shared_ptr<::Microsoft::ReactNative::PreviewKeyboardEventHandlerOnRoot> m_previewKeyboardEventHandlerOnRoot;
   xaml::Controls::ContentControl m_focusSafeHarbor{nullptr};
   xaml::Controls::ContentControl::LosingFocus_revoker m_focusSafeHarborLosingFocusRevoker{};
+  xaml::Controls::Flyout m_debuggerPausedFlyout{nullptr};
   winrt::Grid m_greenBoxGrid{nullptr};
   winrt::TextBlock m_waitingTextBlock{nullptr};
   winrt::SystemNavigationManager::BackRequested_revoker m_backRequestedRevoker{};
+  std::vector<xaml::XamlRoot> m_subscribedDebuggerRoots{};
 
   // Visual tree to support safe harbor
   // this
@@ -102,6 +105,8 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   void UpdateRootViewInternal() noexcept;
   void ClearLoadingUI() noexcept;
   void EnsureLoadingUI() noexcept;
+  void HideDebuggerPausedOverlay() noexcept;
+  void ShowDebuggerPausedOverlay(const std::string &message, const std::function<void()> &onResume) noexcept;
   void ShowInstanceLoaded() noexcept;
   void ShowInstanceError() noexcept;
   void ShowInstanceWaiting() noexcept;
@@ -112,6 +117,7 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   bool OnBackRequested() noexcept;
   Mso::React::IReactViewHost *ReactViewHost() noexcept;
   void ReactViewHost(Mso::React::IReactViewHost *viewHost) noexcept;
+  void SetupDevToolsShortcut() noexcept;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Views/DevMenu.cpp

@@ -6,7 +6,7 @@
 #include "DevMenu.h"
 
 #include <winrt/Windows.ApplicationModel.DataTransfer.h>
-#include "HermesSamplingProfiler.h"
+#include "Hermes/HermesSamplingProfiler.h"
 #include "IReactDispatcher.h"
 #include "Modules/DevSettingsModule.h"
 

package/Microsoft.ReactNative.Cxx/JSI/decorator.h

@@ -112,6 +112,12 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_;
   }
 
+  #if JSI_VERSION >= 20
+  ICast* castInterface(const UUID& interfaceUUID) override {
+    return plain().castInterface(interfaceUUID);
+  }
+  #endif
+
   Value evaluateJavaScript(
       const std::shared_ptr<const Buffer>& buffer,
       const std::string& sourceURL) override {
@@ -423,6 +429,19 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_.callAsConstructor(f, args, count);
   };
 
+  #if JSI_VERSION >= 20
+  void setRuntimeDataImpl(
+      const UUID& uuid,
+      const void* data,
+      void (*deleter)(const void* data)) override {
+    return plain_.setRuntimeDataImpl(uuid, data, deleter);
+  }
+
+  const void* getRuntimeDataImpl(const UUID& uuid) override {
+    return plain_.getRuntimeDataImpl(uuid);
+  }
+  #endif
+
   // Private data for managing scopes.
   Runtime::ScopeState* pushScope() override {
     return plain_.pushScope();
@@ -620,6 +639,13 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
   // the derived class.
   WithRuntimeDecorator(Plain& plain, With& with) : RD(plain), with_(with) {}
 
+  #if JSI_VERSION >= 20
+  ICast* castInterface(const UUID& interfaceUUID) override {
+    Around around{with_};
+    return RD::castInterface(interfaceUUID);
+  }
+  #endif
+
   Value evaluateJavaScript(
       const std::shared_ptr<const Buffer>& buffer,
       const std::string& sourceURL) override {
@@ -1034,6 +1060,21 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
   };
 #endif
 
+  #if JSI_VERSION >= 20
+  void setRuntimeDataImpl(
+      const UUID& uuid,
+      const void* data,
+      void (*deleter)(const void* data)) override {
+    Around around{with_};
+    RD::setRuntimeDataImpl(uuid, data, deleter);
+  }
+
+  const void* getRuntimeDataImpl(const UUID& uuid) override {
+    Around around{with_};
+    return RD::getRuntimeDataImpl(uuid);
+  }
+  #endif
+
  private:
   // Wrap an RAII type around With& to guarantee after always happens.
   struct Around {

package/Microsoft.ReactNative.Cxx/JSI/jsi-inl.h

@@ -86,6 +86,22 @@ inline const Runtime::PointerValue* Runtime::getPointerValue(
   return value.data_.pointer.ptr_;
 }
 
+#if JSI_VERSION >= 20
+inline void Runtime::setRuntimeData(
+    const UUID& uuid,
+    const std::shared_ptr<void>& data) {
+  auto* dataPtr = new std::shared_ptr<void>(data);
+  setRuntimeDataImpl(uuid, dataPtr, [](const void* data) {
+    delete (const std::shared_ptr<void>*)data;
+  });
+}
+
+inline std::shared_ptr<void> Runtime::getRuntimeData(const UUID& uuid) {
+  auto* data = (const std::shared_ptr<void>*)getRuntimeDataImpl(uuid);
+  return data ? *data : nullptr;
+}
+#endif
+
 #if JSI_VERSION >= 17
 Value Object::getPrototype(Runtime& runtime) const {
   return runtime.getPrototypeOf(*this);

package/Microsoft.ReactNative.Cxx/JSI/jsi.cpp

@@ -8,6 +8,8 @@
 #include <cassert>
 #include <cmath>
 #include <cstdlib>
+#include <map>
+#include <mutex>
 #include <stdexcept>
 
 #include <jsi/instrumentation.h>
@@ -18,6 +20,65 @@ namespace jsi {
 
 namespace {
 
+#if JSI_VERSION >= 20
+/// A global map used to store custom runtime data for VMs that do not provide
+/// their own default implementation of setRuntimeData and getRuntimeData.
+struct RuntimeDataGlobal {
+  /// Mutex protecting the Runtime data map
+  std::mutex mutex_{};
+  /// Maps a runtime pointer to a map of its custom data. At destruction of the
+  /// runtime, its entry will be removed from the global map.
+  std::unordered_map<
+      Runtime*,
+      std::unordered_map<
+          UUID,
+          std::pair<const void*, void (*)(const void* data)>,
+          UUID::Hash>>
+      dataMap_;
+};
+
+RuntimeDataGlobal& getRuntimeDataGlobal() {
+  static RuntimeDataGlobal runtimeData{};
+  return runtimeData;
+}
+
+/// A host object that, when destructed, will remove the runtime's custom data
+/// entry from the global map of custom data.
+class RemoveRuntimeDataHostObject : public jsi::HostObject {
+ public:
+  explicit RemoveRuntimeDataHostObject(Runtime* runtime) : runtime_(runtime) {}
+
+  RemoveRuntimeDataHostObject(const RemoveRuntimeDataHostObject&) = default;
+  RemoveRuntimeDataHostObject(RemoveRuntimeDataHostObject&&) = default;
+  RemoveRuntimeDataHostObject& operator=(const RemoveRuntimeDataHostObject&) =
+      default;
+  RemoveRuntimeDataHostObject& operator=(RemoveRuntimeDataHostObject&&) =
+      default;
+
+  ~RemoveRuntimeDataHostObject() override {
+    auto& runtimeDataGlobal = getRuntimeDataGlobal();
+    std::lock_guard<std::mutex> lock(runtimeDataGlobal.mutex_);
+    auto runtimeMapIt = runtimeDataGlobal.dataMap_.find(runtime_);
+    // We install the RemoveRuntimeDataHostObject only when the first custom
+    // data for the runtime is added, and only this object is responsible for
+    // clearing runtime data. Thus, we should always be able to find the data
+    // entry.
+    assert(
+        runtimeMapIt != runtimeDataGlobal.dataMap_.end() &&
+        "Custom runtime data not found for this runtime");
+
+    for (auto [_, entry] : runtimeMapIt->second) {
+      auto* deleter = entry.second;
+      deleter(entry.first);
+    }
+    runtimeDataGlobal.dataMap_.erase(runtime_);
+  }
+
+ private:
+  Runtime* runtime_;
+};
+#endif
+
 // This is used for generating short exception strings.
 std::string kindToString(const Value& v, Runtime* rt = nullptr) {
   if (v.isUndefined()) {
@@ -237,6 +298,12 @@ NativeState::~NativeState() {}
 
 Runtime::~Runtime() {}
 
+#if JSI_VERSION >= 20
+ICast* Runtime::castInterface(const UUID& /*interfaceUUID*/) {
+  return nullptr;
+}
+#endif
+
 Instrumentation& Runtime::instrumentation() {
   class NoInstrumentation : public Instrumentation {
     std::string getRecordedGCStats() override {
@@ -398,6 +465,64 @@ Object Runtime::createObjectWithPrototype(const Value& prototype) {
 }
 #endif
 
+#if JSI_VERSION >= 20
+void Runtime::setRuntimeDataImpl(
+    const UUID& uuid,
+    const void* data,
+    void (*deleter)(const void* data)) {
+  auto& runtimeDataGlobal = getRuntimeDataGlobal();
+  std::lock_guard<std::mutex> lock(runtimeDataGlobal.mutex_);
+  if (auto it = runtimeDataGlobal.dataMap_.find(this);
+      it != runtimeDataGlobal.dataMap_.end()) {
+    auto& map = it->second;
+    if (auto entryIt = map.find(uuid); entryIt != map.end()) {
+      // Free the old data
+      auto oldData = entryIt->second.first;
+      auto oldDataDeleter = entryIt->second.second;
+      oldDataDeleter(oldData);
+    }
+    map[uuid] = {data, deleter};
+    return;
+  }
+  // No custom data entry exist for this runtime in the global map, so create
+  // one.
+  runtimeDataGlobal.dataMap_[this][uuid] = {data, deleter};
+
+  // The first time data is added for this runtime is added to the map, install
+  // a host object on the global object of the runtime. This host object is used
+  // to release the runtime's entry from the global custom data map when the
+  // runtime is destroyed.
+  // Also, try to protect the host object by making it non-configurable,
+  // non-enumerable, and non-writable. These JSI operations are purposely
+  // performed after runtime-specific data map is added and the host object is
+  // created to prevent data leaks if any operations fail.
+  Object ho = Object::createFromHostObject(
+      *this, std::make_shared<RemoveRuntimeDataHostObject>(this));
+  global().setProperty(*this, "_jsiRuntimeDataCleanUp", ho);
+  auto definePropertyFn = global()
+                              .getPropertyAsObject(*this, "Object")
+                              .getPropertyAsFunction(*this, "defineProperty");
+  auto desc = Object(*this);
+  desc.setProperty(*this, "configurable", Value(false));
+  desc.setProperty(*this, "enumerable", Value(false));
+  desc.setProperty(*this, "writable", Value(false));
+  definePropertyFn.call(*this, global(), "_jsiRuntimeDataCleanUp", desc);
+}
+
+const void* Runtime::getRuntimeDataImpl(const UUID& uuid) {
+  auto& runtimeDataGlobal = getRuntimeDataGlobal();
+  std::lock_guard<std::mutex> lock(runtimeDataGlobal.mutex_);
+  if (auto runtimeMapIt = runtimeDataGlobal.dataMap_.find(this);
+      runtimeMapIt != runtimeDataGlobal.dataMap_.end()) {
+    if (auto customDataIt = runtimeMapIt->second.find(uuid);
+        customDataIt != runtimeMapIt->second.end()) {
+      return customDataIt->second.first;
+    }
+  }
+  return nullptr;
+}
+#endif
+
 Pointer& Pointer::operator=(Pointer&& other) JSI_NOEXCEPT_15 {
   if (ptr_) {
     ptr_->invalidate();