react-native-windows 0.71.25 → 0.71.27

package/Shared/DevSupportManager.cpp

@@ -21,8 +21,10 @@
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
 
+#ifdef HERMES_ENABLE_DEBUGGER
 #include <winrt/Windows.ApplicationModel.Activation.h>
 #include <winrt/Windows.Networking.Connectivity.h>
+#endif
 
 #pragma warning(push)
 #pragma warning(disable : 4068 4251 4101 4804 4309)
@@ -241,6 +243,7 @@ void DevSupportManager::StopPollingLiveReload() {
 void DevSupportManager::EnsureHermesInspector(
     [[maybe_unused]] const std::string &packagerHost,
     [[maybe_unused]] const uint16_t packagerPort) noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
   static std::once_flag once;
   std::call_once(once, [this, &packagerHost, packagerPort]() {
     // TODO: should we use the bundleAppId as the app param if available?
@@ -263,10 +266,14 @@ void DevSupportManager::EnsureHermesInspector(
         m_BundleStatusProvider);
     m_inspectorPackagerConnection->connectAsync();
   });
+
+#endif
 }
 
-void DevSupportManager::UpdateBundleStatus(bool isLastDownloadSuccess, int64_t updateTimestamp) noexcept {
-  m_BundleStatusProvider->updateBundleStatus(isLastDownloadSuccess, updateTimestamp);
+void DevSupportManager::UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
+  m_BundleStatusProvider->updateBundleStatus(isLastDownloadSucess, updateTimestamp);
+#endif
 }
 
 std::pair<std::string, bool> GetJavaScriptFromServer(

package/Shared/DevSupportManager.h

@@ -14,7 +14,9 @@
 #include <memory>
 #include <string>
 
+#if defined(HERMES_ENABLE_DEBUGGER)
 #include <InspectorPackagerConnection.h>
+#endif
 
 namespace facebook {
 namespace react {
@@ -55,6 +57,7 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
  private:
   std::atomic_bool m_cancellation_token;
 
+#if defined(HERMES_ENABLE_DEBUGGER)
   std::shared_ptr<InspectorPackagerConnection> m_inspectorPackagerConnection;
 
   struct BundleStatusProvider : public InspectorPackagerConnection::IBundleStatusProvider {
@@ -62,8 +65,8 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
       return m_bundleStatus;
     }
 
-    void updateBundleStatus(bool isLastDownloadSuccess, int64_t updateTimestamp) {
-      m_bundleStatus.m_isLastDownloadSuccess = isLastDownloadSuccess;
+    void updateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) {
+      m_bundleStatus.m_isLastDownloadSucess = isLastDownloadSucess;
       m_bundleStatus.m_updateTimestamp = updateTimestamp;
     }
 
@@ -71,6 +74,7 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
     InspectorPackagerConnection::BundleStatus m_bundleStatus;
   };
   std::shared_ptr<BundleStatusProvider> m_BundleStatusProvider = std::make_shared<BundleStatusProvider>();
+#endif
 };
 
 } // namespace Microsoft::ReactNative

package/Shared/HermesRuntimeHolder.cpp

@@ -3,394 +3,134 @@
 
 #include "pch.h"
 
-#include "HermesRuntimeHolder.h"
+#include <memory>
+#include <mutex>
 
-#include <ApiLoaders/HermesApi.h>
 #include <JSI/decorator.h>
-#include <NodeApiJsiRuntime.h>
-#include <crash/verifyElseCrash.h>
+#include <cxxreact/MessageQueueThread.h>
 #include <cxxreact/SystraceSection.h>
-#include <jsinspector/InspectorInterfaces.h>
-#include <mutex>
-#include "SafeLoadLibrary.h"
-
-#define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
+#include <hermes/hermes.h>
+#include "HermesRuntimeHolder.h"
+#include "HermesShim.h"
 
-namespace React {
-using namespace winrt::Microsoft::ReactNative;
-}
+#if defined(HERMES_ENABLE_DEBUGGER)
+#include <hermes/inspector/chrome/Registration.h>
+#endif
 
-using namespace Microsoft::NodeApiJsi;
+using namespace facebook;
+using namespace Microsoft::ReactNative;
 
