react-native-windows 0.72.0-preview.7 → 0.72.0-preview.9

package/Shared/InspectorPackagerConnection.cpp

@@ -3,18 +3,10 @@
 
 #include "pch.h"
 
-#ifdef HERMES_ENABLE_DEBUGGER
-
 #include <folly/json.h>
 #include <tracing/tracing.h>
 #include "InspectorPackagerConnection.h"
 
-namespace facebook {
-namespace react {
-IDestructible::~IDestructible() {}
-} // namespace react
-} // namespace facebook
-
 namespace Microsoft::ReactNative {
 
 namespace {
@@ -80,35 +72,16 @@ struct InspectorProtocol {
   }
 
   static folly::dynamic constructGetPagesResponsePayloadForPackager(
-      const std::vector<facebook::react::InspectorPage2> &pages,
-      InspectorPackagerConnection::BundleStatus bundleStatus) {
-    folly::dynamic payload = folly::dynamic::array;
-    for (const facebook::react::InspectorPage2 &page : pages) {
-      folly::dynamic pageDyn = folly::dynamic::object;
-      pageDyn["id"] = page.id;
-      pageDyn["title"] = page.title;
-      pageDyn["vm"] = page.vm;
-
-      pageDyn["isLastBundleDownloadSuccess"] = bundleStatus.m_isLastDownloadSucess;
-      pageDyn["bundleUpdateTimestamp"] = bundleStatus.m_updateTimestamp;
-
-      payload.push_back(pageDyn);
-    }
-    return payload;
-  }
-
-  static folly::dynamic constructGetPagesResponsePayloadForPackager(
-      std::unique_ptr<facebook::react::IInspectorPages> pages,
+      const std::vector<facebook::react::InspectorPage> &pages,
       InspectorPackagerConnection::BundleStatus bundleStatus) {
     folly::dynamic payload = folly::dynamic::array;
-    for (int p = 0; p < pages->size(); p++) {
-      const facebook::react::InspectorPage2 page = pages->getPage(p);
+    for (const facebook::react::InspectorPage &page : pages) {
       folly::dynamic pageDyn = folly::dynamic::object;
       pageDyn["id"] = page.id;
       pageDyn["title"] = page.title;
       pageDyn["vm"] = page.vm;
 
-      pageDyn["isLastBundleDownloadSuccess"] = bundleStatus.m_isLastDownloadSucess;
+      pageDyn["isLastBundleDownloadSuccess"] = bundleStatus.m_isLastDownloadSuccess;
       pageDyn["bundleUpdateTimestamp"] = bundleStatus.m_updateTimestamp;
 
       payload.push_back(pageDyn);
@@ -116,14 +89,14 @@ struct InspectorProtocol {
     return payload;
   }
 
-  static folly::dynamic constructVMResponsePayloadForPackager(int64_t pageId, std::string &&messageFromVM) {
+  static folly::dynamic constructVMResponsePayloadForPackager(int32_t pageId, std::string &&messageFromVM) {
     folly::dynamic payload = folly::dynamic::object;
     payload[InspectorProtocol::Message_eventName_wrappedEvent] = messageFromVM;
     payload[InspectorProtocol::Message_PAGEID] = pageId;
     return payload;
   }
 
-  static folly::dynamic constructVMResponsePayloadOnDisconnectForPackager(int64_t pageId) {
+  static folly::dynamic constructVMResponsePayloadOnDisconnectForPackager(int32_t pageId) {
     folly::dynamic payload = folly::dynamic::object;
     payload[InspectorProtocol::Message_PAGEID] = pageId;
     return payload;
@@ -132,7 +105,7 @@ struct InspectorProtocol {
 
 } // namespace
 
-RemoteConnection::RemoteConnection(int64_t pageId, const InspectorPackagerConnection &packagerConnection)
+RemoteConnection::RemoteConnection(int32_t pageId, const InspectorPackagerConnection &packagerConnection)
     : m_packagerConnection(packagerConnection), m_pageId(pageId) {}
 
 void RemoteConnection::onMessage(std::string message) {
@@ -152,26 +125,6 @@ void RemoteConnection::onDisconnect() {
   m_packagerConnection.sendMessageToPackager(std::move(responsestr));
 }
 
-RemoteConnection2::RemoteConnection2(int64_t pageId, const InspectorPackagerConnection &packagerConnection)
-    : m_packagerConnection(packagerConnection), m_pageId(pageId) {}
-
-void RemoteConnection2::onMessage(std::string message) {
-  folly::dynamic response = InspectorProtocol::constructResponseForPackager(
-      InspectorProtocol::EventType::WrappedEvent,
-      InspectorProtocol::constructVMResponsePayloadForPackager(m_pageId, std::move(message)));
-  std::string responsestr = folly::toJson(response);
-  m_packagerConnection.sendMessageToPackager(std::move(responsestr));
-}
-
-void RemoteConnection2::onDisconnect() {
-  folly::dynamic response = InspectorProtocol::constructResponseForPackager(
-      InspectorProtocol::EventType::Disconnect,
-      InspectorProtocol::constructVMResponsePayloadOnDisconnectForPackager(m_pageId));
-
-  std::string responsestr = folly::toJson(response);
-  m_packagerConnection.sendMessageToPackager(std::move(responsestr));
-}
-
 winrt::fire_and_forget InspectorPackagerConnection::sendMessageToPackagerAsync(std::string &&message) const {
   std::string message_(std::move(message));
   co_await winrt::resume_background();
@@ -183,7 +136,7 @@ void InspectorPackagerConnection::sendMessageToPackager(std::string &&message) c
   sendMessageToPackagerAsync(std::move(message));
 }
 
-void InspectorPackagerConnection::sendMessageToVM(int64_t pageId, std::string &&message) {
+void InspectorPackagerConnection::sendMessageToVM(int32_t pageId, std::string &&message) {
   m_localConnections[pageId]->sendMessage(std::move(message));
 }
 
@@ -214,59 +167,62 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
   m_packagerWebSocketConnection->SetOnConnect(
       []() { facebook::react::tracing::log("Inspector: Websocket connection succeeded."); });
 
-  m_packagerWebSocketConnection->SetOnMessage(
-      [self = shared_from_this()](size_t /*length*/, const std::string &message, bool isBinary) {
-        assert(!isBinary && "We don't expect any binary messages !");
-        folly::dynamic messageDyn = folly::parseJson(message);
-
-        InspectorProtocol::EventType eventType = InspectorProtocol::getEventType(messageDyn);
-        switch (eventType) {
-          case InspectorProtocol::EventType::GetPages: {
-            std::unique_ptr<facebook::react::IInspectorPages> inspectorPages = facebook::react::getInspectorPages();
-            folly::dynamic response = InspectorProtocol::constructResponseForPackager(
-                InspectorProtocol::EventType::GetPages,
-                InspectorProtocol::constructGetPagesResponsePayloadForPackager(
-                    std::move(inspectorPages), self->m_bundleStatusProvider->getBundleStatus()));
-
-            std::string responsestr = folly::toJson(response);
-            self->sendMessageToPackager(std::move(responsestr));
-          } break;
-
-          case InspectorProtocol::EventType::WrappedEvent: {
-            folly::dynamic payload = messageDyn[InspectorProtocol::Message_PAYLOAD];
-            int64_t pageId = payload[InspectorProtocol::Message_PAGEID].asInt();
-
-            if (self->m_localConnections.find(pageId) == self->m_localConnections.end()) {
-              break;
-            }
-
-            std::string wrappedEvent = payload[InspectorProtocol::Message_eventName_wrappedEvent].getString();
-            self->sendMessageToVM(pageId, std::move(wrappedEvent));
-          } break;
-
-          case InspectorProtocol::EventType::Connect: {
-            folly::dynamic payload = messageDyn[InspectorProtocol::Message_PAYLOAD];
-            int64_t pageId = payload[InspectorProtocol::Message_PAGEID].asInt();
-
-            if (self->m_localConnections.find(pageId) != self->m_localConnections.end()) {
-              break;
-            }
-
-            self->m_localConnections[pageId] = facebook::react::connectInspectorPage(
-                static_cast<int>(pageId), std::make_unique<RemoteConnection2>(pageId, *self));
-          } break;
-
-          case InspectorProtocol::EventType::Disconnect: {
-            folly::dynamic payload = messageDyn[InspectorProtocol::Message_PAYLOAD];
-            int64_t pageId = payload[InspectorProtocol::Message_PAGEID].asInt();
-            if (self->m_localConnections.find(pageId) != self->m_localConnections.end()) {
-              self->m_localConnections[pageId]->disconnect();
-              self->m_localConnections.erase(pageId);
-            }
-
-          } break;
+  m_packagerWebSocketConnection->SetOnMessage([self = shared_from_this()](
+                                                  size_t /*length*/, const std::string &message, bool isBinary) {
+    assert(!isBinary && "We don't expect any binary messages !");
+    folly::dynamic messageDyn = folly::parseJson(message);
+
+    InspectorProtocol::EventType eventType = InspectorProtocol::getEventType(messageDyn);
+    switch (eventType) {
+      case InspectorProtocol::EventType::GetPages: {
+        std::vector<facebook::react::InspectorPage> inspectorPages = facebook::react::getInspectorInstance().getPages();
+        folly::dynamic response = InspectorProtocol::constructResponseForPackager(
+            InspectorProtocol::EventType::GetPages,
+            InspectorProtocol::constructGetPagesResponsePayloadForPackager(
+                inspectorPages, self->m_bundleStatusProvider->getBundleStatus()));
+
+        std::string responsestr = folly::toJson(response);
+        self->sendMessageToPackager(std::move(responsestr));
+        break;
+      }
+
+      case InspectorProtocol::EventType::WrappedEvent: {
+        folly::dynamic payload = messageDyn[InspectorProtocol::Message_PAYLOAD];
+        int32_t pageId = static_cast<int32_t>(payload[InspectorProtocol::Message_PAGEID].asInt());
+
+        if (self->m_localConnections.find(pageId) == self->m_localConnections.end()) {
+          break;
         }
-      });
+
+        std::string wrappedEvent = payload[InspectorProtocol::Message_eventName_wrappedEvent].getString();
+        self->sendMessageToVM(pageId, std::move(wrappedEvent));
+        break;
+      }
+
+      case InspectorProtocol::EventType::Connect: {
+        folly::dynamic payload = messageDyn[InspectorProtocol::Message_PAYLOAD];
+        int32_t pageId = static_cast<int32_t>(payload[InspectorProtocol::Message_PAGEID].asInt());
+
+        if (self->m_localConnections.find(pageId) != self->m_localConnections.end()) {
+          break;
+        }
+
+        self->m_localConnections[pageId] =
+            facebook::react::getInspectorInstance().connect(pageId, std::make_unique<RemoteConnection>(pageId, *self));
+        break;
+      }
+
+      case InspectorProtocol::EventType::Disconnect: {
+        folly::dynamic payload = messageDyn[InspectorProtocol::Message_PAYLOAD];
+        int32_t pageId = static_cast<int32_t>(payload[InspectorProtocol::Message_PAGEID].asInt());
+        if (self->m_localConnections.find(pageId) != self->m_localConnections.end()) {
+          self->m_localConnections[pageId]->disconnect();
+          self->m_localConnections.erase(pageId);
+        }
+        break;
+      }
+    }
+  });
 
   Microsoft::React::Networking::IWebSocketResource::Protocols protocols;
   Microsoft::React::Networking::IWebSocketResource::Options options;
@@ -276,5 +232,3 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
 }
 
 } // namespace Microsoft::ReactNative
-
-#endif

package/Shared/InspectorPackagerConnection.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include <InspectorProxy.h>
 #include <Networking/WinRTWebSocketResource.h>
 #include <jsinspector/InspectorInterfaces.h>
 
@@ -16,12 +15,12 @@ class InspectorPackagerConnection final : public std::enable_shared_from_this<In
 
   class BundleStatus {
    public:
-    bool m_isLastDownloadSucess;
+    bool m_isLastDownloadSuccess;
     int64_t m_updateTimestamp = -1;
 
     BundleStatus(bool isLastDownloadSucess, long updateTimestamp)
-        : m_isLastDownloadSucess(isLastDownloadSucess), m_updateTimestamp(updateTimestamp) {}
-    BundleStatus() : m_isLastDownloadSucess(false), m_updateTimestamp(-1) {}
+        : m_isLastDownloadSuccess(isLastDownloadSucess), m_updateTimestamp(updateTimestamp) {}
+    BundleStatus() : m_isLastDownloadSuccess(false), m_updateTimestamp(-1) {}
   };
 
   struct IBundleStatusProvider {
@@ -32,16 +31,16 @@ class InspectorPackagerConnection final : public std::enable_shared_from_this<In
 
  private:
   friend class RemoteConnection;
-  friend class RemoteConnection2;
 
   winrt::fire_and_forget sendMessageToPackagerAsync(std::string &&message) const;
   void sendMessageToPackager(std::string &&message) const;
 
-  // Note:: VM side Inspector processes the messages asynchronousely in a sequential executor with dedicated thread.
+  // Note:: VM side Inspector processes the messages asynchronously in a sequential executor with dedicated thread.
   // Hence, we don't bother invoking the inspector asynchronously.
-  void sendMessageToVM(int64_t pageId, std::string &&message);
+  void sendMessageToVM(int32_t pageId, std::string &&message);
 
-  std::unordered_map<int64_t, std::unique_ptr<facebook::react::ILocalConnection>> m_localConnections;
+ private:
+  std::unordered_map<int32_t, std::unique_ptr<facebook::react::ILocalConnection>> m_localConnections;
   std::shared_ptr<Microsoft::React::Networking::WinRTWebSocketResource> m_packagerWebSocketConnection;
   std::shared_ptr<IBundleStatusProvider> m_bundleStatusProvider;
   std::string m_url;
@@ -49,23 +48,12 @@ class InspectorPackagerConnection final : public std::enable_shared_from_this<In
 
 class RemoteConnection final : public facebook::react::IRemoteConnection {
  public:
-  RemoteConnection(int64_t pageId, const InspectorPackagerConnection &packagerConnection);
-  void onMessage(std::string message) override;
-  void onDisconnect() override;
-
- private:
-  int64_t m_pageId;
-  const InspectorPackagerConnection &m_packagerConnection;
-};
-
-class RemoteConnection2 final : public facebook::react::IRemoteConnection2 {
- public:
-  RemoteConnection2(int64_t pageId, const InspectorPackagerConnection &packagerConnection);
+  RemoteConnection(int32_t pageId, const InspectorPackagerConnection &packagerConnection);
   void onMessage(std::string message) override;
   void onDisconnect() override;
 
  private:
-  int64_t m_pageId;
+  int32_t m_pageId;
   const InspectorPackagerConnection &m_packagerConnection;
 };
 

package/Shared/JSI/ScriptStore.h

@@ -5,12 +5,11 @@
 #include <jsi/jsi.h>
 #include <memory>
 
-namespace facebook {
-namespace jsi {
+namespace facebook::jsi {
 
-// Integer type as it's persist friently.
-using ScriptVersion_t = uint64_t; // It shouldbe std::optional<uint64_t> once we have c++17 available everywhere. Until
-                                  // then, 0 implies versioning not available.
+// Integer type as it's persist friendly.
+using ScriptVersion_t = uint64_t; // It should be std::optional<uint64_t> once we have c++17 available everywhere.
+                                  // Until then, 0 implies versioning not available.
 using JSRuntimeVersion_t = uint64_t; // 0 implies version can't be computed. We assert whenever that happens.
 
 struct VersionedBuffer {
@@ -30,14 +29,14 @@ struct JSRuntimeSignature {
 
 // Most JSI::Runtime implementation offer some form of prepared JavaScript which offers better performance
 // characteristics when loading comparing to plain JavaScript. Embedders can provide an instance of this interface
-// (through JSI::Runtime implementation's factory method), to enable persistance of the prepared script and retrieval on
-// subsequent evaluation of a script.
+// (through JSI::Runtime implementation's factory method), to enable persistence of the prepared script
+// and retrieval on subsequent evaluation of a script.
 struct PreparedScriptStore {
   virtual ~PreparedScriptStore() = default;
 
-  // Try to retrieve the prepared javascript for a given combination of script & runtime.
-  // scriptSignature : Javascript url and version
-  // RuntimeSignature : Javascript engine type and version
+  // Try to retrieve the prepared JavaScript for a given combination of script & runtime.
+  // scriptSignature : JavaScript URL and version
+  // RuntimeSignature : JavaScript engine type and version
   // prepareTag : Custom tag to uniquely identify JS engine specific preparation schemes. It is usually useful while
   // experimentation and can be null. It is possible that no prepared script is available for a given script & runtime
   // signature. This method should null if so
@@ -47,12 +46,12 @@ struct PreparedScriptStore {
       const char *prepareTag // Optional tag. For e.g. eagerly evaluated vs lazy cache.
       ) noexcept = 0;
 
-  // Persist the perpared javascript for a given combination of script & runtime.
-  // scriptSignature : Javascript url and version
-  // RuntimeSignature : Javascript engine type and version
+  // Persist the prepared JavaScript for a given combination of script & runtime.
+  // scriptSignature : JavaScript URL and version
+  // RuntimeSignature : JavaScript engine type and version
   // prepareTag : Custom tag to uniquely identify JS engine specific preparation schemes. It is usually useful while
   // experimentation and can be null. It is possible that no prepared script is available for a given script & runtime
-  // signature. This method should null if so Any failure in persistance should be identified during the subsequent
+  // signature. This method should null if so Any failure in persistence should be identified during the subsequent
   // retrieval through the integrity mechanism which must be put into the storage.
   virtual void persistPreparedScript(
       std::shared_ptr<const facebook::jsi::Buffer> preparedScript,
@@ -63,17 +62,16 @@ struct PreparedScriptStore {
 };
 
 // JSI::Runtime implementation must be provided an instance on this interface to enable version sensitive capabilities
-// such as usage of pre-prepared javascript script. Alternatively, this entity can be used to directly provide the
-// Javascript buffer and rich metadata to the JSI::Runtime instance.
+// such as usage of prepared JavaScript script. Alternatively, this entity can be used to directly provide the
+// JavaScript buffer and rich meta data to the JSI::Runtime instance.
 struct ScriptStore {
   virtual ~ScriptStore() = default;
 
-  // Return the Javascript buffer and version corresponding to a given url.
+  // Return the JavaScript buffer and version corresponding to a given URL.
   virtual VersionedBuffer getVersionedScript(const std::string &url) noexcept = 0;
 
-  // Return the version of the Javascript buffer corresponding to a given url.
+  // Return the version of the JavaScript buffer corresponding to a given URL.
   virtual ScriptVersion_t getScriptVersion(const std::string &url) noexcept = 0;
 };
 
-} // namespace jsi
-} // namespace facebook
+} // namespace facebook::jsi

package/Shared/JSI/V8RuntimeHolder.cpp

@@ -0,0 +1,262 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "V8RuntimeHolder.h"
+#include <ApiLoaders/V8Api.h>
+#include <NodeApiJsiRuntime.h>
+#include <crash/verifyElseCrash.h>
+#include "SafeLoadLibrary.h"
+
+using namespace Microsoft::NodeApiJsi;
+
+#define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
+
+namespace Microsoft::ReactNative {
+namespace {
+
+class V8FuncResolver : public IFuncResolver {
+ public:
+  V8FuncResolver() : libHandle_(SafeLoadLibrary(L"v8jsi.dll")) {}
+
+  FuncPtr getFuncPtr(const char *funcName) override {
+    return reinterpret_cast<FuncPtr>(GetProcAddress(libHandle_, funcName));
+  }
+
+ private:
+  HMODULE libHandle_;
+};
+
+V8Api &initV8Api() noexcept {
+  static V8FuncResolver funcResolver;
+  static V8Api s_v8Api(&funcResolver);
+  V8Api::setCurrent(&s_v8Api);
+  return s_v8Api;
+}
+
+V8Api &getV8Api() noexcept {
+  static V8Api &s_v8Api = initV8Api();
+  return s_v8Api;
+}
+
+class V8Task {
+ public:
+  V8Task(void *taskData, jsr_task_run_cb taskRunCallback, jsr_data_delete_cb taskDataDeleteCallback, void *deleterData)
+      : taskData_(taskData),
+        taskRunCallback_(taskRunCallback),
+        taskDataDeleteCallback_(taskDataDeleteCallback),
+        deleterData_(deleterData) {}
+
+  V8Task(const V8Task &other) = delete;
+  V8Task &operator=(const V8Task &other) = delete;
+
+  ~V8Task() {
+    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 V8TaskRunner {
+ public:
+  static void Create(jsr_config config, std::shared_ptr<facebook::react::MessageQueueThread> queue) {
+    CRASH_ON_ERROR(
+        getV8Api().jsr_config_set_task_runner(config, new V8TaskRunner(std::move(queue)), &PostTask, &Delete, nullptr));
+  }
+
+ private:
+  V8TaskRunner(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<V8Task>(taskData, taskRunCallback, taskDataDeleteCallback, deleterData);
+    reinterpret_cast<V8TaskRunner *>(taskRunnerData)->queue_->runOnQueue([task = std::move(task)] { task->Run(); });
+  }
+
+  static void NAPI_CDECL Delete(void *taskRunner, void * /*deleterData*/) {
+    delete reinterpret_cast<V8TaskRunner *>(taskRunner);
+  }
+
+ private:
+  std::shared_ptr<facebook::react::MessageQueueThread> queue_;
+};
+
+struct V8JsiBuffer : 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 V8JsiBuffer(buffer, bufferSize, bufferDeleteCallback, deleterData));
+  }
+
+  V8JsiBuffer(
+      const uint8_t *buffer,
+      size_t bufferSize,
+      jsr_data_delete_cb bufferDeleteCallback,
+      void *deleterData) noexcept
+      : buffer_(buffer),
+        bufferSize_(bufferSize),
+        bufferDeleteCallback_(bufferDeleteCallback),
+        deleterData_(deleterData) {}
+
+  ~V8JsiBuffer() 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 V8ScriptCache {
+ public:
+  static void Create(jsr_config config, std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore) {
+    CRASH_ON_ERROR(getV8Api().jsr_config_set_script_cache(
+        config, new V8ScriptCache(std::move(scriptStore)), &LoadScript, &StoreScript, &Delete, nullptr));
+  }
+
+ private:
+  V8ScriptCache(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<V8ScriptCache *>(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<V8ScriptCache *>(scriptCache)->scriptStore_;
+    scriptStore->persistPreparedScript(
+        V8JsiBuffer::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<V8ScriptCache *>(scriptCache);
+  }
+
+ private:
+  std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore_;
+};
+
+} // namespace
+
+V8RuntimeHolder::V8RuntimeHolder(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
+    std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore,
+    bool enableMultiThreadingSupport) noexcept
+    : m_weakDevSettings(devSettings),
+      m_jsQueue(std::move(jsQueue)),
+      m_preparedScriptStore(std::move(preparedScriptStore)),
+      m_enableMultiThreadingSupport(enableMultiThreadingSupport) {}
+
+void V8RuntimeHolder::initRuntime() noexcept {
+  std::shared_ptr<facebook::react::DevSettings> devSettings = m_weakDevSettings.lock();
+  VerifyElseCrash(devSettings);
+
+  V8Api &api = getV8Api();
+  V8Api::setCurrent(&api);
+  jsr_config config{};
+  CRASH_ON_ERROR(api.jsr_create_config(&config));
+  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));
+  CRASH_ON_ERROR(api.v8_config_enable_multithreading(config, m_enableMultiThreadingSupport));
+
+  if (m_jsQueue) {
+    V8TaskRunner::Create(config, m_jsQueue);
+  }
+  if (m_preparedScriptStore) {
+    V8ScriptCache::Create(config, m_preparedScriptStore);
+  }
+  jsr_runtime runtime{};
+  CRASH_ON_ERROR(api.jsr_create_runtime(config, &runtime));
+  CRASH_ON_ERROR(api.jsr_delete_config(config));
+
+  CRASH_ON_ERROR(api.jsr_create_runtime(config, &runtime));
+
+  napi_env env{};
+  CRASH_ON_ERROR(api.jsr_runtime_get_node_api_env(runtime, &env));
+
+  m_jsiRuntime =
+      makeNodeApiJsiRuntime(env, &api, [runtime]() { CRASH_ON_ERROR(V8Api::current()->jsr_delete_runtime(runtime)); });
+  m_ownThreadId = std::this_thread::get_id();
+}
+
+facebook::react::JSIEngineOverride V8RuntimeHolder::getRuntimeType() noexcept {
+  return facebook::react::JSIEngineOverride::V8NodeApi;
+}
+
+std::shared_ptr<facebook::jsi::Runtime> V8RuntimeHolder::getRuntime() noexcept {
+  std::call_once(m_onceFlag, [this]() { initRuntime(); });
+  VerifyElseCrash(m_jsiRuntime);
+  return m_jsiRuntime;
+}
+
+} // namespace Microsoft::ReactNative