react-native-windows 0.76.3 → 0.77.0-preview.2

package/Microsoft.ReactNative.Cxx/NodeApiJsiRuntime.cpp

@@ -0,0 +1,2878 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#define NAPI_EXPERIMENTAL
+
+#include "NodeApiJsiRuntime.h"
+
+#include <algorithm>
+#include <array>
+#include <optional>
+#include <sstream>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+
+// JSI version defines set of features available in the API.
+// Each significant API change must be under a new version.
+// These macros must be defined in jsi.h, but define them here too
+// in case if this code is used with unmodified jsi.h.
+#ifndef JSI_VERSION
+#define JSI_VERSION 10
+#endif
+
+#ifndef JSI_NO_CONST_3
+#if JSI_VERSION >= 3
+#define JSI_NO_CONST_3
+#else
+#define JSI_NO_CONST_3 const
+#endif
+#endif
+
+#ifndef JSI_CONST_10
+#if JSI_VERSION >= 10
+#define JSI_CONST_10 const
+#else
+#define JSI_CONST_10
+#endif
+#endif
+
+using namespace facebook;
+using namespace std::string_view_literals;
+
+// We use macros to report errors.
+// Macros provide more flexibility to show assert and provide failure context.
+
+// Check condition and crash process if it fails.
+#define CHECK_ELSE_CRASH(condition, message)               \
+  do {                                                     \
+    if (!(condition)) {                                    \
+      assert(false && "Failed: " #condition && (message)); \
+      *((int *)0) = 1;                                     \
+    }                                                      \
+  } while (false)
+
+// Check condition and throw native exception if it fails.
+#define CHECK_ELSE_THROW(condition, message) \
+  do {                                       \
+    if (!(condition)) {                      \
+      throwNativeException(message);         \
+    }                                        \
+  } while (false)
+
+// Check NAPI result and and throw JS exception if it is not napi_ok.
+#define CHECK_NAPI(...)                             \
+  do {                                              \
+    napi_status temp_error_code_ = (__VA_ARGS__);   \
+    if (temp_error_code_ != napi_status::napi_ok) { \
+      runtime.throwJSException(temp_error_code_);   \
+    }                                               \
+  } while (false)
+
+// Check NAPI result and and crash if it is not napi_ok.
+#define CHECK_NAPI_ELSE_CRASH(expression)              \
+  do {                                                 \
+    napi_status temp_error_code_ = (expression);       \
+    if (temp_error_code_ != napi_status::napi_ok) {    \
+      CHECK_ELSE_CRASH(false, "Failed: " #expression); \
+    }                                                  \
+  } while (false)
+
+// Check NAPI result and return it when it is an error.
+#define NAPI_CALL(expression)                       \
+  do {                                              \
+    napi_status temp_error_code_ = (expression);    \
+    if (temp_error_code_ != napi_status::napi_ok) { \
+      return temp_error_code_;                      \
+    }                                               \
+  } while (false)
+
+#ifdef __cpp_lib_span
+#include <span>
+#endif // __cpp_lib_span
+
+namespace Microsoft::NodeApiJsi {
+
+namespace {
+
+#ifdef __cpp_lib_span
+using std::span;
+#else
+/**
+ * @brief A span of values that can be used to pass arguments to a function.
+ *
+ * This should be replaced with std::span once C++20 is supported.
+ */
+template <typename T>
+class span {
+ public:
+  constexpr span() noexcept : data_{nullptr}, size_{0} {}
+  constexpr span(T *data, size_t size) noexcept : data_{data}, size_{size} {}
+  template <std::size_t N>
+  constexpr span(T (&arr)[N]) noexcept : data_{arr}, size_{N} {}
+
+  [[nodiscard]] constexpr T *data() const noexcept {
+    return data_;
+  }
+
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    return size_;
+  }
+
+  [[nodiscard]] constexpr T *begin() const noexcept {
+    return data_;
+  }
+
+  [[nodiscard]] constexpr T *end() const noexcept {
+    return *(data_ + size_);
+  }
+
+  const T &operator[](size_t index) const noexcept {
+    return *(data_ + index);
+  }
+
+ private:
+  T *data_;
+  size_t size_;
+};
+#endif // __cpp_lib_span
+
+// To be used as a key in a unordered_map.
+class StringKey {
+ public:
+  explicit StringKey(std::string &&string) noexcept;
+  explicit StringKey(std::string_view view) noexcept;
+  explicit StringKey(const char *data, size_t length) noexcept;
+  StringKey(StringKey &&other) noexcept;
+  StringKey &operator=(StringKey &&other) noexcept;
+  StringKey(const StringKey &other) = delete;
+  StringKey &operator=(const StringKey &other) = delete;
+  ~StringKey();
+
+  std::string_view getStringView() const;
+  bool equalTo(const StringKey &other) const;
+  size_t hash() const;
+
+  struct Hash {
+    size_t operator()(const StringKey &key) const;
+  };
+
+  struct EqualTo {
+    bool operator()(const StringKey &left, const StringKey &right) const;
+  };
+
+ private:
+  enum class Type {
+    String,
+    View,
+  };
+
+ private:
+  union {
+    std::string string_;
+    std::string_view view_;
+  };
+  Type type_{Type::String};
+  size_t hash_;
+};
+
+// Implementation of N-API JSI Runtime
+class NodeApiJsiRuntime : public jsi::Runtime {
+ public:
+  NodeApiJsiRuntime(napi_env env, JSRuntimeApi *jsrApi, std::function<void()> onDelete) noexcept;
+  ~NodeApiJsiRuntime() override;
+
+  jsi::Value evaluateJavaScript(const std::shared_ptr<const jsi::Buffer> &buffer, const std::string &sourceURL)
+      override;
+  std::shared_ptr<const jsi::PreparedJavaScript> prepareJavaScript(
+      const std::shared_ptr<const jsi::Buffer> &buffer,
+      std::string sourceURL) override;
+  jsi::Value evaluatePreparedJavaScript(const std::shared_ptr<const jsi::PreparedJavaScript> &js) override;
+#if JSI_VERSION >= 4
+  bool drainMicrotasks(int maxMicrotasksHint = -1) override;
+#endif
+  jsi::Object global() override;
+  std::string description() override;
+  bool isInspectable() override;
+
+ protected:
+  PointerValue *cloneSymbol(const PointerValue *pointerValue) override;
+#if JSI_VERSION >= 6
+  PointerValue *cloneBigInt(const PointerValue *pointerValue) override;
+#endif
+  PointerValue *cloneString(const PointerValue *pointerValue) override;
+  PointerValue *cloneObject(const PointerValue *pointerValue) override;
+  PointerValue *clonePropNameID(const PointerValue *pointerValue) override;
+
+  jsi::PropNameID createPropNameIDFromAscii(const char *str, size_t length) override;
+  jsi::PropNameID createPropNameIDFromUtf8(const uint8_t *utf8, size_t length) override;
+  jsi::PropNameID createPropNameIDFromString(const jsi::String &str) override;
+#if JSI_VERSION >= 5
+  jsi::PropNameID createPropNameIDFromSymbol(const jsi::Symbol &sym) override;
+#endif
+  std::string utf8(const jsi::PropNameID &id) override;
+  bool compare(const jsi::PropNameID &lhs, const jsi::PropNameID &rhs) override;
+
+  std::string symbolToString(const jsi::Symbol &s) override;
+
+#if JSI_VERSION >= 8
+  jsi::BigInt createBigIntFromInt64(int64_t value) override;
+  jsi::BigInt createBigIntFromUint64(uint64_t value) override;
+  bool bigintIsInt64(const jsi::BigInt &value) override;
+  bool bigintIsUint64(const jsi::BigInt &value) override;
+  uint64_t truncate(const jsi::BigInt &value) override;
+  jsi::String bigintToString(const jsi::BigInt &value, int radix) override;
+#endif
+
+  jsi::String createStringFromAscii(const char *str, size_t length) override;
+  jsi::String createStringFromUtf8(const uint8_t *utf8, size_t length) override;
+  std::string utf8(const jsi::String &str) override;
+
+  jsi::Object createObject() override;
+  jsi::Object createObject(std::shared_ptr<jsi::HostObject> ho) override;
+  std::shared_ptr<jsi::HostObject> getHostObject(const jsi::Object &) override;
+  jsi::HostFunctionType &getHostFunction(const jsi::Function &) override;
+
+#if JSI_VERSION >= 7
+  bool hasNativeState(const jsi::Object &value) override;
+  std::shared_ptr<jsi::NativeState> getNativeState(const jsi::Object &value) override;
+  void setNativeState(const jsi::Object &value, std::shared_ptr<jsi::NativeState> state) override;
+#endif
+
+  jsi::Value getProperty(const jsi::Object &obj, const jsi::PropNameID &name) override;
+  jsi::Value getProperty(const jsi::Object &obj, const jsi::String &name) override;
+  bool hasProperty(const jsi::Object &obj, const jsi::PropNameID &name) override;
+  bool hasProperty(const jsi::Object &obj, const jsi::String &name) override;
+  void setPropertyValue(JSI_CONST_10 jsi::Object &obj, const jsi::PropNameID &name, const jsi::Value &value) override;
+  void setPropertyValue(JSI_CONST_10 jsi::Object &obj, const jsi::String &name, const jsi::Value &value) override;
+
+  bool isArray(const jsi::Object &obj) const override;
+  bool isArrayBuffer(const jsi::Object &obj) const override;
+  bool isFunction(const jsi::Object &obj) const override;
+  bool isHostObject(const jsi::Object &obj) const override;
+  bool isHostFunction(const jsi::Function &func) const override;
+  jsi::Array getPropertyNames(const jsi::Object &obj) override;
+
+  jsi::WeakObject createWeakObject(const jsi::Object &obj) override;
+  jsi::Value lockWeakObject(JSI_NO_CONST_3 JSI_CONST_10 jsi::WeakObject &weakObj) override;
+
+  jsi::Array createArray(size_t length) override;
+#if JSI_VERSION >= 9
+  jsi::ArrayBuffer createArrayBuffer(std::shared_ptr<jsi::MutableBuffer> buffer);
+#endif
+  size_t size(const jsi::Array &arr) override;
+  size_t size(const jsi::ArrayBuffer &arrBuf) override;
+  uint8_t *data(const jsi::ArrayBuffer &arrBuff) override;
+  jsi::Value getValueAtIndex(const jsi::Array &arr, size_t index) override;
+  void setValueAtIndexImpl(JSI_CONST_10 jsi::Array &arr, size_t index, const jsi::Value &value) override;
+
+  jsi::Function createFunctionFromHostFunction(
+      const jsi::PropNameID &name,
+      unsigned int paramCount,
+      jsi::HostFunctionType func) override;
+  jsi::Value call(const jsi::Function &func, const jsi::Value &jsThis, const jsi::Value *args, size_t count) override;
+  jsi::Value callAsConstructor(const jsi::Function &func, const jsi::Value *args, size_t count) override;
+
+  ScopeState *pushScope() override;
+  void popScope(ScopeState *) override;
+
+  bool strictEquals(const jsi::Symbol &a, const jsi::Symbol &b) const override;
+#if JSI_VERSION >= 6
+  bool strictEquals(const jsi::BigInt &a, const jsi::BigInt &b) const override;
+#endif
+  bool strictEquals(const jsi::String &a, const jsi::String &b) const override;
+  bool strictEquals(const jsi::Object &a, const jsi::Object &b) const override;
+
+  bool instanceOf(const jsi::Object &obj, const jsi::Function &func) override;
+
+#if JSI_VERSION >= 11
+  void setExternalMemoryPressure(const jsi::Object &obj, size_t amount) override;
+#endif
+
+ private:
+  // RAII class to open and close the environment scope.
+  class NodeApiScope {
+   public:
+    NodeApiScope(const NodeApiJsiRuntime &runtime) noexcept;
+    NodeApiScope(NodeApiJsiRuntime &runtime) noexcept;
+    ~NodeApiScope() noexcept;
+
+    NodeApiScope(const NodeApiScope &) = delete;
+    NodeApiScope &operator=(const NodeApiScope &) = delete;
+
+   private:
+    NodeApiJsiRuntime &runtime_;
+    NodeApiEnvScope envScope_;
+    ScopeState *scopeState_{};
+  };
+
+  // RAII class to open and close the environment scope.
+  class NodeApiPointerValueScope {
+   public:
+    NodeApiPointerValueScope(NodeApiJsiRuntime &runtime) noexcept;
+    ~NodeApiPointerValueScope() noexcept;
+
+    NodeApiPointerValueScope(const NodeApiPointerValueScope &) = delete;
+    NodeApiPointerValueScope &operator=(const NodeApiPointerValueScope &) = delete;
+
+   private:
+    NodeApiJsiRuntime &runtime_;
+  };
+
+  // Sets the variable in the constructor and then restores its value in the destructor.
+  template <typename T>
+  class AutoRestore {
+   public:
+    AutoRestore(T &varRef, T value);
+    ~AutoRestore();
+
+    AutoRestore(const AutoRestore &) = delete;
+    AutoRestore &operator=(const AutoRestore &) = delete;
+
+   private:
+    T &varRef_;
+    T oldValue_;
+  };
+
+  enum class NodeApiPointerValueKind {
+    Object,
+    WeakObject,
+    String,
+    StringPropNameID,
+    Symbol,
+    BigInt,
+  };
+
+  class NodeApiRefCountedPointerValue;
+
+  // NodeApiPointerValue is used by jsi::Pointer derived classes.
+  struct NodeApiPointerValue : PointerValue {
+    virtual NodeApiRefCountedPointerValue *clone(NodeApiJsiRuntime &runtime) const = 0;
+    virtual napi_value getValue(NodeApiJsiRuntime &runtime) noexcept = 0;
+    virtual NodeApiPointerValueKind getKind() const noexcept = 0;
+  };
+
+  // NodeApiStackOnlyPointerValue helps to avoid memory allocation in some scenarios.
+  // It is used by the JsiValueView, JsiValueViewArgs, and PropNameIDView classes
+  // to keep temporary PointerValues on the call stack.
+  class NodeApiStackOnlyPointerValue final : public NodeApiPointerValue {
+   public:
+    NodeApiStackOnlyPointerValue(napi_value value, NodeApiPointerValueKind pointerKind) noexcept;
+
+    void invalidate() noexcept override;
+    NodeApiRefCountedPointerValue *clone(NodeApiJsiRuntime &runtime) const override;
+    napi_value getValue(NodeApiJsiRuntime &runtime) noexcept override;
+    NodeApiPointerValueKind getKind() const noexcept override;
+
+    NodeApiStackOnlyPointerValue(const NodeApiStackOnlyPointerValue &) = delete;
+    NodeApiStackOnlyPointerValue &operator=(const NodeApiStackOnlyPointerValue &) = delete;
+
+   private:
+    napi_value value_{};
+    NodeApiPointerValueKind pointerKind_{NodeApiPointerValueKind::Object};
+  };
+
+  // NodeApiRefCountedPointerValue is a ref counted implementation of PointerValue that is allocated in the heap.
+  // It expects to have three different types of smart pointers:
+  // - jsi::Pointer derived classes uses clone() and invalidate() methods to increment and decrement the ref count.
+  //   The invalidate() method can be called from any thread.
+  // - NodeApiStackValueHolder points to NodeApiRefCountedPointerValue when it has associated napi_value.
+  // - NodeApiRefHolder points to NodeApiRefCountedPointerValue when it has associated napi_ref.
+  //
+  // Using three types of smart pointers ensures that we always destroy napi_ref from the right thread.
+  // The invalidate() method can destroy NodeApiRefCountedPointerValue from a different thread only when there are
+  // no napi_value or napi_ref present in the class. Otherwise, the destruction will happen when we remove
+  // either napi_value or napi_ref reference.
+  //
+  // Some NodeApiRefCountedPointerValue are created with napi_value and may never get napi_ref.
+  // When stack scope is closed we see if there any jsi::Pointer references. If such references still exist, then
+  // we ensure that it has an associated napi_ref or we create one.
+  //
+  // In addition to the scope closure, there are two cases when we collect NodeApiRefCountedPointerValue
+  // without jsi::Pointer references:
+  // - When we grow the NodeApiJsiRuntime::stackValues_ vector and we reached current capacity.
+  // - When we grow the NodeApiJsiRuntime::refs_ vector and we reached current capacity.
+  class NodeApiRefCountedPointerValue final : public NodeApiPointerValue {
+   public:
+    // Creates new NodeApiRefCountedPointerValue and adds it to the NodeApiJsiRuntime::stackValues_. The ref count
+    // usually starts with 2: one for NodeApiJsiRuntime::stackValues_ reference and another for the targeting
+    // jsi::Pointer.
+    static NodeApiRefCountedPointerValue *make(
+        NodeApiJsiRuntime &runtime,
+        napi_value value,
+        NodeApiPointerValueKind pointerKind,
+        int32_t initialRefCount = 2);
+
+    // Creates new NodeApiRefCountedPointerValue and adds it to the NodeApiJsiRuntime::stackValues_. Then, it creates
+    // the napi_ref. The ref count usually starts with 2: one for NodeApiJsiRuntime::stackValues_ reference and another
+    // for the targeting NodeApiRefHolder.
+    static NodeApiRefCountedPointerValue *makeNodeApiRef(
+        NodeApiJsiRuntime &runtime,
+        napi_value value,
+        NodeApiPointerValueKind pointerKind,
+        int32_t initialRefCount = 2);
+
+    void invalidate() noexcept override;
+    NodeApiRefCountedPointerValue *clone(NodeApiJsiRuntime &runtime) const override;
+    napi_value getValue(NodeApiJsiRuntime &runtime) noexcept override;
+    NodeApiPointerValueKind getKind() const noexcept override;
+
+    // Returns true if the ref count is bigger than if we would have only references for napi_value and napi_ref.
+    static bool usedByJsiPointer(NodeApiRefCountedPointerValue *ptr) noexcept;
+
+    // Remove napi_value field.
+    static void deleteStackValue(NodeApiRefCountedPointerValue *ptr) noexcept;
+
+    // Removes napi_value field and ensures existence of napi_ref field.
+    // Returns true if napi_ref was created and ref count did not change.
+    // Otherwise, the napi_ref was already there and the ref count was decremented.
+    void convertToNodeApiRef(NodeApiJsiRuntime &runtime) noexcept;
+
+    // Removes napi_ref pointer and decrements ref count. The napi_ref is not deleted.
+    // It is useful for napi_env shutdown when napi_env deletes napi_ref and we must not do it.
+    static void deleteNodeApiRef(NodeApiRefCountedPointerValue *ptr) noexcept;
+
+    // Deletes napi_ref, removes napi_ref pointer, and decrements ref count.
+    // This method must be used in all scenarios except for napi_env shutdown.
+    static void deleteNodeApiRef(NodeApiRefCountedPointerValue *ptr, NodeApiJsiRuntime &runtime) noexcept;
+
+    NodeApiRefCountedPointerValue(const NodeApiRefCountedPointerValue &) = delete;
+    NodeApiRefCountedPointerValue &operator=(const NodeApiRefCountedPointerValue &) = delete;
+
+   private:
+    NodeApiRefCountedPointerValue(
+        napi_value value,
+        NodeApiPointerValueKind pointerKind,
+        int32_t initialRefCount) noexcept;
+
+    void incRefCount() const noexcept;
+
+    // Decrements ref count. Delete this instance if ref count is zero.
+    void decRefCount() const noexcept;
+
+    NodeApiRefCountedPointerValue *createNodeApiRef(NodeApiJsiRuntime &runtime);
+
+   private:
+    napi_value value_{};
+    napi_ref ref_{};
+    mutable std::atomic<int32_t> refCount_{};
+    const NodeApiPointerValueKind pointerKind_{NodeApiPointerValueKind::Object};
+
+    static constexpr char kPrimitivePropertyName[] = "X";
+  };
+
+  using NodeApiPointerValueDeleter = void(NodeApiRefCountedPointerValue *);
+
+  template <NodeApiPointerValueDeleter *deleter>
+  class NodeApiPointerValueHolder {
+   public:
+    NodeApiPointerValueHolder() = default;
+    explicit NodeApiPointerValueHolder(NodeApiRefCountedPointerValue *ptr) : ptr_(ptr) {}
+
+    NodeApiPointerValueHolder(NodeApiPointerValueHolder &&other) : ptr_(std::exchange(other.ptr_, nullptr)) {}
+
+    NodeApiPointerValueHolder &operator=(NodeApiPointerValueHolder &&other) {
+      if (this != &other) {
+        NodeApiPointerValueHolder temp(std::move(*this));
+        ptr_ = std::exchange(other.ptr_, nullptr);
+      }
+      return *this;
+    }
+
+    ~NodeApiPointerValueHolder() {
+      if (NodeApiRefCountedPointerValue *ptr = std::exchange(ptr_, nullptr)) {
+        deleter(ptr);
+      }
+    }
+
+    NodeApiRefCountedPointerValue *operator->() const {
+      return ptr_;
+    }
+
+    NodeApiRefCountedPointerValue *get() const {
+      return ptr_;
+    }
+
+    NodeApiRefCountedPointerValue *release() {
+      return std::exchange(ptr_, nullptr);
+    }
+
+    explicit operator bool() const {
+      return ptr_ != nullptr;
+    }
+
+    NodeApiPointerValueHolder(NodeApiPointerValueHolder const &) = delete;
+    NodeApiPointerValueHolder &operator=(NodeApiPointerValueHolder const &) = delete;
+
+   private:
+    NodeApiRefCountedPointerValue *ptr_{};
+  };
+
+  using NodeApiStackValueHolder = NodeApiPointerValueHolder<&NodeApiRefCountedPointerValue::deleteStackValue>;
+  using NodeApiRefHolder = NodeApiPointerValueHolder<&NodeApiRefCountedPointerValue::deleteNodeApiRef>;
+
+  // SmallBuffer keeps InplaceSize elements in place in the class, and uses heap memory for more elements.
+  template <typename T, size_t InplaceSize>
+  class SmallBuffer {
+   public:
+    SmallBuffer(size_t size) noexcept;
+
+    T *data() noexcept;
+    size_t size() const noexcept;
+
+    SmallBuffer(const SmallBuffer &) = delete;
+    SmallBuffer &operator=(const SmallBuffer &) = delete;
+
+   private:
+    size_t size_{};
+    std::array<T, InplaceSize> stackData_{};
+    std::unique_ptr<T[]> heapData_{};
+  };
+
+  // The number of arguments that we keep on stack. We use heap if we have more arguments.
+  constexpr static size_t MaxStackArgCount = 8;
+
+  // NodeApiValueArgs helps optimize passing arguments to NAPI functions.
+  // If number of arguments is below or equal to MaxStackArgCount, they are kept on the call stack,
+  // otherwise arguments are allocated on the heap.
+  class NodeApiValueArgs {
+   public:
+    NodeApiValueArgs(NodeApiJsiRuntime &runtime, span<const jsi::Value> args);
+    operator span<napi_value>();
+
+    NodeApiValueArgs(const NodeApiValueArgs &) = delete;
+    NodeApiValueArgs &operator=(const NodeApiValueArgs &) = delete;
+
+   private:
+    SmallBuffer<napi_value, MaxStackArgCount> args_;
+  };
+
+  // Helps to use the stack storage for a temporary conversion from napi_value to jsi::Value.
+  // It also helps to avoid a conversion to a relatively expensive napi_ref.
+  class JsiValueView {
+   public:
+    union StoreType {
+      NodeApiStackOnlyPointerValue value_;
+      std::array<std::byte, sizeof(NodeApiStackOnlyPointerValue)> bytes_;
+      StoreType() {}
+      ~StoreType() {}
+    };
+
+   public:
+    JsiValueView(NodeApiJsiRuntime *runtime, napi_value jsValue);
+    operator const jsi::Value &() const noexcept;
+
+    static jsi::Value initValue(NodeApiJsiRuntime *runtime, napi_value jsValue, StoreType *store);
+
+    JsiValueView(const JsiValueView &) = delete;
+    JsiValueView &operator=(const JsiValueView &) = delete;
+
+   private:
+    StoreType pointerStore_;
+    jsi::Value value_{};
+  };
+
+  // Helps to use stack storage for passing arguments that must be temporarily converted
+  // from napi_value to jsi::Value.
+  // It helps to avoid conversion to a relatively expensive napi_ref.
+  class JsiValueViewArgs {
+   public:
+    JsiValueViewArgs(NodeApiJsiRuntime *runtime, span<napi_value> args) noexcept;
+    const jsi::Value *data() noexcept;
+    size_t size() const noexcept;
+
+    JsiValueViewArgs(const JsiValueViewArgs &);
+    JsiValueViewArgs &operator=(const JsiValueViewArgs &);
+
+   private:
+    using StoreType = JsiValueView::StoreType;
+    SmallBuffer<StoreType, MaxStackArgCount> pointerStore_{0};
+    SmallBuffer<jsi::Value, MaxStackArgCount> args_{0};
+  };
+
+  // Helps to use stack storage for a temporary conversion from napi_value to jsi::PropNameID.
+  // It helps to avoid conversions to a relatively expensive napi_ref.
+  class PropNameIDView {
+   public:
+    PropNameIDView(NodeApiJsiRuntime *runtime, napi_value propertyId) noexcept;
+    operator const jsi::PropNameID &() const noexcept;
+
+    PropNameIDView(const PropNameIDView &);
+    PropNameIDView &operator=(const PropNameIDView &);
+
+   private:
+    using StoreType = JsiValueView::StoreType;
+    StoreType pointerStore_{};
+    jsi::PropNameID const propertyId_;
+  };
+
+  // Wraps up the jsi::HostFunctionType along with the NodeApiJsiRuntime.
+  class HostFunctionWrapper {
+   public:
+    HostFunctionWrapper(jsi::HostFunctionType &&hostFunction, NodeApiJsiRuntime &runtime);
+
+    jsi::HostFunctionType &hostFunction() noexcept;
+    NodeApiJsiRuntime &runtime() noexcept;
+
+    HostFunctionWrapper(const HostFunctionWrapper &) = delete;
+    HostFunctionWrapper &operator=(const HostFunctionWrapper &) = delete;
+
+   private:
+    jsi::HostFunctionType hostFunction_;
+    NodeApiJsiRuntime &runtime_;
+  };
+
+  // Wraps up the jsr_prepared_script.
+  class NodeApiPreparedJavaScript final : public jsi::PreparedJavaScript {
+   public:
+    NodeApiPreparedJavaScript(napi_env env, jsr_prepared_script script, std::string sourceURL)
+        : env_(env), script_(script), sourceURL_(std::move(sourceURL)) {}
+
+    ~NodeApiPreparedJavaScript() override {
+      JSRuntimeApi::current()->jsr_delete_prepared_script(env_, script_);
+    }
+
+    jsr_prepared_script getScript() const {
+      return script_;
+    }
+
+    const std::string &sourceURL() const {
+      return sourceURL_;
+    }
+
+    NodeApiPreparedJavaScript(const NodeApiPreparedJavaScript &) = delete;
+    NodeApiPreparedJavaScript &operator=(const NodeApiPreparedJavaScript &) = delete;
+
+   private:
+    napi_env env_;
+    jsr_prepared_script script_;
+    std::string sourceURL_;
+  };
+
+ private: // Error-handling utility methods
+  template <typename... Args>
+  jsi::JSError makeJSError(Args &&...args);
+  [[noreturn]] void throwJSException(napi_status errorCode) const;
+  [[noreturn]] void throwNativeException(char const *errorMessage) const;
+  void rewriteErrorMessage(napi_value jsError) const;
+  template <typename TLambda>
+  auto runInMethodContext(char const *methodName, TLambda lambda);
+  template <typename TLambda>
+  napi_value handleCallbackExceptions(TLambda lambda) const noexcept;
+  bool setException(napi_value error) const noexcept;
+  bool setException(std::string_view message) const noexcept;
+
+ private: // Shared NAPI call helpers
+  napi_valuetype typeOf(napi_value value) const;
+  bool strictEquals(napi_value left, napi_value right) const;
+  napi_value getUndefined() const;
+  napi_value getNull() const;
+  napi_value getGlobal() const;
+  napi_value getBoolean(bool value) const;
+  bool getValueBool(napi_value value) const;
+  napi_value createInt32(int32_t value) const;
+  napi_value createUInt32(uint32_t value) const;
+  napi_value createDouble(double value) const;
+  double getValueDouble(napi_value value) const;
+  napi_value createStringLatin1(std::string_view value) const;
+  napi_value createStringUtf8(std::string_view value) const;
+  napi_value createStringUtf8(const uint8_t *data, size_t length) const;
+  std::string stringToStdString(napi_value stringValue) const;
+  napi_value getPropertyIdFromName(std::string_view value) const;
+  napi_value getPropertyIdFromName(const uint8_t *data, size_t length) const;
+  napi_value getPropertyIdFromName(napi_value str) const;
+  napi_value getPropertyIdFromSymbol(napi_value sym) const;
+  std::string propertyIdToStdString(napi_value propertyId);
+  napi_value createSymbol(std::string_view symbolDescription) const;
+  std::string symbolToStdString(napi_value symbolValue);
+  napi_value callFunction(napi_value thisArg, napi_value function, span<napi_value> args = {}) const;
+  napi_value constructObject(napi_value constructor, span<napi_value> args = {}) const;
+  bool instanceOf(napi_value object, napi_value constructor) const;
+  napi_value createNodeApiObject() const;
+  bool hasProperty(napi_value object, napi_value propertyId) const;
+  napi_value getProperty(napi_value object, napi_value propertyId) const;
+  void setProperty(napi_value object, napi_value propertyId, napi_value value) const;
+  void setProperty(napi_value object, napi_value propertyId, napi_value value, napi_property_attributes attrs) const;
+  napi_value createNodeApiArray(size_t length) const;
+  bool isArray(napi_value value) const;
+  size_t getArrayLength(napi_value value) const;
+  napi_value getElement(napi_value arr, size_t index) const;
+  void setElement(napi_value array, uint32_t index, napi_value value) const;
+  static napi_value __cdecl jsiHostFunctionCallback(napi_env env, napi_callback_info info) noexcept;
+  napi_value createExternalFunction(napi_value name, int32_t paramCount, napi_callback callback, void *callbackData);
+  napi_value createExternalObject(void *data, napi_finalize finalizeCallback) const;
+  template <typename T>
+  napi_value createExternalObject(std::unique_ptr<T> &&data) const;
+  void *getExternalData(napi_value object) const;
+  const std::shared_ptr<jsi::HostObject> &getJsiHostObject(napi_value obj);
+  napi_value getHostObjectProxyHandler();
+  template <napi_value (NodeApiJsiRuntime::*trapMethod)(span<napi_value>), size_t argCount>
+  void setProxyTrap(napi_value handler, napi_value propertyName);
+  napi_value hostObjectHasTrap(span<napi_value> args);
+  napi_value hostObjectGetTrap(span<napi_value> args);
+  napi_value hostObjectSetTrap(span<napi_value> args);
+  napi_value hostObjectOwnKeysTrap(span<napi_value> args);
+  napi_value hostObjectGetOwnPropertyDescriptorTrap(span<napi_value> args);
+
+ private: // Miscellaneous utility methods
+  span<const uint8_t> toSpan(const jsi::Buffer &buffer);
+  jsi::Value toJsiValue(napi_value value) const;
+  napi_value getNodeApiValue(const jsi::Value &value) const;
+  napi_value getNodeApiValue(const jsi::Pointer &ptr) const;
+  napi_value getNodeApiValue(const NodeApiRefHolder &ref) const;
+  NodeApiRefCountedPointerValue *cloneNodeApiPointerValue(const PointerValue *pointerValue);
+  std::optional<uint32_t> toArrayIndex(std::string::const_iterator first, std::string::const_iterator last);
+
+  template <typename T, std::enable_if_t<std::is_same_v<jsi::Object, T>, int> = 0>
+  T makeJsiPointer(napi_value value) const;
+  template <typename T, std::enable_if_t<std::is_same_v<jsi::String, T>, int> = 0>
+  T makeJsiPointer(napi_value value) const;
+  template <typename T, std::enable_if_t<std::is_same_v<jsi::Symbol, T>, int> = 0>
+  T makeJsiPointer(napi_value value) const;
+#if JSI_VERSION >= 6
+  template <typename T, std::enable_if_t<std::is_same_v<jsi::BigInt, T>, int> = 0>
+  T makeJsiPointer(napi_value value) const;
+#endif
+  template <
+      typename TTo,
+      typename TFrom,
+      std::enable_if_t<std::is_base_of_v<jsi::Pointer, TTo>, int> = 0,
+      std::enable_if_t<std::is_base_of_v<jsi::Pointer, TFrom>, int> = 0>
+  TTo cloneAs(const TFrom &pointer) const;
+  NodeApiRefHolder makeNodeApiRef(napi_value value, NodeApiPointerValueKind pointerKind, int32_t initialRefCount = 2);
+
+  void addStackValue(NodeApiStackValueHolder &&pointerHolder);
+  void addRef(NodeApiRefHolder &&refHolder);
+  void pushPointerValueScope() noexcept;
+  void popPointerValueScope() noexcept;
+  void collectUnusedStackValues();
+  void collectUnusedRefs() noexcept;
+
+  napi_env getEnv() const noexcept {
+    return env_;
+  }
+
+ private: // Fields
+  napi_env env_{};
+  JSRuntimeApi *jsrApi_;
+  std::function<void()> onDelete_;
+  std::string sourceURL_;
+
+  // Property ID cache to improve execution speed.
+  struct PropertyId {
+    NodeApiRefHolder Error;
+    NodeApiRefHolder Object;
+    NodeApiRefHolder Proxy;
+    NodeApiRefHolder Symbol;
+    NodeApiRefHolder byteLength;
+    NodeApiRefHolder configurable;
+    NodeApiRefHolder enumerable;
+    NodeApiRefHolder get;
+    NodeApiRefHolder getOwnPropertyDescriptor;
+    NodeApiRefHolder has;
+    NodeApiRefHolder hostFunctionSymbol;
+    NodeApiRefHolder hostObjectSymbol;
+    NodeApiRefHolder length;
+    NodeApiRefHolder message;
+    NodeApiRefHolder ownKeys;
+    NodeApiRefHolder propertyIsEnumerable;
+    NodeApiRefHolder prototype;
+    NodeApiRefHolder set;
+    NodeApiRefHolder stack;
+    NodeApiRefHolder toString;
+    NodeApiRefHolder value;
+    NodeApiRefHolder writable;
+  } propertyId_;
+
+  // Cache of commonly used values.
+  struct CachedValue {
+    NodeApiRefHolder Error;
+    NodeApiRefHolder Global;
+    NodeApiRefHolder HostObjectProxyHandler;
+    NodeApiRefHolder ProxyConstructor;
+    NodeApiRefHolder SymbolToString;
+  } cachedValue_;
+
+  bool hasPendingJSError_{false};
+
+  std::vector<size_t> stackScopes_;
+  std::vector<NodeApiStackValueHolder> stackValues_;
+  std::vector<NodeApiRefHolder> refs_;
+
+  // TODO: implement GC for propNameIDs_
+  std::unordered_map<StringKey, NodeApiRefHolder, StringKey::Hash, StringKey::EqualTo> propNameIDs_;
+
+  NodeApiJsiRuntime &runtime{*this};
+};
+
+//=====================================================================================================================
+// StringKey implementation
+//=====================================================================================================================
+
+StringKey::StringKey(std::string &&string) noexcept
+    : string_(std::move(string)), type_(Type::String), hash_(std::hash<std::string_view>{}(string_)) {}
+
+StringKey::StringKey(std::string_view view) noexcept
+    : view_(view), type_(Type::View), hash_(std::hash<std::string_view>{}(view_)) {}
+
+StringKey::StringKey(const char *data, size_t length) noexcept
+    : view_(data, length), type_(Type::View), hash_(std::hash<std::string_view>{}(view_)) {}
+
+StringKey::StringKey(StringKey &&other) noexcept : type_(other.type_), hash_(std::exchange(other.hash_, 0)) {
+  if (type_ == Type::String) {
+    ::new (std::addressof(string_)) std::string(std::move(other.string_));
+  } else {
+    ::new (std::addressof(view_)) std::string_view(std::exchange(other.view_, std::string_view()));
+  }
+}
+
+StringKey &StringKey::operator=(StringKey &&other) noexcept {
+  if (this != &other) {
+    this->~StringKey();
+    ::new (this) StringKey(std::move(other));
+  }
+  return *this;
+}
+
+StringKey::~StringKey() {
+  if (type_ == Type::String) {
+    std::addressof(string_)->~basic_string();
+  } else {
+    std::addressof(view_)->~basic_string_view();
+  }
+}
+
+std::string_view StringKey::getStringView() const {
+  return (type_ == Type::String) ? std::string_view(string_) : view_;
+}
+
+bool StringKey::equalTo(const StringKey &other) const {
+  return getStringView().compare(other.getStringView()) == 0;
+}
+
+size_t StringKey::hash() const {
+  return hash_;
+}
+
+size_t StringKey::Hash::operator()(const StringKey &key) const {
+  return key.hash();
+}
+
+bool StringKey::EqualTo::operator()(const StringKey &left, const StringKey &right) const {
+  return left.equalTo(right);
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::NodeApiJsiRuntime(napi_env env, JSRuntimeApi *jsrApi, std::function<void()> onDelete) noexcept
+    : env_(env), jsrApi_(jsrApi), onDelete_(std::move(onDelete)) {
+  NodeApiScope scope{*this};
+  propertyId_.Error = makeNodeApiRef(getPropertyIdFromName("Error"), NodeApiPointerValueKind::String);
+  propertyId_.Object = makeNodeApiRef(getPropertyIdFromName("Object"), NodeApiPointerValueKind::String);
+  propertyId_.Proxy = makeNodeApiRef(getPropertyIdFromName("Proxy"), NodeApiPointerValueKind::String);
+  propertyId_.Symbol = makeNodeApiRef(getPropertyIdFromName("Symbol"), NodeApiPointerValueKind::String);
+  propertyId_.byteLength = makeNodeApiRef(getPropertyIdFromName("byteLength"), NodeApiPointerValueKind::String);
+  propertyId_.configurable = makeNodeApiRef(getPropertyIdFromName("configurable"), NodeApiPointerValueKind::String);
+  propertyId_.enumerable = makeNodeApiRef(getPropertyIdFromName("enumerable"), NodeApiPointerValueKind::String);
+  propertyId_.get = makeNodeApiRef(getPropertyIdFromName("get"), NodeApiPointerValueKind::String);
+  propertyId_.getOwnPropertyDescriptor =
+      makeNodeApiRef(getPropertyIdFromName("getOwnPropertyDescriptor"), NodeApiPointerValueKind::String);
+  propertyId_.has = makeNodeApiRef(getPropertyIdFromName("has"), NodeApiPointerValueKind::String);
+  propertyId_.hostFunctionSymbol = makeNodeApiRef(createSymbol("hostFunctionSymbol"), NodeApiPointerValueKind::Symbol);
+  propertyId_.hostObjectSymbol = makeNodeApiRef(createSymbol("hostObjectSymbol"), NodeApiPointerValueKind::Symbol);
+  propertyId_.length = makeNodeApiRef(getPropertyIdFromName("length"), NodeApiPointerValueKind::String);
+  propertyId_.message = makeNodeApiRef(getPropertyIdFromName("message"), NodeApiPointerValueKind::String);
+  propertyId_.ownKeys = makeNodeApiRef(getPropertyIdFromName("ownKeys"), NodeApiPointerValueKind::String);
+  propertyId_.propertyIsEnumerable =
+      makeNodeApiRef(getPropertyIdFromName("propertyIsEnumerable"), NodeApiPointerValueKind::String);
+  propertyId_.prototype = makeNodeApiRef(getPropertyIdFromName("prototype"), NodeApiPointerValueKind::String);
+  propertyId_.set = makeNodeApiRef(getPropertyIdFromName("set"), NodeApiPointerValueKind::String);
+  propertyId_.stack = makeNodeApiRef(getPropertyIdFromName("stack"), NodeApiPointerValueKind::String);
+  propertyId_.toString = makeNodeApiRef(getPropertyIdFromName("toString"), NodeApiPointerValueKind::String);
+  propertyId_.value = makeNodeApiRef(getPropertyIdFromName("value"), NodeApiPointerValueKind::String);
+  propertyId_.writable = makeNodeApiRef(getPropertyIdFromName("writable"), NodeApiPointerValueKind::String);
+
+  cachedValue_.Global = makeNodeApiRef(getGlobal(), NodeApiPointerValueKind::Object);
+  cachedValue_.Error = makeNodeApiRef(
+      getProperty(getNodeApiValue(cachedValue_.Global), getNodeApiValue(propertyId_.Error)),
+      NodeApiPointerValueKind::Object);
+}
+
+NodeApiJsiRuntime::~NodeApiJsiRuntime() {
+  if (onDelete_) {
+    onDelete_();
+  }
+}
+
+jsi::Value NodeApiJsiRuntime::evaluateJavaScript(
+    const std::shared_ptr<const jsi::Buffer> &buffer,
+    const std::string &sourceURL) {
+  return evaluatePreparedJavaScript(prepareJavaScript(buffer, sourceURL));
+}
+
+std::shared_ptr<const jsi::PreparedJavaScript> NodeApiJsiRuntime::prepareJavaScript(
+    const std::shared_ptr<const jsi::Buffer> &sourceBuffer,
+    std::string sourceURL) {
+  NodeApiScope scope{*this};
+  jsr_prepared_script script{};
+  napi_status status = jsrApi_->jsr_create_prepared_script(
+      env_,
+      sourceBuffer->data(),
+      sourceBuffer->size(),
+      [](void * /*data*/, void *deleterData) {
+        delete reinterpret_cast<std::shared_ptr<const jsi::Buffer> *>(deleterData);
+      },
+      new std::shared_ptr<const jsi::Buffer>(sourceBuffer),
+      sourceURL.c_str(),
+      &script);
+  CHECK_NAPI(status); // Not for the call to keep better automated formatting.
+  return std::make_shared<NodeApiPreparedJavaScript>(env_, script, std::move(sourceURL));
+}
+
+jsi::Value NodeApiJsiRuntime::evaluatePreparedJavaScript(const std::shared_ptr<const jsi::PreparedJavaScript> &js) {
+  NodeApiScope scope{*this};
+  auto preparedScript = static_cast<const NodeApiPreparedJavaScript *>(js.get());
+  AutoRestore<std::string> sourceURLScope{sourceURL_, preparedScript->sourceURL()};
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->jsr_prepared_script_run(env_, preparedScript->getScript(), &result));
+  return toJsiValue(result);
+}
+
+#if JSI_VERSION >= 4
+bool NodeApiJsiRuntime::drainMicrotasks(int maxMicrotasksHint) {
+  bool result{};
+  CHECK_NAPI(jsrApi_->jsr_drain_microtasks(env_, maxMicrotasksHint, &result));
+  return result;
+}
+#endif
+
+jsi::Object NodeApiJsiRuntime::global() {
+  return make<jsi::Object>(cachedValue_.Global->clone(*this));
+}
+
+std::string NodeApiJsiRuntime::description() {
+  const char *desc{};
+  CHECK_NAPI(jsrApi_->jsr_get_description(env_, &desc));
+  return desc;
+}
+
+bool NodeApiJsiRuntime::isInspectable() {
+  bool result{};
+  CHECK_NAPI(jsrApi_->jsr_is_inspectable(env_, &result));
+  return result;
+}
+
+jsi::Runtime::PointerValue *NodeApiJsiRuntime::cloneSymbol(const jsi::Runtime::PointerValue *pointerValue) {
+  return cloneNodeApiPointerValue(pointerValue);
+}
+
+#if JSI_VERSION >= 6
+jsi::Runtime::PointerValue *NodeApiJsiRuntime::cloneBigInt(const jsi::Runtime::PointerValue *pointerValue) {
+  return cloneNodeApiPointerValue(pointerValue);
+}
+#endif
+
+jsi::Runtime::PointerValue *NodeApiJsiRuntime::cloneString(const jsi::Runtime::PointerValue *pointerValue) {
+  return cloneNodeApiPointerValue(pointerValue);
+}
+
+jsi::Runtime::PointerValue *NodeApiJsiRuntime::cloneObject(const jsi::Runtime::PointerValue *pointerValue) {
+  return cloneNodeApiPointerValue(pointerValue);
+}
+
+jsi::Runtime::PointerValue *NodeApiJsiRuntime::clonePropNameID(const jsi::Runtime::PointerValue *pointerValue) {
+  return cloneNodeApiPointerValue(pointerValue);
+}
+
+jsi::PropNameID NodeApiJsiRuntime::createPropNameIDFromAscii(const char *str, size_t length) {
+  NodeApiScope scope{*this};
+  StringKey keyName{str, length};
+  auto it = propNameIDs_.find(keyName);
+  if (it != propNameIDs_.end()) {
+    return make<jsi::PropNameID>(it->second->clone(*this));
+  }
+
+  napi_value obj = createNodeApiObject();
+  napi_value propName{};
+  CHECK_NAPI(jsrApi_->napi_create_string_latin1(env_, str, length, &propName));
+  CHECK_NAPI(jsrApi_->napi_set_property(env_, obj, propName, getUndefined()));
+  napi_value props{};
+  CHECK_NAPI(jsrApi_->napi_get_all_property_names(
+      env_, obj, napi_key_own_only, napi_key_skip_symbols, napi_key_numbers_to_strings, &props));
+  napi_value propNameId = getElement(props, 0);
+  NodeApiRefHolder propNameRef = makeNodeApiRef(propNameId, NodeApiPointerValueKind::StringPropNameID, 3);
+  jsi::PropNameID result = make<jsi::PropNameID>(propNameRef.get());
+  propNameIDs_.try_emplace(StringKey(std::string(keyName.getStringView())), std::move(propNameRef));
+  return result;
+}
+
+jsi::PropNameID NodeApiJsiRuntime::createPropNameIDFromUtf8(const uint8_t *utf8, size_t length) {
+  NodeApiScope scope{*this};
+  StringKey keyName{reinterpret_cast<const char *>(utf8), length};
+  auto it = propNameIDs_.find(keyName);
+  if (it != propNameIDs_.end()) {
+    return make<jsi::PropNameID>(it->second->clone(*this));
+  }
+
+  napi_value obj = createNodeApiObject();
+  napi_value propName{};
+  CHECK_NAPI(jsrApi_->napi_create_string_utf8(env_, reinterpret_cast<const char *>(utf8), length, &propName));
+  CHECK_NAPI(jsrApi_->napi_set_property(env_, obj, propName, getUndefined()));
+  napi_value props{};
+  CHECK_NAPI(jsrApi_->napi_get_all_property_names(
+      env_, obj, napi_key_own_only, napi_key_skip_symbols, napi_key_numbers_to_strings, &props));
+  napi_value propNameId = getElement(props, 0);
+  NodeApiRefHolder propNameRef = makeNodeApiRef(propNameId, NodeApiPointerValueKind::StringPropNameID, 3);
+  jsi::PropNameID result = make<jsi::PropNameID>(propNameRef.get());
+  propNameIDs_.try_emplace(StringKey(std::string(keyName.getStringView())), std::move(propNameRef));
+  return result;
+}
+
+jsi::PropNameID NodeApiJsiRuntime::createPropNameIDFromString(const jsi::String &str) {
+  NodeApiScope scope{*this};
+  const NodeApiPointerValue *pv = static_cast<const NodeApiPointerValue *>(getPointerValue(str));
+  if (pv->getKind() == NodeApiPointerValueKind::StringPropNameID) {
+    return make<jsi::PropNameID>(pv->clone(*this));
+  }
+
+  StringKey keyName(utf8(str));
+  auto it = propNameIDs_.find(keyName);
+  if (it != propNameIDs_.end()) {
+    return make<jsi::PropNameID>(it->second->clone(*this));
+  }
+
+  napi_value napiStr = const_cast<NodeApiPointerValue *>(pv)->getValue(*this);
+
+  napi_value obj = createNodeApiObject();
+  setProperty(obj, napiStr, getUndefined());
+  napi_value props{};
+  CHECK_NAPI(jsrApi_->napi_get_all_property_names(
+      env_, obj, napi_key_own_only, napi_key_skip_symbols, napi_key_numbers_to_strings, &props));
+  napi_value propNameId = getElement(props, 0);
+  NodeApiRefHolder propNameRef = makeNodeApiRef(propNameId, NodeApiPointerValueKind::StringPropNameID, 3);
+  jsi::PropNameID result = make<jsi::PropNameID>(propNameRef.get());
+  propNameIDs_.try_emplace(StringKey(std::string(keyName.getStringView())), std::move(propNameRef));
+  return result;
+}
+
+#if JSI_VERSION >= 5
+jsi::PropNameID NodeApiJsiRuntime::createPropNameIDFromSymbol(const jsi::Symbol &sym) {
+  // TODO: Should we ensure uniqueness of symbols?
+  return cloneAs<jsi::PropNameID>(sym);
+}
+#endif
+
+std::string NodeApiJsiRuntime::utf8(const jsi::PropNameID &id) {
+  NodeApiScope scope{*this};
+  return propertyIdToStdString(getNodeApiValue(id));
+}
+
+bool NodeApiJsiRuntime::compare(const jsi::PropNameID &lhs, const jsi::PropNameID &rhs) {
+  NodeApiScope scope{*this};
+  return getPointerValue(lhs) == getPointerValue(rhs) || strictEquals(getNodeApiValue(lhs), getNodeApiValue(rhs));
+}
+
+std::string NodeApiJsiRuntime::symbolToString(const jsi::Symbol &sym) {
+  NodeApiScope scope{*this};
+  return symbolToStdString(getNodeApiValue(sym));
+}
+
+#if JSI_VERSION >= 8
+jsi::BigInt NodeApiJsiRuntime::createBigIntFromInt64(int64_t val) {
+  NodeApiScope scope{*this};
+  napi_value bigint{};
+  CHECK_NAPI(jsrApi_->napi_create_bigint_int64(env_, val, &bigint));
+  return makeJsiPointer<jsi::BigInt>(bigint);
+}
+
+jsi::BigInt NodeApiJsiRuntime::createBigIntFromUint64(uint64_t val) {
+  NodeApiScope scope{*this};
+  napi_value bigint{};
+  CHECK_NAPI(jsrApi_->napi_create_bigint_uint64(env_, val, &bigint));
+  return makeJsiPointer<jsi::BigInt>(bigint);
+}
+
+bool NodeApiJsiRuntime::bigintIsInt64(const jsi::BigInt &bigint) {
+  NodeApiScope scope{*this};
+  napi_value value = getNodeApiValue(bigint);
+  bool lossless{false};
+  int64_t result{};
+  CHECK_NAPI(jsrApi_->napi_get_value_bigint_int64(env_, value, &result, &lossless));
+  return lossless;
+}
+
+bool NodeApiJsiRuntime::bigintIsUint64(const jsi::BigInt &bigint) {
+  NodeApiScope scope{*this};
+  napi_value value = getNodeApiValue(bigint);
+  bool lossless{false};
+  uint64_t result{};
+  CHECK_NAPI(jsrApi_->napi_get_value_bigint_uint64(env_, value, &result, &lossless));
+  return lossless;
+}
+
+uint64_t NodeApiJsiRuntime::truncate(const jsi::BigInt &bigint) {
+  NodeApiScope scope{*this};
+  napi_value value = getNodeApiValue(bigint);
+  bool lossless{false};
+  uint64_t result{};
+  CHECK_NAPI(jsrApi_->napi_get_value_bigint_uint64(env_, value, &result, &lossless));
+  return result;
+}
+
+inline uint32_t constexpr maxCharsPerDigitInRadix(int32_t radix) {
+  // To compute the lower bound of bits in a BigIntDigitType "covered" by a
+  // char. For power of 2 radixes, it is known (exactly) that each character
+  // covers log2(radix) bits. For non-power of 2 radixes, a lower bound is
+  // log2(greatest power of 2 that is less than radix).
+  uint32_t minNumBitsPerChar = radix < 4 ? 1 : radix < 8 ? 2 : radix < 16 ? 3 : radix < 32 ? 4 : 5;
+
+  // With minNumBitsPerChar being the lower bound estimate of how many bits each
+  // char can represent, the upper bound of how many chars "fit" in a bigint
+  // digit is ceil(sizeofInBits(bigint digit) / minNumBitsPerChar).
+  uint32_t numCharsPerDigits = static_cast<uint32_t>(sizeof(uint64_t)) / (1 << minNumBitsPerChar);
+
+  return numCharsPerDigits;
+}
+
+// Return the high 32 bits of a 64 bit value.
+constexpr inline uint32_t Hi_32(uint64_t Value) {
+  return static_cast<uint32_t>(Value >> 32);
+}
+
+// Return the low 32 bits of a 64 bit value.
+constexpr inline uint32_t Lo_32(uint64_t Value) {
+  return static_cast<uint32_t>(Value);
+}
+
+// Make a 64-bit integer from a high / low pair of 32-bit integers.
+constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
+  return ((uint64_t)High << 32) | (uint64_t)Low;
+}
+
+jsi::String NodeApiJsiRuntime::bigintToString(const jsi::BigInt &bigint, int32_t radix) {
+  NodeApiScope scope{*this};
+  if (radix < 2 || radix > 36) {
+    throw makeJSError("Invalid radix ", radix, " to BigInt.toString");
+  }
+
+  napi_value value = getNodeApiValue(bigint);
+  size_t wordCount{};
+  CHECK_NAPI(jsrApi_->napi_get_value_bigint_words(env_, value, nullptr, &wordCount, nullptr));
+  uint64_t stackWords[8]{};
+  std::unique_ptr<uint64_t[]> heapWords;
+  uint64_t *words = stackWords;
+  if (wordCount > std::size(stackWords)) {
+    heapWords = std::unique_ptr<uint64_t[]>(new uint64_t[wordCount]);
+    words = heapWords.get();
+  }
+  int32_t signBit{};
+  CHECK_NAPI(jsrApi_->napi_get_value_bigint_words(env_, value, &signBit, &wordCount, words));
+
+  if (wordCount == 0) {
+    return createStringFromAscii("0", 1);
+  }
+
+  // avoid trashing the heap by pre-allocating the largest possible string
+  // returned by this function. The "1" below is to account for a possible "-"
+  // sign.
+  std::string digits;
+  digits.reserve(1 + wordCount * maxCharsPerDigitInRadix(radix));
+
+  // Use 32-bit values for calculations to get 64-bit results.
+  // For the little-endian machines we just cast the words array.
+  // TODO: Add support for big-endian.
+  uint32_t *halfWords = reinterpret_cast<uint32_t *>(words);
+  size_t count = wordCount * 2;
+  for (size_t i = count; i > 0 && halfWords[i - 1] == 0; --i) {
+    --count;
+  }
+
+  uint32_t divisor = static_cast<uint32_t>(radix);
+  uint32_t remainder = 0;
+  uint64_t word0 = words[0];
+
+  do {
+    // We rewrite the halfWords array as we divide it by radix.
+    if (count <= 2) {
+      remainder = word0 % divisor;
+      word0 = word0 / divisor;
+    } else {
+      for (size_t i = count; i > 0; --i) {
+        uint64_t partialDividend = Make_64(remainder, halfWords[i - 1]);
+        if (partialDividend == 0) {
+          halfWords[i] = 0;
+          remainder = 0;
+          if (i == count) {
+            if (--count == 2) {
+              word0 = words[0];
+            }
+          }
+        } else if (partialDividend < divisor) {
+          halfWords[i] = 0;
+          remainder = Lo_32(partialDividend);
+          if (i == count) {
+            if (--count == 2) {
+              word0 = words[0];
+            }
+          }
+        } else if (partialDividend == divisor) {
+          halfWords[i] = 1;
+          remainder = 0;
+        } else {
+          halfWords[i] = Lo_32(partialDividend / divisor);
+          remainder = Lo_32(partialDividend % divisor);
+        }
+      }
+    }
+
+    if (remainder < 10) {
+      digits.push_back(static_cast<char>('0' + remainder));
+    } else {
+      digits.push_back(static_cast<char>('a' + remainder - 10));
+    }
+  } while (count > 2 || word0 != 0);
+
+  if (signBit) {
+    digits.push_back('-');
+  }
+
+  std::reverse(digits.begin(), digits.end());
+  return createStringFromAscii(digits.data(), digits.size());
+}
+#endif
+
+jsi::String NodeApiJsiRuntime::createStringFromAscii(const char *str, size_t length) {
+  NodeApiScope scope{*this};
+  return makeJsiPointer<jsi::String>(createStringLatin1({str, length}));
+}
+
+jsi::String NodeApiJsiRuntime::createStringFromUtf8(const uint8_t *str, size_t length) {
+  NodeApiScope scope{*this};
+  return makeJsiPointer<jsi::String>(createStringUtf8(str, length));
+}
+
+std::string NodeApiJsiRuntime::utf8(const jsi::String &str) {
+  NodeApiScope scope{*this};
+  return stringToStdString(getNodeApiValue(str));
+}
+
+jsi::Object NodeApiJsiRuntime::createObject() {
+  NodeApiScope scope{*this};
+  return makeJsiPointer<jsi::Object>(createNodeApiObject());
+}
+
+jsi::Object NodeApiJsiRuntime::createObject(std::shared_ptr<jsi::HostObject> hostObject) {
+  NodeApiScope scope{*this};
+  // The hostObjectHolder keeps the hostObject as external data.
+  // Then, the hostObjectHolder is wrapped up by a Proxy object to provide access
+  // to the hostObject's get, set, and getPropertyNames methods.
+  // There is a special symbol property ID, 'hostObjectSymbol', used to access the hostObjectWrapper from the Proxy.
+  napi_value hostObjectHolder =
+      createExternalObject(std::make_unique<std::shared_ptr<jsi::HostObject>>(std::move(hostObject)));
+  napi_value obj = createNodeApiObject();
+  setProperty(obj, getNodeApiValue(propertyId_.hostObjectSymbol), hostObjectHolder);
+  if (!cachedValue_.ProxyConstructor) {
+    cachedValue_.ProxyConstructor = makeNodeApiRef(
+        getProperty(getNodeApiValue(cachedValue_.Global), getNodeApiValue(propertyId_.Proxy)),
+        NodeApiPointerValueKind::Object);
+  }
+  napi_value args[] = {obj, getHostObjectProxyHandler()};
+  napi_value proxy = constructObject(getNodeApiValue(cachedValue_.ProxyConstructor), args);
+  return makeJsiPointer<jsi::Object>(proxy);
+}
+
+std::shared_ptr<jsi::HostObject> NodeApiJsiRuntime::getHostObject(const jsi::Object &obj) {
+  NodeApiScope scope{*this};
+  return getJsiHostObject(getNodeApiValue(obj));
+}
+
+jsi::HostFunctionType &NodeApiJsiRuntime::getHostFunction(const jsi::Function &func) {
+  NodeApiScope scope{*this};
+  napi_value hostFunctionHolder = getProperty(getNodeApiValue(func), getNodeApiValue((propertyId_.hostFunctionSymbol)));
+  if (typeOf(hostFunctionHolder) == napi_valuetype::napi_external) {
+    return static_cast<HostFunctionWrapper *>(getExternalData(hostFunctionHolder))->hostFunction();
+  } else {
+    throw jsi::JSINativeException("getHostFunction() can only be called with HostFunction.");
+  }
+}
+
+#if JSI_VERSION >= 7
+bool NodeApiJsiRuntime::hasNativeState(const jsi::Object &obj) {
+  NodeApiScope scope{*this};
+  void *nativeState{};
+  napi_status status = jsrApi_->napi_unwrap(env_, getNodeApiValue(obj), &nativeState);
+  return status == napi_ok && nativeState != nullptr;
+}
+
+std::shared_ptr<jsi::NativeState> NodeApiJsiRuntime::getNativeState(const jsi::Object &obj) {
+  NodeApiScope scope{*this};
+  void *nativeState{};
+  CHECK_NAPI(jsrApi_->napi_unwrap(env_, getNodeApiValue(obj), &nativeState));
+  if (nativeState != nullptr) {
+    return *reinterpret_cast<std::shared_ptr<jsi::NativeState> *>(nativeState);
+  } else {
+    return std::shared_ptr<jsi::NativeState>();
+  }
+}
+
+void NodeApiJsiRuntime::setNativeState(const jsi::Object &obj, std::shared_ptr<jsi::NativeState> state) {
+  NodeApiScope scope{*this};
+  if (hasNativeState(obj)) {
+    void *nativeState{};
+    CHECK_NAPI(jsrApi_->napi_remove_wrap(env_, getNodeApiValue(obj), &nativeState));
+    if (nativeState != nullptr) {
+      std::shared_ptr<jsi::NativeState> oldState{
+          std::move(*reinterpret_cast<std::shared_ptr<jsi::NativeState> *>(nativeState))};
+    }
+  }
+
+  if (state) {
+    CHECK_NAPI(jsrApi_->napi_wrap(
+        env_,
+        getNodeApiValue(obj),
+        new std::shared_ptr<jsi::NativeState>(std::move(state)),
+        [](napi_env /*env*/, void *data, void * /*finalize_hint*/) {
+          std::shared_ptr<jsi::NativeState> oldState{
+              std::move(*reinterpret_cast<std::shared_ptr<jsi::NativeState> *>(data))};
+        },
+        nullptr,
+        nullptr));
+  }
+}
+#endif
+
+jsi::Value NodeApiJsiRuntime::getProperty(const jsi::Object &obj, const jsi::PropNameID &name) {
+  NodeApiScope scope{*this};
+  return toJsiValue(getProperty(getNodeApiValue(obj), getNodeApiValue(name)));
+}
+
+jsi::Value NodeApiJsiRuntime::getProperty(const jsi::Object &obj, const jsi::String &name) {
+  NodeApiScope scope{*this};
+  return toJsiValue(getProperty(getNodeApiValue(obj), getNodeApiValue(name)));
+}
+
+bool NodeApiJsiRuntime::hasProperty(const jsi::Object &obj, const jsi::PropNameID &name) {
+  NodeApiScope scope{*this};
+  return hasProperty(getNodeApiValue(obj), getNodeApiValue(name));
+}
+
+bool NodeApiJsiRuntime::hasProperty(const jsi::Object &obj, const jsi::String &name) {
+  NodeApiScope scope{*this};
+  return hasProperty(getNodeApiValue(obj), getNodeApiValue(name));
+}
+
+void NodeApiJsiRuntime::setPropertyValue(
+    JSI_CONST_10 jsi::Object &obj,
+    const jsi::PropNameID &name,
+    const jsi::Value &value) {
+  NodeApiScope scope{*this};
+  setProperty(getNodeApiValue(obj), getNodeApiValue(name), getNodeApiValue(value));
+}
+
+void NodeApiJsiRuntime::setPropertyValue(
+    JSI_CONST_10 jsi::Object &obj,
+    const jsi::String &name,
+    const jsi::Value &value) {
+  NodeApiScope scope{*this};
+  setProperty(getNodeApiValue(obj), getNodeApiValue(name), getNodeApiValue(value));
+}
+
+bool NodeApiJsiRuntime::isArray(const jsi::Object &obj) const {
+  NodeApiScope scope{*this};
+  return isArray(getNodeApiValue(obj));
+}
+
+bool NodeApiJsiRuntime::isArrayBuffer(const jsi::Object &obj) const {
+  NodeApiScope scope{*this};
+  bool result{};
+  CHECK_NAPI(jsrApi_->napi_is_arraybuffer(env_, getNodeApiValue(obj), &result));
+  return result;
+}
+
+bool NodeApiJsiRuntime::isFunction(const jsi::Object &obj) const {
+  NodeApiScope scope{*this};
+  return typeOf(getNodeApiValue(obj)) == napi_valuetype::napi_function;
+}
+
+bool NodeApiJsiRuntime::isHostObject(const jsi::Object &obj) const {
+  NodeApiScope scope{*this};
+  napi_value hostObjectHolder = getProperty(getNodeApiValue(obj), getNodeApiValue(propertyId_.hostObjectSymbol));
+  if (typeOf(hostObjectHolder) == napi_valuetype::napi_external) {
+    return getExternalData(hostObjectHolder) != nullptr;
+  } else {
+    return false;
+  }
+}
+
+bool NodeApiJsiRuntime::isHostFunction(const jsi::Function &func) const {
+  NodeApiScope scope{*this};
+  napi_value hostFunctionHolder = getProperty(getNodeApiValue(func), getNodeApiValue(propertyId_.hostFunctionSymbol));
+  if (typeOf(hostFunctionHolder) == napi_valuetype::napi_external) {
+    return getExternalData(hostFunctionHolder) != nullptr;
+  } else {
+    return false;
+  }
+}
+
+jsi::Array NodeApiJsiRuntime::getPropertyNames(const jsi::Object &obj) {
+  NodeApiScope scope{*this};
+  napi_value properties;
+  CHECK_NAPI(jsrApi_->napi_get_all_property_names(
+      env_,
+      getNodeApiValue(obj),
+      napi_key_collection_mode::napi_key_include_prototypes,
+      napi_key_filter(napi_key_enumerable | napi_key_skip_symbols),
+      napi_key_numbers_to_strings,
+      &properties));
+  return makeJsiPointer<jsi::Object>(properties).asArray(*this);
+}
+
+jsi::WeakObject NodeApiJsiRuntime::createWeakObject(const jsi::Object &obj) {
+  NodeApiScope scope{*this};
+  return make<jsi::WeakObject>(NodeApiRefCountedPointerValue::make(
+      *const_cast<NodeApiJsiRuntime *>(this), getNodeApiValue(obj), NodeApiPointerValueKind::WeakObject));
+}
+
+jsi::Value NodeApiJsiRuntime::lockWeakObject(JSI_NO_CONST_3 JSI_CONST_10 jsi::WeakObject &weakObject) {
+  NodeApiScope scope{*this};
+  napi_value value = getNodeApiValue(weakObject);
+  if (value) {
+    return toJsiValue(value);
+  } else {
+    return jsi::Value::undefined();
+  }
+}
+
+jsi::Array NodeApiJsiRuntime::createArray(size_t length) {
+  NodeApiScope scope{*this};
+  return makeJsiPointer<jsi::Object>(createNodeApiArray(length)).asArray(*this);
+}
+
+#if JSI_VERSION >= 9
+jsi::ArrayBuffer NodeApiJsiRuntime::createArrayBuffer(std::shared_ptr<jsi::MutableBuffer> buffer) {
+  NodeApiScope scope{*this};
+  napi_value result{};
+  void *data = buffer->data();
+  size_t size = buffer->size();
+  CHECK_NAPI(jsrApi_->napi_create_external_arraybuffer(
+      env_,
+      data,
+      size,
+      [](napi_env /*env*/, void * /*data*/, void *finalizeHint) {
+        std::shared_ptr<jsi::MutableBuffer> buffer{
+            std::move(*reinterpret_cast<std::shared_ptr<jsi::MutableBuffer> *>(finalizeHint))};
+      },
+      new std::shared_ptr<jsi::MutableBuffer>{std::move(buffer)},
+      &result));
+  return makeJsiPointer<jsi::Object>(result).getArrayBuffer(*this);
+}
+#endif
+
+size_t NodeApiJsiRuntime::size(const jsi::Array &arr) {
+  NodeApiScope scope{*this};
+  return getArrayLength(getNodeApiValue(arr));
+}
+
+size_t NodeApiJsiRuntime::size(const jsi::ArrayBuffer &arrBuf) {
+  NodeApiScope scope{*this};
+  size_t result{};
+  CHECK_NAPI(jsrApi_->napi_get_arraybuffer_info(env_, getNodeApiValue(arrBuf), nullptr, &result));
+  return result;
+}
+
+uint8_t *NodeApiJsiRuntime::data(const jsi::ArrayBuffer &arrBuf) {
+  NodeApiScope scope{*this};
+  uint8_t *result{};
+  CHECK_NAPI(
+      jsrApi_->napi_get_arraybuffer_info(env_, getNodeApiValue(arrBuf), reinterpret_cast<void **>(&result), nullptr));
+  return result;
+}
+
+jsi::Value NodeApiJsiRuntime::getValueAtIndex(const jsi::Array &arr, size_t index) {
+  NodeApiScope scope{*this};
+  return toJsiValue(getElement(getNodeApiValue(arr), index));
+}
+
+void NodeApiJsiRuntime::setValueAtIndexImpl(JSI_CONST_10 jsi::Array &arr, size_t index, const jsi::Value &value) {
+  NodeApiScope scope{*this};
+  setElement(getNodeApiValue(arr), static_cast<uint32_t>(index), getNodeApiValue(value));
+}
+
+jsi::Function NodeApiJsiRuntime::createFunctionFromHostFunction(
+    const jsi::PropNameID &name,
+    unsigned int paramCount,
+    jsi::HostFunctionType func) {
+  NodeApiScope scope{*this};
+  auto hostFunctionWrapper = std::make_unique<HostFunctionWrapper>(std::move(func), *this);
+  napi_value function = createExternalFunction(
+      getNodeApiValue(name), static_cast<int32_t>(paramCount), jsiHostFunctionCallback, hostFunctionWrapper.get());
+
+  const napi_value hostFunctionHolder = createExternalObject(std::move(hostFunctionWrapper));
+  setProperty(
+      function,
+      getNodeApiValue(propertyId_.hostFunctionSymbol),
+      hostFunctionHolder,
+      napi_property_attributes::napi_default);
+  return makeJsiPointer<jsi::Object>(function).getFunction(*this);
+}
+
+jsi::Value
+NodeApiJsiRuntime::call(const jsi::Function &func, const jsi::Value &jsThis, const jsi::Value *args, size_t count) {
+  NodeApiScope scope{*this};
+  return toJsiValue(callFunction(
+      getNodeApiValue(jsThis), getNodeApiValue(func), NodeApiValueArgs(*this, span<const jsi::Value>(args, count))));
+}
+
+jsi::Value NodeApiJsiRuntime::callAsConstructor(const jsi::Function &func, const jsi::Value *args, size_t count) {
+  NodeApiScope scope{*this};
+  return toJsiValue(
+      constructObject(getNodeApiValue(func), NodeApiValueArgs(*this, span<jsi::Value const>(args, count))));
+}
+
+jsi::Runtime::ScopeState *NodeApiJsiRuntime::pushScope() {
+  NodeApiEnvScope scope{getEnv()};
+  napi_handle_scope result{};
+  CHECK_NAPI(jsrApi_->napi_open_handle_scope(env_, &result));
+  pushPointerValueScope();
+  return reinterpret_cast<jsi::Runtime::ScopeState *>(result);
+}
+
+void NodeApiJsiRuntime::popScope(jsi::Runtime::ScopeState *state) {
+  NodeApiEnvScope scope{getEnv()};
+  popPointerValueScope();
+  CHECK_NAPI(jsrApi_->napi_close_handle_scope(env_, reinterpret_cast<napi_handle_scope>(state)));
+}
+
+bool NodeApiJsiRuntime::strictEquals(const jsi::Symbol &a, const jsi::Symbol &b) const {
+  NodeApiScope scope{*this};
+  return strictEquals(getNodeApiValue(a), getNodeApiValue(b));
+}
+
+#if JSI_VERSION >= 6
+bool NodeApiJsiRuntime::strictEquals(const jsi::BigInt &a, const jsi::BigInt &b) const {
+  NodeApiScope scope{*this};
+  return strictEquals(getNodeApiValue(a), getNodeApiValue(b));
+}
+#endif
+
+bool NodeApiJsiRuntime::strictEquals(const jsi::String &a, const jsi::String &b) const {
+  NodeApiScope scope{*this};
+  return strictEquals(getNodeApiValue(a), getNodeApiValue(b));
+}
+
+bool NodeApiJsiRuntime::strictEquals(const jsi::Object &a, const jsi::Object &b) const {
+  NodeApiScope scope{*this};
+  return strictEquals(getNodeApiValue(a), getNodeApiValue(b));
+}
+
+bool NodeApiJsiRuntime::instanceOf(const jsi::Object &obj, const jsi::Function &func) {
+  NodeApiScope scope{*this};
+  return instanceOf(getNodeApiValue(obj), getNodeApiValue(func));
+}
+
+#if JSI_VERSION >= 11
+void NodeApiJsiRuntime::setExternalMemoryPressure(const jsi::Object &/*obj*/, size_t /*amount*/) {
+  // TODO: implement
+}
+#endif
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::NodeApiScope implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::NodeApiScope::NodeApiScope(const NodeApiJsiRuntime &runtime) noexcept
+    : NodeApiScope(const_cast<NodeApiJsiRuntime &>(runtime)) {}
+
+NodeApiJsiRuntime::NodeApiScope::NodeApiScope(NodeApiJsiRuntime &runtime) noexcept
+    : runtime_(runtime), envScope_(runtime_.getEnv()), scopeState_(runtime_.pushScope()) {}
+
+NodeApiJsiRuntime::NodeApiScope::~NodeApiScope() noexcept {
+  runtime_.popScope(scopeState_);
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::NodeApiPointerValueScope implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::NodeApiPointerValueScope::NodeApiPointerValueScope(NodeApiJsiRuntime &runtime) noexcept
+    : runtime_(runtime) {
+  runtime_.pushPointerValueScope();
+}
+
+NodeApiJsiRuntime::NodeApiPointerValueScope::~NodeApiPointerValueScope() noexcept {
+  runtime_.popPointerValueScope();
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::AutoRestore implementation
+//=====================================================================================================================
+
+template <typename T>
+NodeApiJsiRuntime::AutoRestore<T>::AutoRestore(T &varRef, T newValue)
+    : varRef_{varRef}, oldValue_{std::exchange(varRef, newValue)} {}
+
+template <typename T>
+NodeApiJsiRuntime::AutoRestore<T>::~AutoRestore() {
+  varRef_ = oldValue_;
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::NodeApiStackOnlyPointerValue implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::NodeApiStackOnlyPointerValue::NodeApiStackOnlyPointerValue(
+    napi_value value,
+    NodeApiPointerValueKind pointerKind) noexcept
+    : value_(value), pointerKind_(pointerKind) {}
+
+// Intentionally do nothing.
+void NodeApiJsiRuntime::NodeApiStackOnlyPointerValue::invalidate() noexcept {}
+
+NodeApiJsiRuntime::NodeApiRefCountedPointerValue *NodeApiJsiRuntime::NodeApiStackOnlyPointerValue::clone(
+    NodeApiJsiRuntime &runtime) const {
+  return NodeApiRefCountedPointerValue::make(runtime, value_, pointerKind_);
+}
+
+napi_value NodeApiJsiRuntime::NodeApiStackOnlyPointerValue::getValue(NodeApiJsiRuntime & /*runtime*/) noexcept {
+  return value_;
+}
+
+NodeApiJsiRuntime::NodeApiPointerValueKind NodeApiJsiRuntime::NodeApiStackOnlyPointerValue::getKind() const noexcept {
+  return pointerKind_;
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::NodeApiPointerValue implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::NodeApiRefCountedPointerValue::NodeApiRefCountedPointerValue(
+    napi_value value,
+    NodeApiJsiRuntime::NodeApiPointerValueKind pointerKind,
+    int32_t initialRefCount) noexcept
+    : value_(value), pointerKind_(pointerKind), refCount_(initialRefCount) {}
+
+/*static*/ NodeApiJsiRuntime::NodeApiRefCountedPointerValue *NodeApiJsiRuntime::NodeApiRefCountedPointerValue::make(
+    NodeApiJsiRuntime &runtime,
+    napi_value value,
+    NodeApiJsiRuntime::NodeApiPointerValueKind pointerKind,
+    int32_t initialRefCount) {
+  NodeApiRefCountedPointerValue *result = new NodeApiRefCountedPointerValue(value, pointerKind, initialRefCount);
+  runtime.addStackValue(NodeApiStackValueHolder(result));
+  return result;
+}
+
+/*static*/ NodeApiJsiRuntime::NodeApiRefCountedPointerValue *
+NodeApiJsiRuntime::NodeApiRefCountedPointerValue::makeNodeApiRef(
+    NodeApiJsiRuntime &runtime,
+    napi_value value,
+    NodeApiPointerValueKind pointerKind,
+    int32_t initialRefCount) {
+  return make(runtime, value, pointerKind, initialRefCount)->createNodeApiRef(runtime);
+}
+
+void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::invalidate() noexcept {
+  decRefCount();
+}
+
+NodeApiJsiRuntime::NodeApiRefCountedPointerValue *NodeApiJsiRuntime::NodeApiRefCountedPointerValue::clone(
+    NodeApiJsiRuntime & /*runtime*/) const {
+  incRefCount();
+  return const_cast<NodeApiRefCountedPointerValue *>(this);
+}
+
+napi_value NodeApiJsiRuntime::NodeApiRefCountedPointerValue::getValue(NodeApiJsiRuntime &runtime) noexcept {
+  if (value_ != nullptr) {
+    return value_;
+  }
+
+  if (ref_ == nullptr) {
+    return nullptr;
+  }
+
+  JSRuntimeApi *jsrApi = JSRuntimeApi::current();
+  if (pointerKind_ == NodeApiPointerValueKind::Object || pointerKind_ == NodeApiPointerValueKind::WeakObject) {
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_get_reference_value(runtime.getEnv(), ref_, &value_));
+  } else {
+    napi_value obj{};
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_get_reference_value(runtime.getEnv(), ref_, &obj));
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_get_named_property(runtime.getEnv(), obj, kPrimitivePropertyName, &value_));
+  }
+
+  if (value_ != nullptr) {
+    runtime.addStackValue(NodeApiStackValueHolder(this));
+    incRefCount();
+  }
+
+  return value_;
+}
+
+NodeApiJsiRuntime::NodeApiPointerValueKind NodeApiJsiRuntime::NodeApiRefCountedPointerValue::getKind() const noexcept {
+  return pointerKind_;
+}
+
+/*static*/ bool NodeApiJsiRuntime::NodeApiRefCountedPointerValue::usedByJsiPointer(
+    NodeApiRefCountedPointerValue *ptr) noexcept {
+  if (ptr == nullptr)
+    return false;
+  const int32_t internalRefCount = (ptr->value_ != nullptr ? 1 : 0) + (ptr->ref_ != nullptr ? 1 : 0);
+  const int32_t refCount = ptr->refCount_.load(std::memory_order_acquire);
+  return refCount > internalRefCount;
+}
+
+/*static*/ void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::deleteStackValue(
+    NodeApiRefCountedPointerValue *ptr) noexcept {
+  if (ptr != nullptr && ptr->value_ != nullptr) {
+    ptr->value_ = nullptr;
+    ptr->decRefCount();
+  }
+}
+
+void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::convertToNodeApiRef(NodeApiJsiRuntime &runtime) noexcept {
+  if (value_ == nullptr) {
+    return;
+  }
+
+  if (ref_ == nullptr && usedByJsiPointer(this)) {
+    createNodeApiRef(runtime);
+    runtime.addRef(NodeApiRefHolder(this));
+    value_ = nullptr;
+    return;
+  }
+
+  value_ = nullptr;
+  decRefCount();
+  return;
+}
+
+/*static*/ void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::deleteNodeApiRef(
+    NodeApiRefCountedPointerValue *ptr) noexcept {
+  if (ptr != nullptr && ptr->ref_ != nullptr) {
+    ptr->ref_ = nullptr;
+    ptr->decRefCount();
+  }
+}
+
+/*static*/ void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::deleteNodeApiRef(
+    NodeApiRefCountedPointerValue *ptr,
+    NodeApiJsiRuntime &runtime) noexcept {
+  if (ptr != nullptr && ptr->ref_ != nullptr) {
+    CHECK_NAPI_ELSE_CRASH(JSRuntimeApi::current()->napi_delete_reference(runtime.getEnv(), ptr->ref_));
+    ptr->ref_ = nullptr;
+    ptr->decRefCount();
+  }
+}
+
+void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::incRefCount() const noexcept {
+  refCount_.fetch_add(1, std::memory_order_relaxed);
+}
+
+void NodeApiJsiRuntime::NodeApiRefCountedPointerValue::decRefCount() const noexcept {
+  int32_t count = refCount_.fetch_sub(1, std::memory_order_release) - 1;
+  if (count == 0) {
+    std::atomic_thread_fence(std::memory_order_acquire);
+    delete this;
+  }
+}
+
+NodeApiJsiRuntime::NodeApiRefCountedPointerValue *NodeApiJsiRuntime::NodeApiRefCountedPointerValue::createNodeApiRef(
+    NodeApiJsiRuntime &runtime) {
+  JSRuntimeApi *jsrApi = JSRuntimeApi::current();
+  CHECK_ELSE_CRASH(value_ != nullptr, "value_ must not be null");
+  CHECK_ELSE_CRASH(ref_ == nullptr, "ref_ must be null");
+  if (pointerKind_ == NodeApiPointerValueKind::Object) {
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_create_reference(runtime.getEnv(), value_, 1, &ref_));
+  } else if (pointerKind_ != NodeApiPointerValueKind::WeakObject) {
+    napi_value obj{};
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_create_object(runtime.getEnv(), &obj));
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_set_named_property(runtime.getEnv(), obj, kPrimitivePropertyName, value_));
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_create_reference(runtime.getEnv(), obj, 1, &ref_));
+  } else {
+    CHECK_NAPI_ELSE_CRASH(jsrApi->napi_create_reference(runtime.getEnv(), value_, 0, &ref_));
+  }
+  return this;
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::SmallBuffer implementation
+//=====================================================================================================================
+
+template <typename T, size_t InplaceSize>
+NodeApiJsiRuntime::SmallBuffer<T, InplaceSize>::SmallBuffer(size_t size) noexcept
+    : size_{size}, heapData_{size_ > InplaceSize ? std::make_unique<T[]>(size_) : nullptr} {}
+
+template <typename T, size_t InplaceSize>
+T *NodeApiJsiRuntime::SmallBuffer<T, InplaceSize>::data() noexcept {
+  return heapData_ ? heapData_.get() : stackData_.data();
+}
+
+template <typename T, size_t InplaceSize>
+size_t NodeApiJsiRuntime::SmallBuffer<T, InplaceSize>::size() const noexcept {
+  return size_;
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::NodeApiValueArgs implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::NodeApiValueArgs::NodeApiValueArgs(NodeApiJsiRuntime &runtime, span<const jsi::Value> args)
+    : args_{args.size()} {
+  napi_value *jsArgs = args_.data();
+  for (size_t i = 0; i < args.size(); ++i) {
+    jsArgs[i] = runtime.getNodeApiValue(args[i]);
+  }
+}
+
+NodeApiJsiRuntime::NodeApiValueArgs::operator span<napi_value>() {
+  return span<napi_value>{args_.data(), args_.size()};
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::JsiValueView implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::JsiValueView::JsiValueView(NodeApiJsiRuntime *runtime, napi_value jsValue)
+    : value_{initValue(runtime, jsValue, std::addressof(pointerStore_))} {}
+
+NodeApiJsiRuntime::JsiValueView::operator const jsi::Value &() const noexcept {
+  return value_;
+}
+
+/*static*/ jsi::Value
+NodeApiJsiRuntime::JsiValueView::initValue(NodeApiJsiRuntime *runtime, napi_value value, StoreType *store) {
+  switch (runtime->typeOf(value)) {
+    case napi_valuetype::napi_undefined:
+      return jsi::Value::undefined();
+    case napi_valuetype::napi_null:
+      return jsi::Value::null();
+    case napi_valuetype::napi_boolean:
+      return jsi::Value{runtime->getValueBool(value)};
+    case napi_valuetype::napi_number:
+      return jsi::Value{runtime->getValueDouble(value)};
+    case napi_valuetype::napi_string:
+      return make<jsi::String>(new (store) NodeApiStackOnlyPointerValue(value, NodeApiPointerValueKind::String));
+    case napi_valuetype::napi_symbol:
+      return make<jsi::Symbol>(new (store) NodeApiStackOnlyPointerValue(value, NodeApiPointerValueKind::Symbol));
+    case napi_valuetype::napi_object:
+    case napi_valuetype::napi_function:
+    case napi_valuetype::napi_external:
+      return make<jsi::Object>(new (store) NodeApiStackOnlyPointerValue(value, NodeApiPointerValueKind::Object));
+#if JSI_VERSION >= 8
+    case napi_valuetype::napi_bigint:
+      return make<jsi::BigInt>(new (store) NodeApiStackOnlyPointerValue(value, NodeApiPointerValueKind::BigInt));
+#endif
+    default:
+      throw jsi::JSINativeException("Unexpected value type");
+  }
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::JsiValueViewArgs implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::JsiValueViewArgs::JsiValueViewArgs(NodeApiJsiRuntime *runtime, span<napi_value> args) noexcept
+    : pointerStore_{args.size()}, args_{args.size()} {
+  JsiValueView::StoreType *pointerStore = pointerStore_.data();
+  jsi::Value *jsiArgs = args_.data();
+  for (size_t i = 0; i < args_.size(); ++i) {
+    jsiArgs[i] = JsiValueView::initValue(runtime, args[i], std::addressof(pointerStore[i]));
+  }
+}
+
+jsi::Value const *NodeApiJsiRuntime::JsiValueViewArgs::data() noexcept {
+  return args_.data();
+}
+
+size_t NodeApiJsiRuntime::JsiValueViewArgs::size() const noexcept {
+  return args_.size();
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::PropNameIDView implementation
+//=====================================================================================================================
+
+// TODO: account for symbol
+NodeApiJsiRuntime::PropNameIDView::PropNameIDView(NodeApiJsiRuntime * /*runtime*/, napi_value propertyId) noexcept
+    : propertyId_{make<jsi::PropNameID>(new(std::addressof(
+          pointerStore_)) NodeApiStackOnlyPointerValue(propertyId, NodeApiPointerValueKind::StringPropNameID))} {}
+
+NodeApiJsiRuntime::PropNameIDView::operator jsi::PropNameID const &() const noexcept {
+  return propertyId_;
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime::HostFunctionWrapper implementation
+//=====================================================================================================================
+
+NodeApiJsiRuntime::HostFunctionWrapper::HostFunctionWrapper(jsi::HostFunctionType &&type, NodeApiJsiRuntime &runtime)
+    : hostFunction_{std::move(type)}, runtime_{runtime} {}
+
+jsi::HostFunctionType &NodeApiJsiRuntime::HostFunctionWrapper::hostFunction() noexcept {
+  return hostFunction_;
+}
+
+NodeApiJsiRuntime &NodeApiJsiRuntime::HostFunctionWrapper::runtime() noexcept {
+  return runtime_;
+}
+
+//=====================================================================================================================
+// NodeApiJsiRuntime implementation
+//=====================================================================================================================
+
+template <typename... Args>
+jsi::JSError NodeApiJsiRuntime::makeJSError(Args &&...args) {
+  std::ostringstream errorStream;
+  ((errorStream << std::forward<Args>(args)), ...);
+  return jsi::JSError(*this, errorStream.str());
+}
+
+// Throws jsi::JSError or jsi::JSINativeException from Node-API error.
+[[noreturn]] void NodeApiJsiRuntime::throwJSException(napi_status status) const {
+  napi_value jsError{};
+  CHECK_NAPI_ELSE_CRASH(jsrApi_->napi_get_and_clear_last_exception(env_, &jsError));
+
+  if (!hasPendingJSError_ &&
+      (status == napi_pending_exception || instanceOf(jsError, getNodeApiValue(cachedValue_.Error)))) {
+    AutoRestore<bool> setValue(const_cast<NodeApiJsiRuntime *>(this)->hasPendingJSError_, true);
+    rewriteErrorMessage(jsError);
+    throw jsi::JSError(*const_cast<NodeApiJsiRuntime *>(this), toJsiValue(jsError));
+  } else {
+    std::ostringstream errorStream;
+    errorStream << "A call to Node-API returned error code 0x" << std::hex << status << '.';
+    throw jsi::JSINativeException(errorStream.str().c_str());
+  }
+}
+
+// Throws jsi::JSINativeException with a message.
+[[noreturn]] void NodeApiJsiRuntime::throwNativeException(char const *errorMessage) const {
+  throw jsi::JSINativeException(errorMessage);
+}
+
+// Rewrites error messages to match the JSI unit test expectations.
+void NodeApiJsiRuntime::rewriteErrorMessage(napi_value jsError) const {
+  // The code below must work correctly even if the 'message' getter throws.
+  // In case when it throws, we ignore that exception.
+  napi_value message{};
+  napi_status status = jsrApi_->napi_get_property(env_, jsError, getNodeApiValue(propertyId_.message), &message);
+  if (status != napi_ok) {
+    // If the 'message' property getter throws, then we clear the exception and ignore it.
+    napi_value ignoreJSError{};
+    jsrApi_->napi_get_and_clear_last_exception(env_, &ignoreJSError);
+  } else if (typeOf(message) == napi_string) {
+    // JSI unit tests expect V8- or JSC-like messages for the stack overflow.
+    if (stringToStdString(message) == "Out of stack space") {
+      setProperty(
+          jsError,
+          getNodeApiValue(propertyId_.message),
+          createStringUtf8("RangeError : Maximum call stack size exceeded"sv));
+    }
+  }
+
+  // Make sure that the call stack has the current URL
+  if (!sourceURL_.empty()) {
+    napi_value stack{};
+    status = jsrApi_->napi_get_property(env_, jsError, getNodeApiValue(propertyId_.stack), &stack);
+    if (status != napi_ok) {
+      // If the 'stack' property getter throws, then we clear the exception and ignore it.
+      napi_value ignoreJSError{};
+      jsrApi_->napi_get_and_clear_last_exception(env_, &ignoreJSError);
+    } else if (typeOf(message) == napi_string) {
+      // JSI unit tests expect URL to be part of the call stack.
+      std::string stackStr = stringToStdString(stack);
+      if (stackStr.find(sourceURL_) == std::string::npos) {
+        stackStr += sourceURL_ + '\n' + stackStr;
+        setProperty(jsError, getNodeApiValue(propertyId_.stack), createStringUtf8(stackStr.c_str()));
+      }
+    }
+  }
+}
+
+// Evaluates lambda and augments exception messages with the method's name.
+template <typename TLambda>
+auto NodeApiJsiRuntime::runInMethodContext(char const *methodName, TLambda lambda) {
+  try {
+    return lambda();
+  } catch (jsi::JSError const &) {
+    throw; // do not augment the JSError exceptions.
+  } catch (std::exception const &ex) {
+    throwNativeException((std::string{"Exception in "} + methodName + ": " + ex.what()).c_str());
+  } catch (...) {
+    throwNativeException((std::string{"Exception in "} + methodName + ": <unknown>").c_str());
+  }
+}
+
+// Evaluates lambda and converts all exceptions to NAPI errors.
+template <typename TLambda>
+napi_value NodeApiJsiRuntime::handleCallbackExceptions(TLambda lambda) const noexcept {
+  try {
+    try {
+      return lambda();
+    } catch (jsi::JSError const &jsError) {
+      // This block may throw exceptions
+      setException(getNodeApiValue(jsError.value()));
+    }
+  } catch (std::exception const &ex) {
+    setException(ex.what());
+  } catch (...) {
+    setException("Unexpected error");
+  }
+
+  return getUndefined();
+}
+
+// Throws JavaScript exception using NAPI.
+bool NodeApiJsiRuntime::setException(napi_value error) const noexcept {
+  // This method must not throw. We return false in case of error.
+  return jsrApi_->napi_throw(env_, error) == napi_status::napi_ok;
+}
+
+// Throws JavaScript error exception with the provided message using NAPI.
+bool NodeApiJsiRuntime::setException(std::string_view message) const noexcept {
+  // This method must not throw. We return false in case of error.
+  return jsrApi_->napi_throw_error(env_, "Unknown", message.data()) == napi_status::napi_ok;
+}
+
+// Gets type of the napi_value.
+napi_valuetype NodeApiJsiRuntime::typeOf(napi_value value) const {
+  napi_valuetype result{};
+  CHECK_NAPI(jsrApi_->napi_typeof(env_, value, &result));
+  return result;
+}
+
+// Returns true if two napi_values are strict equal per JavaScript rules.
+bool NodeApiJsiRuntime::strictEquals(napi_value left, napi_value right) const {
+  bool result{false};
+  CHECK_NAPI(jsrApi_->napi_strict_equals(env_, left, right, &result));
+  return result;
+}
+
+// Gets the napi_value for the JavaScript's undefined value.
+napi_value NodeApiJsiRuntime::getUndefined() const {
+  napi_value result{nullptr};
+  CHECK_NAPI(jsrApi_->napi_get_undefined(env_, &result));
+  return result;
+}
+
+// Gets the napi_value for the JavaScript's null value.
+napi_value NodeApiJsiRuntime::getNull() const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_get_null(env_, &result));
+  return result;
+}
+
+// Gets the napi_value for the JavaScript's global object.
+napi_value NodeApiJsiRuntime::getGlobal() const {
+  napi_value result{nullptr};
+  CHECK_NAPI(jsrApi_->napi_get_global(env_, &result));
+  return result;
+}
+
+// Gets the napi_value for the JavaScript's true and false values.
+napi_value NodeApiJsiRuntime::getBoolean(bool value) const {
+  napi_value result{nullptr};
+  CHECK_NAPI(jsrApi_->napi_get_boolean(env_, value, &result));
+  return result;
+}
+
+// Gets value of the Boolean napi_value.
+bool NodeApiJsiRuntime::getValueBool(napi_value value) const {
+  bool result{nullptr};
+  CHECK_NAPI(jsrApi_->napi_get_value_bool(env_, value, &result));
+  return result;
+}
+
+// Creates napi_value with an int32_t value.
+napi_value NodeApiJsiRuntime::createInt32(int32_t value) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_int32(env_, value, &result));
+  return result;
+}
+
+// Creates napi_value with an int32_t value.
+napi_value NodeApiJsiRuntime::createUInt32(uint32_t value) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_uint32(env_, value, &result));
+  return result;
+}
+
+// Creates napi_value with a double value.
+napi_value NodeApiJsiRuntime::createDouble(double value) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_double(env_, value, &result));
+  return result;
+}
+
+// Gets value of the Double napi_value.
+double NodeApiJsiRuntime::getValueDouble(napi_value value) const {
+  double result{0};
+  CHECK_NAPI(jsrApi_->napi_get_value_double(env_, value, &result));
+  return result;
+}
+
+// Creates a napi_value string from the extended ASCII symbols that correspond to the Latin1 encoding.
+// Each character is a byte-sized value from 0 to 255.
+napi_value NodeApiJsiRuntime::createStringLatin1(std::string_view value) const {
+  CHECK_ELSE_THROW(value.data(), "Cannot convert a nullptr to a JS string.");
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_string_latin1(env_, value.data(), value.size(), &result));
+  return result;
+}
+
+// Creates a napi_value string from a UTF-8 string.
+napi_value NodeApiJsiRuntime::createStringUtf8(std::string_view value) const {
+  CHECK_ELSE_THROW(value.data(), "Cannot convert a nullptr to a JS string.");
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_string_utf8(env_, value.data(), value.size(), &result));
+  return result;
+}
+
+// Creates a napi_value string from a UTF-8 string. Use data and length instead of string_view.
+napi_value NodeApiJsiRuntime::createStringUtf8(const uint8_t *data, size_t length) const {
+  return createStringUtf8({reinterpret_cast<const char *>(data), length});
+}
+
+// Gets std::string from the napi_value string.
+std::string NodeApiJsiRuntime::stringToStdString(napi_value stringValue) const {
+  std::string result;
+  CHECK_ELSE_THROW(
+      typeOf(stringValue) == napi_valuetype::napi_string,
+      "Cannot convert a non JS string Node-API Value to a std::string.");
+  size_t strLength{};
+  CHECK_NAPI(jsrApi_->napi_get_value_string_utf8(env_, stringValue, nullptr, 0, &strLength));
+  result.assign(strLength, '\0');
+  size_t copiedLength{};
+  CHECK_NAPI(jsrApi_->napi_get_value_string_utf8(env_, stringValue, &result[0], result.length() + 1, &copiedLength));
+  CHECK_ELSE_THROW(result.length() == copiedLength, "Unexpected string length");
+  return result;
+}
+
+// Gets or creates a unique string value from an UTF-8 string_view.
+napi_value NodeApiJsiRuntime::getPropertyIdFromName(std::string_view value) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_string_utf8(env_, value.data(), value.size(), &result));
+  return result;
+}
+
+// Gets or creates a unique string value from an UTF-8 data/length range.
+napi_value NodeApiJsiRuntime::getPropertyIdFromName(const uint8_t *data, size_t length) const {
+  return getPropertyIdFromName({reinterpret_cast<const char *>(data), length});
+}
+
+// Gets or creates a unique string value from napi_value string.
+napi_value NodeApiJsiRuntime::getPropertyIdFromName(napi_value str) const {
+  return str;
+}
+
+// Gets or creates a unique string value from napi_value symbol.
+napi_value NodeApiJsiRuntime::getPropertyIdFromSymbol(napi_value sym) const {
+  return sym;
+}
+
+// Converts property id value to std::string.
+std::string NodeApiJsiRuntime::propertyIdToStdString(napi_value propertyId) {
+  if (typeOf(propertyId) == napi_symbol) {
+    return symbolToStdString(propertyId);
+  }
+
+  return stringToStdString(propertyId);
+}
+
+// Creates a JavaScript symbol napi_value.
+napi_value NodeApiJsiRuntime::createSymbol(std::string_view symbolDescription) const {
+  napi_value result{};
+  napi_value description = createStringUtf8(symbolDescription);
+  CHECK_NAPI(jsrApi_->napi_create_symbol(env_, description, &result));
+  return result;
+}
+
+// Calls Symbol.toString() and returns it as std::string.
+std::string NodeApiJsiRuntime::symbolToStdString(napi_value symbolValue) {
+  if (!cachedValue_.SymbolToString) {
+    napi_value symbolCtor = getProperty(getNodeApiValue(cachedValue_.Global), getNodeApiValue(propertyId_.Symbol));
+    napi_value symbolPrototype = getProperty(symbolCtor, getNodeApiValue(propertyId_.prototype));
+    cachedValue_.SymbolToString = makeNodeApiRef(
+        getProperty(symbolPrototype, getNodeApiValue(propertyId_.toString)), NodeApiPointerValueKind::Object);
+  }
+  napi_value jsString = callFunction(symbolValue, getNodeApiValue(cachedValue_.SymbolToString), {});
+  return stringToStdString(jsString);
+}
+
+// Calls a JavaScript function.
+napi_value NodeApiJsiRuntime::callFunction(napi_value thisArg, napi_value function, span<napi_value> args) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_call_function(env_, thisArg, function, args.size(), args.data(), &result));
+  return result;
+}
+
+// Constructs a new JavaScript Object using a constructor function.
+napi_value NodeApiJsiRuntime::constructObject(napi_value constructor, span<napi_value> args) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_new_instance(env_, constructor, args.size(), args.data(), &result));
+  return result;
+}
+
+// Returns true if object was constructed using the provided constructor.
+bool NodeApiJsiRuntime::instanceOf(napi_value object, napi_value constructor) const {
+  bool result{false};
+  CHECK_NAPI(jsrApi_->napi_instanceof(env_, object, constructor, &result));
+  return result;
+}
+
+// Creates new JavaScript Object.
+napi_value NodeApiJsiRuntime::createNodeApiObject() const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_object(env_, &result));
+  return result;
+}
+
+// Returns true if the object has a property with the provided property ID.
+bool NodeApiJsiRuntime::hasProperty(napi_value object, napi_value propertyId) const {
+  bool result{};
+  CHECK_NAPI(jsrApi_->napi_has_property(env_, object, propertyId, &result));
+  return result;
+}
+
+// Gets object property value.
+napi_value NodeApiJsiRuntime::getProperty(napi_value object, napi_value propertyId) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_get_property(env_, object, propertyId, &result));
+  return result;
+}
+
+// Sets object property value.
+void NodeApiJsiRuntime::setProperty(napi_value object, napi_value propertyId, napi_value value) const {
+  CHECK_NAPI(jsrApi_->napi_set_property(env_, object, propertyId, value));
+}
+
+// Sets object property value with the provided property accessibility attributes.
+void NodeApiJsiRuntime::setProperty(
+    napi_value object,
+    napi_value propertyId,
+    napi_value value,
+    napi_property_attributes attrs) const {
+  napi_property_descriptor descriptor{};
+  descriptor.name = propertyId;
+  descriptor.value = value;
+  descriptor.attributes = attrs;
+  CHECK_NAPI(jsrApi_->napi_define_properties(env_, object, 1, &descriptor));
+}
+
+// Creates a new JavaScript Array with the provided length.
+napi_value NodeApiJsiRuntime::createNodeApiArray(size_t length) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_array_with_length(env_, length, &result));
+  return result;
+}
+
+bool NodeApiJsiRuntime::isArray(napi_value value) const {
+  bool result{};
+  CHECK_NAPI(jsrApi_->napi_is_array(env_, value, &result));
+  return result;
+}
+
+size_t NodeApiJsiRuntime::getArrayLength(napi_value value) const {
+  uint32_t result{};
+  CHECK_NAPI(jsrApi_->napi_get_array_length(env_, value, &result));
+  return result;
+}
+
+napi_value NodeApiJsiRuntime::getElement(napi_value arr, size_t index) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_get_element(env_, arr, static_cast<int32_t>(index), &result));
+  return result;
+}
+
+// Sets array element.
+void NodeApiJsiRuntime::setElement(napi_value array, uint32_t index, napi_value value) const {
+  CHECK_NAPI(jsrApi_->napi_set_element(env_, array, index, value));
+}
+
+// The NAPI external function callback used for the JSI host function implementation.
+/*static*/ napi_value __cdecl NodeApiJsiRuntime::jsiHostFunctionCallback(
+    napi_env env,
+    napi_callback_info info) noexcept {
+  HostFunctionWrapper *hostFuncWrapper{};
+  size_t argc{};
+  CHECK_NAPI_ELSE_CRASH(JSRuntimeApi::current()->napi_get_cb_info(
+      env, info, &argc, nullptr, nullptr, reinterpret_cast<void **>(&hostFuncWrapper)));
+  CHECK_ELSE_CRASH(hostFuncWrapper, "Cannot find the host function");
+  NodeApiJsiRuntime &runtime = hostFuncWrapper->runtime();
+  NodeApiPointerValueScope scope{runtime};
+
+  return runtime.handleCallbackExceptions([&env, &info, &argc, &runtime, &hostFuncWrapper]() {
+    SmallBuffer<napi_value, MaxStackArgCount> napiArgs(argc);
+    napi_value thisArg{};
+    CHECK_NAPI_ELSE_CRASH(
+        JSRuntimeApi::current()->napi_get_cb_info(env, info, &argc, napiArgs.data(), &thisArg, nullptr));
+    CHECK_ELSE_CRASH(napiArgs.size() == argc, "Wrong argument count");
+    const JsiValueView jsiThisArg{&runtime, thisArg};
+    JsiValueViewArgs jsiArgs(&runtime, span<napi_value>(napiArgs.data(), napiArgs.size()));
+
+    const jsi::HostFunctionType &hostFunc = hostFuncWrapper->hostFunction();
+    return runtime.runInMethodContext("HostFunction", [&hostFunc, &runtime, &jsiThisArg, &jsiArgs]() {
+      return runtime.getNodeApiValue(hostFunc(runtime, jsiThisArg, jsiArgs.data(), jsiArgs.size()));
+    });
+  });
+}
+
+// Creates an external function.
+napi_value NodeApiJsiRuntime::createExternalFunction(
+    napi_value name,
+    int32_t paramCount,
+    napi_callback callback,
+    void *callbackData) {
+  std::string funcName = stringToStdString(name);
+  napi_value function{};
+  CHECK_NAPI(
+      jsrApi_->napi_create_function(env_, funcName.data(), funcName.length(), callback, callbackData, &function));
+  setProperty(
+      function, getNodeApiValue(propertyId_.length), createInt32(paramCount), napi_property_attributes::napi_default);
+
+  return function;
+}
+
+// Creates an object that wraps up external data.
+napi_value NodeApiJsiRuntime::createExternalObject(void *data, napi_finalize finalizeCallback) const {
+  napi_value result{};
+  CHECK_NAPI(jsrApi_->napi_create_external(env_, data, finalizeCallback, nullptr, &result));
+  return result;
+}
+
+// Wraps up std::unique_ptr as an external object.
+template <typename T>
+napi_value NodeApiJsiRuntime::createExternalObject(std::unique_ptr<T> &&data) const {
+  napi_finalize finalize = [](napi_env /*env*/, void *dataToDestroy, void * /*finalizerHint*/) {
+    // We wrap dataToDestroy in a unique_ptr to avoid calling delete explicitly.
+    std::unique_ptr<T> dataDeleter{static_cast<T *>(dataToDestroy)};
+  };
+  napi_value object = createExternalObject(data.get(), finalize);
+
+  // We only call data.release() after the createExternalObject succeeds.
+  // Otherwise, when createExternalObject fails and an exception is thrown,
+  // the memory that data used to own will be leaked.
+  data.release();
+  return object;
+}
+
+// Gets external data wrapped by an external object.
+void *NodeApiJsiRuntime::getExternalData(napi_value object) const {
+  void *result{};
+  CHECK_NAPI(jsrApi_->napi_get_value_external(env_, object, &result));
+  return result;
+}
+
+// Gets JSI host object wrapped into a napi_value object.
+const std::shared_ptr<jsi::HostObject> &NodeApiJsiRuntime::getJsiHostObject(napi_value obj) {
+  const napi_value hostObjectHolder = getProperty(obj, getNodeApiValue(propertyId_.hostObjectSymbol));
+
+  if (typeOf(hostObjectHolder) == napi_valuetype::napi_external) {
+    if (void *data = getExternalData(hostObjectHolder)) {
+      return *static_cast<std::shared_ptr<jsi::HostObject> *>(data);
+    }
+  }
+
+  throw jsi::JSINativeException("Cannot get HostObjects.");
+}
+
+// Gets cached or creates Proxy handler to implement the JSI host object.
+napi_value NodeApiJsiRuntime::getHostObjectProxyHandler() {
+  if (!cachedValue_.HostObjectProxyHandler) {
+    const napi_value handler = createNodeApiObject();
+    setProxyTrap<&NodeApiJsiRuntime::hostObjectHasTrap, 2>(handler, getNodeApiValue(propertyId_.has));
+    setProxyTrap<&NodeApiJsiRuntime::hostObjectGetTrap, 3>(handler, getNodeApiValue(propertyId_.get));
+    setProxyTrap<&NodeApiJsiRuntime::hostObjectSetTrap, 4>(handler, getNodeApiValue(propertyId_.set));
+    setProxyTrap<&NodeApiJsiRuntime::hostObjectOwnKeysTrap, 1>(handler, getNodeApiValue(propertyId_.ownKeys));
+    setProxyTrap<&NodeApiJsiRuntime::hostObjectGetOwnPropertyDescriptorTrap, 2>(
+        handler, getNodeApiValue(propertyId_.getOwnPropertyDescriptor));
+    cachedValue_.HostObjectProxyHandler = makeNodeApiRef(handler, NodeApiPointerValueKind::Object);
+  }
+
+  return getNodeApiValue(cachedValue_.HostObjectProxyHandler);
+}
+
+// Sets Proxy trap method as a pointer to NodeApiJsiRuntime instance method.
+template <napi_value (NodeApiJsiRuntime::*trapMethod)(span<napi_value>), size_t argCount>
+void NodeApiJsiRuntime::setProxyTrap(napi_value handler, napi_value propertyName) {
+  napi_callback proxyTrap = [](napi_env env, napi_callback_info info) noexcept {
+    NodeApiJsiRuntime *runtime{};
+    napi_value args[argCount]{};
+    size_t actualArgCount{argCount};
+    CHECK_NAPI_ELSE_CRASH(JSRuntimeApi::current()->napi_get_cb_info(
+        env, info, &actualArgCount, args, nullptr, reinterpret_cast<void **>(&runtime)));
+    CHECK_ELSE_CRASH(actualArgCount == argCount, "proxy trap requires argCount arguments.");
+    NodeApiPointerValueScope scope{*runtime};
+    return runtime->handleCallbackExceptions(
+        [&runtime, &args]() { return (runtime->*trapMethod)(span<napi_value>(args, argCount)); });
+  };
+
+  setProperty(handler, propertyName, createExternalFunction(propertyName, argCount, proxyTrap, this));
+}
+
+// The host object Proxy 'has' trap implementation.
+napi_value NodeApiJsiRuntime::hostObjectHasTrap(span<napi_value> args) {
+  // args[0] - the Proxy target object.
+  // args[1] - the name of the property to check.
+  napi_value propertyName = args[1];
+  const auto &hostObject = getJsiHostObject(args[0]);
+  return runInMethodContext("HostObject::has", [&hostObject, &propertyName, this]() {
+    // std::vector<jsi::PropNameID> ownKeys = hostObject->getPropertyNames(*this);
+    // for (jsi::PropNameID &ownKey : ownKeys) {
+    //   if (strictEquals(propertyName, getNodeApiValue(ownKey))) {
+    return getBoolean(true);
+    //   }
+    // }
+    // return getBoolean(false);
+  });
+}
+
+// The host object Proxy 'get' trap implementation.
+napi_value NodeApiJsiRuntime::hostObjectGetTrap(span<napi_value> args) {
+  // args[0] - the Proxy target object.
+  // args[1] - the name of the property to set.
+  // args[2] - the Proxy object (unused).
+  napi_value target = args[0];
+  napi_value propertyName = args[1];
+  bool isTargetOwnProp{};
+  CHECK_NAPI(jsrApi_->napi_has_own_property(env_, target, propertyName, &isTargetOwnProp));
+  if (isTargetOwnProp) {
+    return getProperty(target, propertyName);
+  }
+  const auto &hostObject = getJsiHostObject(args[0]);
+  PropNameIDView propertyId{this, propertyName};
+  return runInMethodContext("HostObject::get", [&hostObject, &propertyId, this]() {
+    return getNodeApiValue(hostObject->get(*this, propertyId));
+  });
+}
+
+// The host object Proxy 'set' trap implementation.
+napi_value NodeApiJsiRuntime::hostObjectSetTrap(span<napi_value> args) {
+  // args[0] - the Proxy target object.
+  // args[1] - the name of the property to set.
+  // args[2] - the new value of the property to set.
+  // args[3] - the Proxy object (unused).
+  const auto &hostObject = getJsiHostObject(args[0]);
+  PropNameIDView propertyId{this, args[1]};
+  JsiValueView value{this, args[2]};
+  runInMethodContext(
+      "HostObject::set", [&hostObject, &propertyId, &value, this]() { hostObject->set(*this, propertyId, value); });
+  return getUndefined();
+}
+
+// The host object Proxy 'ownKeys' trap implementation.
+napi_value NodeApiJsiRuntime::hostObjectOwnKeysTrap(span<napi_value> args) {
+  // args[0] - the Proxy target object.
+  napi_value target = args[0];
+
+  napi_value targetOwnKeys{};
+  CHECK_NAPI(jsrApi_->napi_get_all_property_names(
+      env_, target, napi_key_own_only, napi_key_all_properties, napi_key_numbers_to_strings, &targetOwnKeys));
+  CHECK_ELSE_THROW(isArray(targetOwnKeys), "Expected an array");
+  size_t targetOwnKeysLength = getArrayLength(targetOwnKeys);
+
+  const auto &hostObject = getJsiHostObject(target);
+  std::vector<jsi::PropNameID> hostOwnKeys = runInMethodContext(
+      "HostObject::getPropertyNames", [&hostObject, this]() { return hostObject->getPropertyNames(*this); });
+
+  std::vector<jsi::PropNameID> ownKeys;
+  std::unordered_set<const PointerValue *> uniqueOwnKeys;
+  // Minus one hostObjectSymbol key.
+  ownKeys.reserve(targetOwnKeysLength - 1 + hostOwnKeys.size());
+  uniqueOwnKeys.reserve(targetOwnKeysLength - 1 + hostOwnKeys.size());
+
+  // Read all target own keys.
+  if (targetOwnKeysLength > 1) {
+    auto addPropNameId = [this, &uniqueOwnKeys, &ownKeys](jsi::PropNameID &&propNameId) {
+      const PointerValue *pv = getPointerValue(propNameId);
+      auto inserted = uniqueOwnKeys.insert(pv);
+      CHECK_ELSE_THROW(inserted.second, "Target has non-unique keys");
+      ownKeys.push_back(std::move(propNameId));
+    };
+    for (size_t i = 0; i < targetOwnKeysLength; ++i) {
+      napi_value key = getElement(targetOwnKeys, i);
+      napi_valuetype keyType = typeOf(key);
+      if (keyType == napi_string) {
+        addPropNameId(createPropNameIDFromString(makeJsiPointer<jsi::String>(key)));
+#if JSI_VERSION >= 8
+      } else if (keyType == napi_symbol) {
+        if (strictEquals(key, getNodeApiValue(propertyId_.hostObjectSymbol))) {
+          continue;
+        }
+        addPropNameId(createPropNameIDFromSymbol(makeJsiPointer<jsi::Symbol>(key)));
+#endif
+      } else {
+        throwNativeException("Unexpected key type");
+      }
+    }
+  }
+
+  // Read all unique host own keys.
+  for (jsi::PropNameID &propNameId : hostOwnKeys) {
+    const PointerValue *pv = getPointerValue(propNameId);
+    auto inserted = uniqueOwnKeys.insert(pv);
+    if (inserted.second) {
+      ownKeys.push_back(std::move(propNameId));
+    }
+  }
+
+  // Put indexed properties before named ones.
+  struct Index {
+    uint32_t index;
+    napi_value value;
+  };
+  std::vector<Index> indexKeys;
+  std::vector<napi_value> nonIndexKeys;
+  nonIndexKeys.reserve(ownKeys.size());
+  for (const jsi::PropNameID &key : ownKeys) {
+    napi_value napiKey = getNodeApiValue(key);
+    napi_valuetype valueType = typeOf(napiKey);
+    if (valueType == napi_string) {
+      std::string keyStr = stringToStdString(napiKey);
+      std::optional<uint32_t> indexKey = toArrayIndex(keyStr.begin(), keyStr.end());
+      if (indexKey.has_value()) {
+        indexKeys.push_back(Index{indexKey.value(), napiKey});
+        continue;
+      }
+    }
+    nonIndexKeys.push_back(napiKey);
+  }
+
+  std::sort(indexKeys.begin(), indexKeys.end(), [](const Index &left, const Index &right) {
+    return left.index < right.index;
+  });
+
+  napi_value ownKeyArray = createNodeApiArray(0);
+  uint32_t index = 0;
+  for (const Index &indexKey : indexKeys) {
+    setElement(ownKeyArray, index++, indexKey.value);
+  }
+  for (napi_value napiKey : nonIndexKeys) {
+    setElement(ownKeyArray, index++, napiKey);
+  }
+
+  return ownKeyArray;
+}
+
+// The host object Proxy 'getOwnPropertyDescriptor' trap implementation.
+napi_value NodeApiJsiRuntime::hostObjectGetOwnPropertyDescriptorTrap(span<napi_value> args) {
+  // args[0] - the Proxy target object.
+  // args[1] - the property
+  const auto &hostObject = getJsiHostObject(args[0]);
+  PropNameIDView propertyId{this, args[1]};
+
+  return runInMethodContext("HostObject::getOwnPropertyDescriptor", [&hostObject, &propertyId, this]() {
+    auto getPropDescriptor = [](napi_value name, napi_value value) {
+      return napi_property_descriptor{
+          nullptr, name, nullptr, nullptr, nullptr, value, napi_default_jsproperty, nullptr};
+    };
+    napi_value trueValue = getBoolean(true);
+    napi_property_descriptor properties[]{
+        getPropDescriptor(getNodeApiValue(propertyId_.value), getNodeApiValue(hostObject->get(*this, propertyId))),
+        getPropDescriptor(getNodeApiValue(propertyId_.writable), trueValue),
+        getPropDescriptor(getNodeApiValue(propertyId_.enumerable), trueValue),
+        getPropDescriptor(getNodeApiValue(propertyId_.configurable), trueValue)};
+    napi_value descriptor = createNodeApiObject();
+    CHECK_NAPI(jsrApi_->napi_define_properties(env_, descriptor, std::size(properties), properties));
+    return descriptor;
+  });
+}
+
+// Converts jsi::Bufer to span.
+span<const uint8_t> NodeApiJsiRuntime::toSpan(const jsi::Buffer &buffer) {
+  return span<const uint8_t>(buffer.data(), buffer.size());
+}
+
+// Creates jsi::Value from napi_value.
+jsi::Value NodeApiJsiRuntime::toJsiValue(napi_value value) const {
+  switch (typeOf(value)) {
+    case napi_valuetype::napi_undefined:
+      return jsi::Value::undefined();
+    case napi_valuetype::napi_null:
+      return jsi::Value::null();
+    case napi_valuetype::napi_boolean:
+      return jsi::Value{getValueBool(value)};
+    case napi_valuetype::napi_number:
+      return jsi::Value{getValueDouble(value)};
+    case napi_valuetype::napi_string:
+      return jsi::Value{makeJsiPointer<jsi::String>(value)};
+    case napi_valuetype::napi_symbol:
+      return jsi::Value{makeJsiPointer<jsi::Symbol>(value)};
+    case napi_valuetype::napi_object:
+    case napi_valuetype::napi_function:
+    case napi_valuetype::napi_external:
+      return jsi::Value{makeJsiPointer<jsi::Object>(value)};
+#if JSI_VERSION >= 6
+    case napi_valuetype::napi_bigint:
+      return jsi::Value{makeJsiPointer<jsi::BigInt>(value)};
+#endif
+    default:
+      throw jsi::JSINativeException("Unexpected value type");
+  }
+}
+
+napi_value NodeApiJsiRuntime::getNodeApiValue(const jsi::Value &value) const {
+  if (value.isUndefined()) {
+    return getUndefined();
+  } else if (value.isNull()) {
+    return getNull();
+  } else if (value.isBool()) {
+    return getBoolean(value.getBool());
+  } else if (value.isNumber()) {
+    return createDouble(value.getNumber());
+  } else if (value.isSymbol()) {
+    return getNodeApiValue(value.getSymbol(*const_cast<NodeApiJsiRuntime *>(this)));
+  } else if (value.isString()) {
+    return getNodeApiValue(value.getString(*const_cast<NodeApiJsiRuntime *>(this)));
+  } else if (value.isObject()) {
+    return getNodeApiValue(value.getObject(*const_cast<NodeApiJsiRuntime *>(this)));
+#if JSI_VERSION >= 8
+  } else if (value.isBigInt()) {
+    return getNodeApiValue(value.getBigInt(*const_cast<NodeApiJsiRuntime *>(this)));
+#endif
+  } else {
+    throw jsi::JSINativeException("Unexpected jsi::Value type");
+  }
+}
+
+napi_value NodeApiJsiRuntime::getNodeApiValue(const jsi::Pointer &ptr) const {
+  return const_cast<NodeApiPointerValue *>(static_cast<const NodeApiPointerValue *>(getPointerValue(ptr)))
+      ->getValue(*const_cast<NodeApiJsiRuntime *>(this));
+}
+
+napi_value NodeApiJsiRuntime::getNodeApiValue(const NodeApiRefHolder &ref) const {
+  return ref->getValue(*const_cast<NodeApiJsiRuntime *>(this));
+}
+
+NodeApiJsiRuntime::NodeApiRefCountedPointerValue *NodeApiJsiRuntime::cloneNodeApiPointerValue(
+    const PointerValue *pointerValue) {
+  return static_cast<const NodeApiPointerValue *>(pointerValue)->clone(*this);
+}
+
+// Adopted from Hermes code.
+std::optional<uint32_t> NodeApiJsiRuntime::toArrayIndex(
+    std::string::const_iterator first,
+    std::string::const_iterator last) {
+  // Empty string is invalid.
+  if (first == last)
+    return std::nullopt;
+
+  // Leading 0 is special.
+  if (*first == '0') {
+    ++first;
+    // Just "0"?
+    if (first == last)
+      return 0;
+    // Leading 0 is invalid otherwise.
+    return std::nullopt;
+  }
+
+  uint32_t res = 0;
+  do {
+    auto ch = *first;
+    if (ch < '0' || ch > '9')
+      return std::nullopt;
+    uint64_t tmp = (uint64_t)res * 10 + (ch - '0');
+    // Check for overflow.
+    if (tmp & ((uint64_t)0xFFFFFFFFu << 32))
+      return std::nullopt;
+    res = (uint32_t)tmp;
+  } while (++first != last);
+
+  // 0xFFFFFFFF is not a valid array index.
+  if (res == 0xFFFFFFFFu)
+    return std::nullopt;
+
+  return res;
+}
+
+template <typename T, std::enable_if_t<std::is_same_v<jsi::Object, T>, int>>
+T NodeApiJsiRuntime::makeJsiPointer(napi_value value) const {
+  return make<T>(NodeApiRefCountedPointerValue::make(
+      *const_cast<NodeApiJsiRuntime *>(this), value, NodeApiPointerValueKind::Object));
+}
+
+template <typename T, std::enable_if_t<std::is_same_v<jsi::String, T>, int>>
+T NodeApiJsiRuntime::makeJsiPointer(napi_value value) const {
+  return make<T>(NodeApiRefCountedPointerValue::make(
+      *const_cast<NodeApiJsiRuntime *>(this), value, NodeApiPointerValueKind::String));
+}
+
+template <typename T, std::enable_if_t<std::is_same_v<jsi::Symbol, T>, int>>
+T NodeApiJsiRuntime::makeJsiPointer(napi_value value) const {
+  return make<T>(NodeApiRefCountedPointerValue::make(
+      *const_cast<NodeApiJsiRuntime *>(this), value, NodeApiPointerValueKind::Symbol));
+}
+
+#if JSI_VERSION >= 6
+template <typename T, std::enable_if_t<std::is_same_v<jsi::BigInt, T>, int>>
+T NodeApiJsiRuntime::makeJsiPointer(napi_value value) const {
+  return make<T>(NodeApiRefCountedPointerValue::make(
+      *const_cast<NodeApiJsiRuntime *>(this), value, NodeApiPointerValueKind::BigInt));
+}
+#endif
+
+template <
+    typename TTo,
+    typename TFrom,
+    std::enable_if_t<std::is_base_of_v<jsi::Pointer, TTo>, int>,
+    std::enable_if_t<std::is_base_of_v<jsi::Pointer, TFrom>, int>>
+TTo NodeApiJsiRuntime::cloneAs(const TFrom &pointer) const {
+  return make<TTo>(static_cast<const NodeApiRefCountedPointerValue *>(getPointerValue(pointer))
+                       ->clone(*const_cast<NodeApiJsiRuntime *>(this)));
+}
+
+NodeApiJsiRuntime::NodeApiRefHolder NodeApiJsiRuntime::makeNodeApiRef(
+    napi_value value,
+    NodeApiJsiRuntime::NodeApiPointerValueKind pointerKind,
+    int32_t initialRefCount) {
+  return NodeApiRefHolder(NodeApiRefCountedPointerValue::makeNodeApiRef(*this, value, pointerKind, initialRefCount));
+}
+
+void NodeApiJsiRuntime::addStackValue(NodeApiStackValueHolder &&pointerHolder) {
+  if (stackValues_.size() == stackValues_.capacity()) {
+    collectUnusedStackValues();
+  }
+  stackValues_.push_back(std::move(pointerHolder));
+}
+
+void NodeApiJsiRuntime::addRef(NodeApiRefHolder &&refHolder) {
+  if (refs_.size() == refs_.capacity()) {
+    collectUnusedRefs();
+  }
+  refs_.push_back(std::move(refHolder));
+}
+
+void NodeApiJsiRuntime::pushPointerValueScope() noexcept {
+  stackScopes_.push_back(stackValues_.size());
+}
+
+void NodeApiJsiRuntime::popPointerValueScope() noexcept {
+  CHECK_ELSE_CRASH(!stackScopes_.empty(), "There are no scopes to pop");
+
+  size_t newStackSize = stackScopes_.back();
+  auto beginIterator = stackValues_.begin() + newStackSize;
+  stackScopes_.pop_back();
+  std::for_each(beginIterator, stackValues_.end(), [this](NodeApiStackValueHolder &holder) {
+    holder.release()->convertToNodeApiRef(*this);
+  });
+  stackValues_.resize(newStackSize);
+}
+
+void NodeApiJsiRuntime::collectUnusedStackValues() {
+  auto usedByJsiPointer = [](NodeApiStackValueHolder &holder) {
+    return NodeApiRefCountedPointerValue::usedByJsiPointer(holder.get());
+  };
+  auto beginIterator = stackValues_.begin();
+  for (size_t &scope : stackScopes_) {
+    auto endIterator = stackValues_.begin() + scope;
+    beginIterator = std::partition(beginIterator, endIterator, usedByJsiPointer);
+    scope -= endIterator - beginIterator;
+  }
+  beginIterator = std::partition(beginIterator, stackValues_.end(), usedByJsiPointer);
+  stackValues_.resize(beginIterator - stackValues_.begin());
+}
+
+void NodeApiJsiRuntime::collectUnusedRefs() noexcept {
+  auto usedByJsiPointer = [](NodeApiRefHolder &holder) {
+    return NodeApiRefCountedPointerValue::usedByJsiPointer(holder.get());
+  };
+  auto beginIterator = std::partition(refs_.begin(), refs_.end(), usedByJsiPointer);
+  std::for_each(beginIterator, refs_.end(), [this](NodeApiRefHolder &holder) {
+    NodeApiRefCountedPointerValue::deleteNodeApiRef(holder.release(), *this);
+  });
+  refs_.resize(beginIterator - refs_.begin());
+}
+
+} // namespace
+
+std::unique_ptr<jsi::Runtime>
+makeNodeApiJsiRuntime(napi_env env, JSRuntimeApi *jsrApi, std::function<void()> onDelete) noexcept {
+  return std::make_unique<NodeApiJsiRuntime>(env, jsrApi, std::move(onDelete));
+}
+
+} // namespace Microsoft::NodeApiJsi
+
+EXTERN_C_START
+
+// Default implementation of jsr_get_description if it is not provided by JS engine.
+// It returns "NodeApiJsiRuntime" string.
+napi_status NAPI_CDECL default_jsr_get_description(napi_env /*env*/, const char **result) {
+  if (result != nullptr) {
+    *result = "NodeApiJsiRuntime";
+  }
+  return napi_ok;
+}
+
+// Default implementation of jsr_drain_microtasks if it is not provided by JS engine.
+// It does nothing
+napi_status NAPI_CDECL default_jsr_drain_microtasks(napi_env /*env*/, int32_t /*max_count_hint*/, bool *result) {
+  if (result != nullptr) {
+    *result = true; // All tasks are drained
+  }
+  return napi_ok;
+}
+
+// Default implementation of jsr_is_inspectable if it is not provided by JS engine.
+// It always returns false.
+napi_status NAPI_CDECL default_jsr_is_inspectable(napi_env /*env*/, bool *result) {
+  if (result != nullptr) {
+    *result = false;
+  }
+  return napi_ok;
+}
+
+// Default implementation of jsr_open_napi_env_scope if it is not provided by JS engine.
+napi_status NAPI_CDECL default_jsr_open_napi_env_scope(napi_env /*env*/, jsr_napi_env_scope * /*scope*/) {
+  return napi_ok;
+}
+
+// Default implementation of jsr_close_napi_env_scope if it is not provided by JS engine.
+napi_status NAPI_CDECL default_jsr_close_napi_env_scope(napi_env /*env*/, jsr_napi_env_scope /*scope*/) {
+  return napi_ok;
+}
+
+// TODO: Ensure that we either load all three functions or use their default versions and never mix and match.
+
+// Default implementation of jsr_create_prepared_script if it is not provided by JS engine.
+// It return napi_ref as a jsr_prepared_script that wraps up an object with a "script" property string.
+napi_status NAPI_CDECL default_jsr_create_prepared_script(
+    napi_env env,
+    const uint8_t *script_data,
+    size_t script_length,
+    jsr_data_delete_cb script_delete_cb,
+    void *deleter_data,
+    const char * /*source_url*/,
+    jsr_prepared_script *result) {
+  Microsoft::NodeApiJsi::JSRuntimeApi *jsrApi = Microsoft::NodeApiJsi::JSRuntimeApi::current();
+  napi_value script{}, obj{};
+  // Do not use NAPI_CALL - we must finalize the buffer right after we attempted the string creation.
+  napi_status status =
+      jsrApi->napi_create_string_utf8(env, reinterpret_cast<const char *>(script_data), script_length, &script);
+  if (script_delete_cb != nullptr) {
+    script_delete_cb(const_cast<uint8_t *>(script_data), deleter_data);
+  }
+  NAPI_CALL(status);
+  NAPI_CALL(jsrApi->napi_create_object(env, &obj));
+  NAPI_CALL(jsrApi->napi_set_named_property(env, obj, "script", script));
+  return jsrApi->napi_create_reference(env, obj, 1, reinterpret_cast<napi_ref *>(result));
+}
+
+// Default implementation of jsr_delete_prepared_script if it is not provided by JS engine.
+// It deletes prepared_script as a napi_ref.
+napi_status NAPI_CDECL default_jsr_delete_prepared_script(napi_env env, jsr_prepared_script prepared_script) {
+  Microsoft::NodeApiJsi::JSRuntimeApi *jsrApi = Microsoft::NodeApiJsi::JSRuntimeApi::current();
+  return jsrApi->napi_delete_reference(env, reinterpret_cast<napi_ref>(prepared_script));
+}
+
+// Default implementation of jsr_prepared_script_run if it is not provided by JS engine.
+// It interprets prepared_script as a napi_ref to an object with a "script" property string.
+napi_status NAPI_CDECL
+default_jsr_prepared_script_run(napi_env env, jsr_prepared_script prepared_script, napi_value *result) {
+  Microsoft::NodeApiJsi::JSRuntimeApi *jsrApi = Microsoft::NodeApiJsi::JSRuntimeApi::current();
+  napi_value obj{}, script{};
+  NAPI_CALL(jsrApi->napi_get_reference_value(env, reinterpret_cast<napi_ref>(prepared_script), &obj));
+  NAPI_CALL(jsrApi->napi_get_named_property(env, obj, "script", &script));
+  return jsrApi->napi_run_script(env, script, result);
+}
+
+EXTERN_C_END