-namespace Microsoft::ReactNative {
-
-React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>>
-HermesRuntimeHolderProperty() noexcept {
-  static React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>> propId{
-      L"ReactNative.HermesRuntimeHolder", L"HermesRuntimeHolder"};
-  return propId;
-}
+namespace facebook {
+namespace react {
 
 namespace {
 
-int32_t NAPI_CDECL addInspectorPage(const char *title, const char *vm, void *connectFunc) noexcept;
-void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept;
-
-class HermesFuncResolver : public IFuncResolver {
- public:
-  HermesFuncResolver() : libHandle_(SafeLoadLibrary(L"hermes.dll")) {}
-
-  FuncPtr getFuncPtr(const char *funcName) override {
-    return reinterpret_cast<FuncPtr>(GetProcAddress(libHandle_, funcName));
+std::unique_ptr<facebook::hermes::HermesRuntime> makeHermesRuntimeSystraced(bool enableDefaultCrashHandler) {
+  SystraceSection s("HermesExecutorFactory::makeHermesRuntimeSystraced");
+  if (enableDefaultCrashHandler) {
+    return HermesShim::makeHermesRuntimeWithWER();
+  } else {
+    auto runtimeConfig = ::hermes::vm::RuntimeConfig();
+    return HermesShim::makeHermesRuntime(runtimeConfig);
   }
-
- private:
-  HMODULE libHandle_;
-};
-
-HermesApi &initHermesApi() noexcept {
-  static HermesFuncResolver funcResolver;
-  static HermesApi s_hermesApi(&funcResolver);
-  HermesApi::setCurrent(&s_hermesApi);
-  CRASH_ON_ERROR(s_hermesApi.hermes_set_inspector(&addInspectorPage, &removeInspectorPage));
-  return s_hermesApi;
-}
-
-HermesApi &getHermesApi() noexcept {
-  static HermesApi &s_hermesApi = initHermesApi();
-  return s_hermesApi;
 }
 
-class HermesTask {
- public:
-  HermesTask(
-      void *taskData,
-      jsr_task_run_cb taskRunCallback,
-      jsr_data_delete_cb taskDataDeleteCallback,
-      void *deleterData)
-      : taskData_(taskData),
-        taskRunCallback_(taskRunCallback),
-        taskDataDeleteCallback_(taskDataDeleteCallback),
-        deleterData_(deleterData) {}
-
-  HermesTask(const HermesTask &other) = delete;
-  HermesTask &operator=(const HermesTask &other) = delete;
-
-  ~HermesTask() {
-    if (taskDataDeleteCallback_ != nullptr) {
-      taskDataDeleteCallback_(taskData_, deleterData_);
-    }
-  }
-
-  void Run() const {
-    if (taskRunCallback_ != nullptr) {
-      taskRunCallback_(taskData_);
-    }
-  }
-
- private:
-  void *taskData_;
-  jsr_task_run_cb taskRunCallback_;
-  jsr_data_delete_cb taskDataDeleteCallback_;
-  void *deleterData_;
-};
-
-class HermesTaskRunner {
- public:
-  static void Create(jsr_config config, std::shared_ptr<facebook::react::MessageQueueThread> queue) {
-    CRASH_ON_ERROR(getHermesApi().jsr_config_set_task_runner(
-        config, new HermesTaskRunner(std::move(queue)), &PostTask, &Delete, nullptr));
-  }
-
- private:
-  HermesTaskRunner(std::shared_ptr<facebook::react::MessageQueueThread> queue) : queue_(std::move(queue)) {}
-
-  static void NAPI_CDECL PostTask(
-      void *taskRunnerData,
-      void *taskData,
-      jsr_task_run_cb taskRunCallback,
-      jsr_data_delete_cb taskDataDeleteCallback,
-      void *deleterData) {
-    auto task = std::make_shared<HermesTask>(taskData, taskRunCallback, taskDataDeleteCallback, deleterData);
-    reinterpret_cast<HermesTaskRunner *>(taskRunnerData)->queue_->runOnQueue([task = std::move(task)] { task->Run(); });
-  }
-
-  static void NAPI_CDECL Delete(void *taskRunner, void * /*deleterData*/) {
-    delete reinterpret_cast<HermesTaskRunner *>(taskRunner);
-  }
-
- private:
-  std::shared_ptr<facebook::react::MessageQueueThread> queue_;
-};
-
-struct HermesJsiBuffer : facebook::jsi::Buffer {
-  static std::shared_ptr<const facebook::jsi::Buffer>
-  Create(const uint8_t *buffer, size_t bufferSize, jsr_data_delete_cb bufferDeleteCallback, void *deleterData) {
-    return std::shared_ptr<const facebook::jsi::Buffer>(
-        new HermesJsiBuffer(buffer, bufferSize, bufferDeleteCallback, deleterData));
-  }
-
-  HermesJsiBuffer(
-      const uint8_t *buffer,
-      size_t bufferSize,
-      jsr_data_delete_cb bufferDeleteCallback,
-      void *deleterData) noexcept
-      : buffer_(buffer),
-        bufferSize_(bufferSize),
-        bufferDeleteCallback_(bufferDeleteCallback),
-        deleterData_(deleterData) {}
-
-  ~HermesJsiBuffer() override {
-    if (bufferDeleteCallback_) {
-      bufferDeleteCallback_(const_cast<uint8_t *>(buffer_), deleterData_);
-    }
-  }
-
-  const uint8_t *data() const override {
-    return buffer_;
-  }
-
-  size_t size() const override {
-    return bufferSize_;
-  }
-
- private:
-  const uint8_t *buffer_;
-  size_t bufferSize_;
-  jsr_data_delete_cb bufferDeleteCallback_;
-  void *deleterData_;
-};
-
-class HermesScriptCache {
+#ifdef HERMES_ENABLE_DEBUGGER
+class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::RuntimeAdapter {
  public:
-  static void Create(jsr_config config, std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore) {
-    CRASH_ON_ERROR(getHermesApi().jsr_config_set_script_cache(
-        config, new HermesScriptCache(std::move(scriptStore)), &LoadScript, &StoreScript, &Delete, nullptr));
-  }
+  HermesExecutorRuntimeAdapter(
+      std::shared_ptr<jsi::Runtime> runtime,
+      facebook::hermes::HermesRuntime &hermesRuntime,
+      std::shared_ptr<MessageQueueThread> thread)
+      : m_runtime(runtime), m_hermesRuntime(hermesRuntime), m_thread(std::move(thread)) {}
 
- private:
-  HermesScriptCache(std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore)
-      : scriptStore_(std::move(scriptStore)) {}
-
-  static void NAPI_CDECL LoadScript(
-      void *scriptCache,
-      const char *sourceUrl,
-      uint64_t sourceHash,
-      const char *runtimeName,
-      uint64_t runtimeVersion,
-      const char *cacheTag,
-      const uint8_t **buffer,
-      size_t *bufferSize,
-      jsr_data_delete_cb *bufferDeleteCallback,
-      void **deleterData) {
-    auto &scriptStore = reinterpret_cast<HermesScriptCache *>(scriptCache)->scriptStore_;
-    std::shared_ptr<const facebook::jsi::Buffer> preparedScript = scriptStore->tryGetPreparedScript(
-        facebook::jsi::ScriptSignature{sourceUrl, sourceHash},
-        facebook::jsi::JSRuntimeSignature{runtimeName, runtimeVersion},
-        cacheTag);
-    if (preparedScript) {
-      *buffer = preparedScript->data();
-      *bufferSize = preparedScript->size();
-      *bufferDeleteCallback = [](void * /*data*/, void *deleterData) noexcept {
-        delete reinterpret_cast<std::shared_ptr<const facebook::jsi::Buffer> *>(deleterData);
-      };
-      *deleterData = new std::shared_ptr<const facebook::jsi::Buffer>(std::move(preparedScript));
-    } else {
-      *buffer = nullptr;
-      *bufferSize = 0;
-      *bufferDeleteCallback = nullptr;
-      *deleterData = nullptr;
-    }
-  }
-
-  static void NAPI_CDECL StoreScript(
-      void *scriptCache,
-      const char *sourceUrl,
-      uint64_t sourceHash,
-      const char *runtimeName,
-      uint64_t runtimeVersion,
-      const char *cacheTag,
-      const uint8_t *buffer,
-      size_t bufferSize,
-      jsr_data_delete_cb bufferDeleteCallback,
-      void *deleterData) {
-    auto &scriptStore = reinterpret_cast<HermesScriptCache *>(scriptCache)->scriptStore_;
-    scriptStore->persistPreparedScript(
-        HermesJsiBuffer::Create(buffer, bufferSize, bufferDeleteCallback, deleterData),
-        facebook::jsi::ScriptSignature{sourceUrl, sourceHash},
-        facebook::jsi::JSRuntimeSignature{runtimeName, runtimeVersion},
-        cacheTag);
-  }
-
-  static void NAPI_CDECL Delete(void *scriptCache, void * /*deleterData*/) {
-    delete reinterpret_cast<HermesScriptCache *>(scriptCache);
-  }
-
- private:
-  std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore_;
-};
-
-class HermesLocalConnection : public facebook::react::ILocalConnection {
- public:
-  HermesLocalConnection(
-      std::unique_ptr<facebook::react::IRemoteConnection> remoteConneciton,
-      void *connectFunc) noexcept {
-    CRASH_ON_ERROR(getHermesApi().hermes_create_local_connection(
-        connectFunc,
-        reinterpret_cast<hermes_remote_connection>(remoteConneciton.release()),
-        &OnRemoteConnectionSendMessage,
-        &OnRemoteConnectionDisconnect,
-        &OnRemoteConnectionDelete,
-        nullptr,
-        &localConnection_));
-  }
+  virtual ~HermesExecutorRuntimeAdapter() = default;
 
-  ~HermesLocalConnection() override {
-    CRASH_ON_ERROR(getHermesApi().hermes_delete_local_connection(localConnection_));
+  jsi::Runtime &getRuntime() override {
+    return *m_runtime;
   }
 
-  void sendMessage(std::string message) {
-    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_send_message(localConnection_, message.c_str()));
+  facebook::hermes::debugger::Debugger &getDebugger() override {
+    return m_hermesRuntime.getDebugger();
   }
 
-  void disconnect() {
-    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_disconnect(localConnection_));
+  void tickleJs() override {
+    // The queue will ensure that runtime_ is still valid when this
+    // gets invoked.
+    m_thread->runOnQueue([&runtime = m_runtime]() {
+      auto func = runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
+      func.call(*runtime);
+    });
   }
 
  private:
-  static void NAPI_CDECL OnRemoteConnectionSendMessage(hermes_remote_connection remoteConnection, const char *message) {
-    reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection)->onMessage(message);
-  }
-
-  static void NAPI_CDECL OnRemoteConnectionDisconnect(hermes_remote_connection remoteConnection) {
-    reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection)->onDisconnect();
-  }
+  std::shared_ptr<jsi::Runtime> m_runtime;
+  facebook::hermes::HermesRuntime &m_hermesRuntime;
 
-  static void NAPI_CDECL OnRemoteConnectionDelete(void *remoteConnection, void * /*deleterData*/) {
-    delete reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection);
-  }
-
- private:
-  hermes_local_connection localConnection_{};
+  std::shared_ptr<MessageQueueThread> m_thread;
 };
-
-int32_t NAPI_CDECL addInspectorPage(const char *title, const char *vm, void *connectFunc) noexcept {
-  return facebook::react::getInspectorInstance().addPage(
-      title,
-      vm,
-      [connectFunc,
-       hermesApi = HermesApi::current()](std::unique_ptr<facebook::react::IRemoteConnection> remoteConneciton) {
-        HermesApi::Scope apiScope(hermesApi);
-        return std::make_unique<HermesLocalConnection>(std::move(remoteConneciton), connectFunc);
-      });
-}
-
-void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept {
-  facebook::react::getInspectorInstance().removePage(pageId);
-}
+#endif
 
 } // namespace
 
-HermesRuntimeHolder::HermesRuntimeHolder(
-    std::shared_ptr<facebook::react::DevSettings> devSettings,
-    std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
-    std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore) noexcept
-    : m_weakDevSettings(devSettings),
-      m_jsQueue(std::move(jsQueue)),
-      m_preparedScriptStore(std::move(preparedScriptStore)) {}
-
-HermesRuntimeHolder::~HermesRuntimeHolder() {
-  if (m_runtime) {
-    CRASH_ON_ERROR(getHermesApi().jsr_delete_runtime(m_runtime));
-  }
+void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
+  HermesShim::hermesCrashHandler(*m_hermesRuntime, fileDescriptor);
 }
 
-void HermesRuntimeHolder::initRuntime() noexcept {
-  facebook::react::SystraceSection s("HermesExecutorFactory::makeHermesRuntimeSystraced");
-  std::shared_ptr<facebook::react::DevSettings> devSettings = m_weakDevSettings.lock();
-  VerifyElseCrash(devSettings);
-
-  HermesApi &api = getHermesApi();
-  HermesApi::setCurrent(&api);
-  jsr_config config{};
-  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_inspector_runtime_name(config, devSettings->debuggerRuntimeName.c_str()));
-  CRASH_ON_ERROR(api.jsr_config_set_inspector_port(config, devSettings->debuggerPort));
-  CRASH_ON_ERROR(api.jsr_config_set_inspector_break_on_start(config, devSettings->debuggerBreakOnNextLine));
-  if (m_jsQueue) {
-    HermesTaskRunner::Create(config, m_jsQueue);
-  }
-  if (m_preparedScriptStore) {
-    HermesScriptCache::Create(config, m_preparedScriptStore);
+void HermesRuntimeHolder::teardown() noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
+  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
+    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
   }
-  jsr_runtime runtime{};
-  CRASH_ON_ERROR(api.jsr_create_runtime(config, &runtime));
-  CRASH_ON_ERROR(api.jsr_delete_config(config));
-
-  napi_env env{};
-  CRASH_ON_ERROR(api.jsr_runtime_get_node_api_env(runtime, &env));
-
-  m_jsiRuntime = makeNodeApiJsiRuntime(
-      env, &api, [runtime]() { CRASH_ON_ERROR(HermesApi::current()->jsr_delete_runtime(runtime)); });
-  m_ownThreadId = std::this_thread::get_id();
-
-  // Add JS engine information to Error.prototype so in error reporting we
-  // can send this information.
-  auto errorPrototype = m_jsiRuntime->global()
-                            .getPropertyAsObject(*m_jsiRuntime, "Error")
-                            .getPropertyAsObject(*m_jsiRuntime, "prototype");
-  errorPrototype.setProperty(*m_jsiRuntime, "jsEngine", "hermes");
+#endif
 }
 
 facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
   return facebook::react::JSIEngineOverride::Hermes;
 }
 
-std::shared_ptr<facebook::jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
-  std::call_once(m_onceFlag, [this]() { initRuntime(); });
-  VerifyElseCrash(m_jsiRuntime);
-  return m_jsiRuntime;
-}
-
-void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_dump_crash_data(m_runtime, fileDescriptor));
-}
+std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
+  std::call_once(m_once_flag, [this]() { initRuntime(); });
 
