react-native-windows 0.71.37 → 0.71.38

package/Shared/HermesSamplingProfiler.cpp

@@ -3,19 +3,51 @@
 
 #include "pch.h"
 
-#include <hermes/hermes.h>
+#include <hermes/hermes_api.h>
 #include <chrono>
 #include <future>
 
+#include "HermesRuntimeHolder.h"
 #include "HermesSamplingProfiler.h"
-#include "HermesShim.h"
+#include "IReactDispatcher.h"
+#include "ReactPropertyBag.h"
 #include "Utils.h"
 
+using namespace winrt::Microsoft::ReactNative;
+using namespace facebook::react;
+
 namespace Microsoft::ReactNative {
 
 namespace {
+
+// Implements an awaiter for Mso::DispatchQueue
+auto resume_in_dispatcher(const IReactDispatcher &dispatcher) noexcept {
+  struct awaitable {
+    awaitable(const IReactDispatcher &dispatcher) noexcept : dispatcher_(dispatcher) {}
+
+    bool await_ready() const noexcept {
+      return false;
+    }
+
+    void await_resume() const noexcept {}
+
+    void await_suspend(std::experimental::coroutine_handle<> resume) noexcept {
+      callback_ = [context = resume.address()]() noexcept {
+        std::experimental::coroutine_handle<>::from_address(context)();
+      };
+      dispatcher_.Post(std::move(callback_));
+    }
+
+   private:
+    IReactDispatcher dispatcher_;
+    ReactDispatcherCallback callback_;
+  };
+
+  return awaitable{dispatcher};
+}
+
 std::future<std::string> getTraceFilePath() noexcept {
-  auto hermesDataPath = co_await Microsoft::React::getApplicationDataPath(L"Hermes");
+  std::string hermesDataPath = co_await Microsoft::React::getApplicationDataPath(L"Hermes");
   std::ostringstream os;
   auto now = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch())
                  .count();
@@ -23,39 +55,59 @@ std::future<std::string> getTraceFilePath() noexcept {
   os << hermesDataPath << "\\cpu_" << now << ".cpuprofile";
   co_return os.str();
 }
+
 } // namespace
 
-bool HermesSamplingProfiler::s_isStarted = false;
+std::atomic_bool HermesSamplingProfiler::s_isStarted{false};
 std::string HermesSamplingProfiler::s_lastTraceFilePath;
 
 std::string HermesSamplingProfiler::GetLastTraceFilePath() noexcept {
   return s_lastTraceFilePath;
 }
 
-winrt::fire_and_forget HermesSamplingProfiler::Start() noexcept {
-  if (!s_isStarted) {
-    s_isStarted = true;
+winrt::fire_and_forget HermesSamplingProfiler::Start(
+    Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
+  bool expectedIsStarted = false;
+  if (s_isStarted.compare_exchange_strong(expectedIsStarted, true)) {
+    IReactDispatcher jsDispatcher = implementation::ReactDispatcher::GetJSDispatcher(reactContext->Properties());
+    ReactPropertyBag propertyBag = ReactPropertyBag(reactContext->Properties());
+
+    co_await resume_in_dispatcher(jsDispatcher);
+    std::shared_ptr<HermesRuntimeHolder> hermesRuntimeHolder = HermesRuntimeHolder::loadFrom(propertyBag);
+    hermesRuntimeHolder->addToProfiling();
+
     co_await winrt::resume_background();
-    HermesShim::enableSamplingProfiler();
+    HermesRuntimeHolder::enableSamplingProfiler();
   }
 
   co_return;
 }
 
-std::future<std::string> HermesSamplingProfiler::Stop() noexcept {
-  if (s_isStarted) {
-    s_isStarted = false;
+std::future<std::string> HermesSamplingProfiler::Stop(
+    Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
+  bool expectedIsStarted = true;
+  if (s_isStarted.compare_exchange_strong(expectedIsStarted, false)) {
+    IReactDispatcher jsDispatcher = implementation::ReactDispatcher::GetJSDispatcher(reactContext->Properties());
+    ReactPropertyBag propertyBag = ReactPropertyBag(reactContext->Properties());
+
     co_await winrt::resume_background();
-    HermesShim::disableSamplingProfiler();
+    HermesRuntimeHolder::disableSamplingProfiler();
+
     s_lastTraceFilePath = co_await getTraceFilePath();
-    HermesShim::dumpSampledTraceToFile(s_lastTraceFilePath);
+    HermesRuntimeHolder::dumpSampledTraceToFile(s_lastTraceFilePath);
+
+    co_await resume_in_dispatcher(jsDispatcher);
+    std::shared_ptr<HermesRuntimeHolder> hermesRuntimeHolder = HermesRuntimeHolder::loadFrom(propertyBag);
+    hermesRuntimeHolder->removeFromProfiling();
+
+    co_await winrt::resume_background();
   }
 
   co_return s_lastTraceFilePath;
 }
 
 bool HermesSamplingProfiler::IsStarted() noexcept {
-  return s_isStarted;
+  return s_isStarted.load();
 }
 
 } // namespace Microsoft::ReactNative

package/Shared/HermesSamplingProfiler.h

@@ -3,19 +3,21 @@
 
 #pragma once
 
+#include <ReactHost/React.h>
+#include <atomic>
 #include <string>
 
 namespace Microsoft::ReactNative {
 
 class HermesSamplingProfiler final {
  public:
-  static winrt::fire_and_forget Start() noexcept;
-  static std::future<std::string> Stop() noexcept;
+  static winrt::fire_and_forget Start(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept;
+  static std::future<std::string> Stop(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept;
   static std::string GetLastTraceFilePath() noexcept;
   static bool IsStarted() noexcept;
 
  private:
-  static bool s_isStarted;
+  static std::atomic_bool s_isStarted;
   static std::string s_lastTraceFilePath;
 };
 

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) {}
+    BundleStatus(bool isLastDownloadSuccess, long updateTimestamp)
+        : m_isLastDownloadSuccess(isLastDownloadSuccess), 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.
   // 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/RuntimeHolder.h

@@ -11,7 +11,7 @@ namespace Microsoft::JSI {
 // a. lazily create a JSI Runtime on the first call to getRuntime
 // b. subsequent calls to getRuntime should return the Runtime created in (a)
 
-// Note :: All calls to getRuntime() should happen on the same thread unless you are sure that
+// Note: all calls to getRuntime() should happen on the same thread unless you are sure that
 // the underlying Runtime instance is thread safe.
 
 struct RuntimeHolderLazyInit {
@@ -21,7 +21,7 @@ struct RuntimeHolderLazyInit {
   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
+  // The fileDescriptor supplied is a raw file stream an implementation might write JSON to.
   virtual void crashHandler(int fileDescriptor) noexcept {};
 };
 

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