-void HermesRuntimeHolder::teardown() noexcept {
-  // TODO: (vmoroz) Implement
-}
+  if (!m_hermesRuntime)
+    std::terminate();
 
-std::shared_ptr<HermesRuntimeHolder> HermesRuntimeHolder::loadFrom(
-    React::ReactPropertyBag const &propertyBag) noexcept {
-  return *(propertyBag.Get(HermesRuntimeHolderProperty()));
-}
+  // Make sure that the runtime instance is not consumed from multiple threads.
+  if (m_own_thread_id != std::this_thread::get_id())
+    std::terminate();
 
-void HermesRuntimeHolder::storeTo(
-    React::ReactPropertyBag const &propertyBag,
-    std::shared_ptr<HermesRuntimeHolder> const &holder) noexcept {
-  propertyBag.Set(HermesRuntimeHolderProperty(), holder);
+  return m_hermesRuntime;
 }
 
-void HermesRuntimeHolder::addToProfiling() const noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_add(m_runtime));
-}
+HermesRuntimeHolder::HermesRuntimeHolder(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept
+    : m_weakDevSettings(devSettings), m_jsQueue(std::move(jsQueue)) {}
 
-void HermesRuntimeHolder::removeFromProfiling() const noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_remove(m_runtime));
-}
+void HermesRuntimeHolder::initRuntime() noexcept {
+  auto devSettings = m_weakDevSettings.lock();
+  if (!devSettings)
+    std::terminate();
 
-/*static*/ void HermesRuntimeHolder::enableSamplingProfiler() noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_enable());
-}
+  m_hermesRuntime = makeHermesRuntimeSystraced(devSettings->enableDefaultCrashHandler);
+  m_own_thread_id = std::this_thread::get_id();
 
-/*static*/ void HermesRuntimeHolder::disableSamplingProfiler() noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_disable());
-}
+#ifdef HERMES_ENABLE_DEBUGGER
+  if (devSettings->useDirectDebugger) {
+    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_hermesRuntime, *m_hermesRuntime, m_jsQueue);
+    facebook::hermes::inspector::chrome::enableDebugging(
+        std::move(adapter),
+        devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : devSettings->debuggerRuntimeName);
+  }
+#endif
 
-/*static*/ void HermesRuntimeHolder::dumpSampledTraceToFile(const std::string &fileName) noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_dump_to_file(fileName.c_str()));
+  // Add js engine information to Error.prototype so in error reporting we
+  // can send this information.
+  auto errorPrototype = m_hermesRuntime->global()
+                            .getPropertyAsObject(*m_hermesRuntime, "Error")
+                            .getPropertyAsObject(*m_hermesRuntime, "prototype");
+  errorPrototype.setProperty(*m_hermesRuntime, "jsEngine", "hermes");
 }
 
-} // namespace Microsoft::ReactNative
+} // namespace react
+} // namespace facebook

package/Shared/HermesRuntimeHolder.h

@@ -2,54 +2,43 @@
 // Licensed under the MIT License.
 
 #pragma once
-#include <DevSettings.h>
 #include <JSI/RuntimeHolder.h>
-#include <JSI/ScriptStore.h>
-#include <ReactPropertyBag.h>
-#include <cxxreact/MessageQueueThread.h>
-#include <hermes/hermes_api.h>
 
-namespace Microsoft::ReactNative {
+#include <jsi/jsi.h>
+#include <thread>
+
+#include <DevSettings.h>
+
+namespace facebook::hermes {
+class HermesRuntime;
+}
+
+namespace facebook {
+namespace react {
 
 class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
- public: // RuntimeHolderLazyInit implementation.
+ public:
   std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
   facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
+
   void crashHandler(int fileDescriptor) noexcept override;
+
   void teardown() noexcept override;
 
- public:
   HermesRuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,
-      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
-      std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore) noexcept;
-  ~HermesRuntimeHolder();
-
-  static std::shared_ptr<HermesRuntimeHolder> loadFrom(
-      winrt::Microsoft::ReactNative::ReactPropertyBag const &propertyBag) noexcept;
-
-  static void storeTo(
-      winrt::Microsoft::ReactNative::ReactPropertyBag const &propertyBag,
-      std::shared_ptr<HermesRuntimeHolder> const &holder) noexcept;
-
-  void addToProfiling() const noexcept;
-  void removeFromProfiling() const noexcept;
-
-  static void enableSamplingProfiler() noexcept;
-  static void disableSamplingProfiler() noexcept;
-  static void dumpSampledTraceToFile(const std::string &fileName) noexcept;
+      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept;
 
  private:
   void initRuntime() noexcept;
+  std::shared_ptr<facebook::hermes::HermesRuntime> m_hermesRuntime;
+
+  std::once_flag m_once_flag;
+  std::thread::id m_own_thread_id;
 
- private:
-  jsr_runtime m_runtime{};
-  std::shared_ptr<facebook::jsi::Runtime> m_jsiRuntime;
-  std::once_flag m_onceFlag{};
-  std::thread::id m_ownThreadId{};
   std::weak_ptr<facebook::react::DevSettings> m_weakDevSettings;
   std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
-  std::shared_ptr<facebook::jsi::PreparedScriptStore> m_preparedScriptStore;
 };
 
-} // namespace Microsoft::ReactNative
+} // namespace react
+} // namespace facebook