libv8-node 22.7.0.4-arm64-darwin → 24.1.0.0-arm64-darwin

data/vendor/v8/include/v8-local-handle.h

@@ -51,8 +51,6 @@ class Isolate;
 class Object;
 template <class F1, class F2, class F3>
 class PersistentValueMapBase;
-template <class F1, class F2>
-class PersistentValueVector;
 class Primitive;
 class Private;
 template <class F>
@@ -152,11 +150,11 @@ class V8_EXPORT V8_NODISCARD HandleScope {
 
 /**
  * A base class for local handles.
- * Its implementation depends on whether direct local support is enabled.
+ * Its implementation depends on whether direct handle support is enabled.
  * When it is, a local handle contains a direct pointer to the referenced
  * object, otherwise it contains an indirect pointer.
  */
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
 
 template <typename T>
 class LocalBase : public api_internal::DirectHandleBase {
@@ -181,11 +179,17 @@ class LocalBase : public api_internal::DirectHandleBase {
   }
 
   V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {
+    if (slot == nullptr) return LocalBase<T>();
     return LocalBase<T>(*slot);
   }
+
+  V8_INLINE static LocalBase<T> FromRepr(
+      internal::ValueHelper::InternalRepresentationType repr) {
+    return LocalBase<T>(repr);
+  }
 };
 
-#else  // !V8_ENABLE_DIRECT_LOCAL
+#else  // !V8_ENABLE_DIRECT_HANDLE
 
 template <typename T>
 class LocalBase : public api_internal::IndirectHandleBase {
@@ -215,9 +219,14 @@ class LocalBase : public api_internal::IndirectHandleBase {
   V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {
     return LocalBase<T>(slot);
   }
+
+  V8_INLINE static LocalBase<T> FromRepr(
+      internal::ValueHelper::InternalRepresentationType repr) {
+    return LocalBase<T>(repr);
+  }
 };
 
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 
 /**
  * An object reference managed by the v8 garbage collector.
@@ -257,17 +266,19 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
 #endif
 {
  public:
+  /**
+   * Default constructor: Returns an empty handle.
+   */
   V8_INLINE Local() = default;
 
+  /**
+   * Constructor for handling automatic up casting.
+   * Ex. Local<Object> can be passed when Local<Value> is expected but not
+   * the other way round.
+   */
   template <class S>
-  V8_INLINE Local(Local<S> that) : LocalBase<T>(that) {
-    /**
-     * This check fails when trying to convert between incompatible
-     * handles. For example, converting from a Local<String> to a
-     * Local<Number>.
-     */
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+    requires std::is_base_of_v<T, S>
+  V8_INLINE Local(Local<S> that) : LocalBase<T>(that) {}
 
   V8_INLINE T* operator->() const { return this->template value<T>(); }
 
@@ -307,7 +318,7 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
   /**
    * Cast a handle to a subclass, e.g. Local<Value> to Local<Object>.
    * This is only valid if the handle actually refers to a value of the
-   * target type.
+   * target type or if the handle is empty.
    */
   template <class S>
   V8_INLINE static Local<T> Cast(Local<S> that) {
@@ -323,7 +334,7 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
   /**
    * Calling this is equivalent to Local<S>::Cast().
    * In particular, this is only valid if the handle actually refers to a value
-   * of the target type.
+   * of the target type or if the handle is empty.
    */
   template <class S>
   V8_INLINE Local<S> As() const {
@@ -382,8 +393,6 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
   friend class InternalEscapableScope;
   template <class F1, class F2, class F3>
   friend class PersistentValueMapBase;
-  template <class F1, class F2>
-  friend class PersistentValueVector;
   template <class F>
   friend class ReturnValue;
   template <class F>
@@ -400,17 +409,22 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
 
   V8_INLINE explicit Local(const LocalBase<T>& other) : LocalBase<T>(other) {}
 
+  V8_INLINE static Local<T> FromRepr(
+      internal::ValueHelper::InternalRepresentationType repr) {
+    return Local<T>(LocalBase<T>::FromRepr(repr));
+  }
+
   V8_INLINE static Local<T> FromSlot(internal::Address* slot) {
     return Local<T>(LocalBase<T>::FromSlot(slot));
   }
 
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
   friend class TypecheckWitness;
 
   V8_INLINE static Local<T> FromAddress(internal::Address ptr) {
     return Local<T>(LocalBase<T>(ptr));
   }
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 
   V8_INLINE static Local<T> New(Isolate* isolate, internal::Address value) {
     return Local<T>(LocalBase<T>::New(isolate, value));
@@ -438,17 +452,18 @@ class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> {
 #if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
   // In this case, the check is also enforced in the copy constructor and we
   // need to suppress it.
-  LocalUnchecked(const LocalUnchecked& other)
+  LocalUnchecked(
+      const LocalUnchecked& other) noexcept  // NOLINT(runtime/explicit)
       : Local<T>(other, Local<T>::do_not_check) {}
-  LocalUnchecked& operator=(const LocalUnchecked&) = default;
+  LocalUnchecked& operator=(const LocalUnchecked&) noexcept = default;
 #endif
 
   // Implicit conversion from Local.
-  LocalUnchecked(const Local<T>& other)  // NOLINT(runtime/explicit)
+  LocalUnchecked(const Local<T>& other) noexcept  // NOLINT(runtime/explicit)
       : Local<T>(other, Local<T>::do_not_check) {}
 };
 
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
 // Off-stack allocated direct locals must be registered as strong roots.
 // For off-stack indirect locals, this is not necessary.
 
@@ -459,9 +474,9 @@ class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
   static_assert(std::is_standard_layout_v<value_type>);
   static_assert(sizeof(value_type) == sizeof(Address));
 
-  explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {}
-  explicit StrongRootAllocator(v8::Isolate* isolate)
-      : StrongRootAllocatorBase(isolate) {}
+  template <typename HeapOrIsolateT>
+  explicit StrongRootAllocator(HeapOrIsolateT* heap_or_isolate)
+      : StrongRootAllocatorBase(heap_or_isolate) {}
   template <typename U>
   StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept
       : StrongRootAllocatorBase(other) {}
@@ -473,7 +488,7 @@ class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
     return deallocate_impl(reinterpret_cast<Address*>(p), n);
   }
 };
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 }  // namespace internal
 
 template <typename T>
@@ -481,7 +496,7 @@ class LocalVector {
  private:
   using element_type = internal::LocalUnchecked<T>;
 
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
   using allocator_type = internal::StrongRootAllocator<element_type>;
 
   static allocator_type make_allocator(Isolate* isolate) noexcept {
@@ -493,7 +508,7 @@ class LocalVector {
   static allocator_type make_allocator(Isolate* isolate) noexcept {
     return allocator_type();
   }
-#endif  // V8_ENABLE_DIRECT_LOCAL
+#endif  // V8_ENABLE_DIRECT_HANDLE
 
   using vector_type = std::vector<element_type, allocator_type>;
 
@@ -560,13 +575,18 @@ class LocalVector {
 
   LocalVector<T>& operator=(std::initializer_list<Local<T>> init) {
     backing_.clear();
+    backing_.reserve(init.size());
     backing_.insert(backing_.end(), init.begin(), init.end());
     return *this;
   }
 
   void push_back(const Local<T>& x) { backing_.push_back(x); }
   void pop_back() { backing_.pop_back(); }
-  void emplace_back(const Local<T>& x) { backing_.emplace_back(x); }
+
+  template <typename... Args>
+  void emplace_back(Args&&... args) {
+    backing_.push_back(value_type{std::forward<Args>(args)...});
+  }
 
   void clear() noexcept { backing_.clear(); }
   void resize(size_t n) { backing_.resize(n); }
@@ -614,9 +634,22 @@ using Handle = Local<T>;
 template <class T>
 class MaybeLocal {
  public:
-  V8_INLINE MaybeLocal() : local_() {}
+  /**
+   * Default constructor: Returns an empty handle.
+   */
+  V8_INLINE MaybeLocal() = default;
+  /**
+   * Implicitly construct MaybeLocal from Local.
+   */
   template <class S>
+    requires std::is_base_of_v<T, S>
   V8_INLINE MaybeLocal(Local<S> that) : local_(that) {}
+  /**
+   * Implicitly up-cast MaybeLocal<S> to MaybeLocal<T> if T is a base of S.
+   */
+  template <class S>
+    requires std::is_base_of_v<T, S>
+  V8_INLINE MaybeLocal(MaybeLocal<S> that) : local_(that.local_) {}
 
   V8_INLINE bool IsEmpty() const { return local_.IsEmpty(); }
 
@@ -651,23 +684,17 @@ class MaybeLocal {
   /**
    * Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>.
    * This is only valid if the handle actually refers to a value of the target
-   * type.
+   * type or if the handle is empty.
    */
   template <class S>
   V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) {
-#ifdef V8_ENABLE_CHECKS
-    // If we're going to perform the type check then we have to check
-    // that the handle isn't empty before doing the checked cast.
-    if (that.IsEmpty()) return MaybeLocal<T>();
-    T::Cast(that.local_.template value<S>());
-#endif
-    return MaybeLocal<T>(that.local_);
+    return MaybeLocal<T>{Local<T>::Cast(that.local_)};
   }
 
   /**
    * Calling this is equivalent to MaybeLocal<S>::Cast().
    * In particular, this is only valid if the handle actually refers to a value
-   * of the target type.
+   * of the target type or if the handle is empty.
    */
   template <class S>
   V8_INLINE MaybeLocal<S> As() const {
@@ -716,7 +743,7 @@ class V8_EXPORT V8_NODISCARD EscapableHandleScope
   V8_INLINE ~EscapableHandleScope() = default;
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
     return value;
 #else
     if (value.IsEmpty()) return value;

data/vendor/v8/include/v8-maybe.h

@@ -8,6 +8,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "cppgc/internal/conditional-stack-allocated.h"  // NOLINT(build/include_directory)
 #include "v8-internal.h"  // NOLINT(build/include_directory)
 #include "v8config.h"     // NOLINT(build/include_directory)
 
@@ -29,7 +30,7 @@ V8_EXPORT void FromJustIsNothing();
  * "Nothing" value is returned.
  */
 template <class T>
-class Maybe {
+class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
   V8_INLINE bool IsNothing() const { return !has_value_; }
   V8_INLINE bool IsJust() const { return has_value_; }

data/vendor/v8/include/v8-memory-span.h

@@ -8,11 +8,46 @@
 #include <stddef.h>
 
 #include <array>
+#include <cstddef>
 #include <iterator>
 #include <type_traits>
 
 #include "v8config.h"  // NOLINT(build/include_directory)
 
+// TODO(pkasting): Use <compare>/spaceship unconditionally after dropping
+// support for old libstdc++ versions.
+#if __has_include(<version>)
+#include <version>
+#endif
+#if defined(__cpp_lib_three_way_comparison) && \
+    __cpp_lib_three_way_comparison >= 201711L
+#define V8_HAVE_SPACESHIP_OPERATOR 1
+#else
+#define V8_HAVE_SPACESHIP_OPERATOR 0
+#endif
+
+// TODO(pkasting): Make this block unconditional after dropping support for old
+// libstdc++ versions.
+#if __has_include(<ranges>)
+#include <ranges>
+
+namespace v8 {
+
+template <typename T>
+class V8_EXPORT MemorySpan;
+
+}  // namespace v8
+
+// Mark `MemorySpan` as satisfying the `view` and `borrowed_range` concepts.
+// This should be done before the definition of `MemorySpan`, so that any
+// inlined calls to range functionality use the correct specializations.
+template <typename T>
+inline constexpr bool std::ranges::enable_view<v8::MemorySpan<T>> = true;
+template <typename T>
+inline constexpr bool std::ranges::enable_borrowed_range<v8::MemorySpan<T>> =
+    true;
+#endif
+
 namespace v8 {
 
 /**
@@ -53,13 +88,13 @@ class V8_EXPORT MemorySpan {
       is_compatible_iterator<It>::value;
 
   template <typename U>
-  static constexpr U* to_address(U* p) noexcept {
+  [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
     return p;
   }
 
   template <typename It,
             typename = std::void_t<decltype(std::declval<It&>().operator->())>>
-  static constexpr auto to_address(It it) noexcept {
+  [[nodiscard]] static constexpr auto to_address(It it) noexcept {
     return it.operator->();
   }
 
@@ -108,50 +143,139 @@ class V8_EXPORT MemorySpan {
       : data_(a.data()), size_{N} {}
 
   /** Returns a pointer to the beginning of the buffer. */
-  constexpr T* data() const { return data_; }
+  [[nodiscard]] constexpr T* data() const { return data_; }
   /** Returns the number of elements that the buffer holds. */
-  constexpr size_t size() const { return size_; }
+  [[nodiscard]] constexpr size_t size() const { return size_; }
 
-  constexpr T& operator[](size_t i) const { return data_[i]; }
+  [[nodiscard]] constexpr T& operator[](size_t i) const { return data_[i]; }
 
   /** Returns true if the buffer is empty. */
-  constexpr bool empty() const { return size() == 0; }
+  [[nodiscard]] constexpr bool empty() const { return size() == 0; }
 
   class Iterator {
    public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = T;
     using difference_type = std::ptrdiff_t;
+    using value_type = T;
     using pointer = value_type*;
     using reference = value_type&;
+    using iterator_category = std::random_access_iterator_tag;
+    // There seems to be no feature-test macro covering this, so use the
+    // presence of `<ranges>` as a crude proxy, since it was added to the
+    // standard as part of the Ranges papers.
+    // TODO(pkasting): Add this unconditionally after dropping support for old
+    // libstdc++ versions.
+#if __has_include(<ranges>)
+    using iterator_concept = std::contiguous_iterator_tag;
+#endif
+
+    // Required to satisfy `std::semiregular<>`.
+    constexpr Iterator() = default;
+
+    [[nodiscard]] friend constexpr bool operator==(const Iterator& a,
+                                                   const Iterator& b) {
+      // TODO(pkasting): Replace this body with `= default` after dropping
+      // support for old gcc versions.
+      return a.ptr_ == b.ptr_;
+    }
+#if V8_HAVE_SPACESHIP_OPERATOR
+    [[nodiscard]] friend constexpr auto operator<=>(const Iterator&,
+                                                    const Iterator&) = default;
+#else
+    // Assume that if spaceship isn't present, operator rewriting might not be
+    // either.
+    [[nodiscard]] friend constexpr bool operator!=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ != b.ptr_;
+    }
 
-    T& operator*() const { return *ptr_; }
-    T* operator->() const { return ptr_; }
-
-    bool operator==(Iterator other) const { return ptr_ == other.ptr_; }
-    bool operator!=(Iterator other) const { return !(*this == other); }
+    [[nodiscard]] friend constexpr bool operator<(const Iterator& a,
+                                                  const Iterator& b) {
+      return a.ptr_ < b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator<=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ <= b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator>(const Iterator& a,
+                                                  const Iterator& b) {
+      return a.ptr_ > b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator>=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ >= b.ptr_;
+    }
+#endif
 
-    Iterator& operator++() {
+    constexpr Iterator& operator++() {
       ++ptr_;
       return *this;
     }
 
-    Iterator operator++(int) {
-      Iterator temp(*this);
-      ++(*this);
+    constexpr Iterator operator++(int) {
+      Iterator temp = *this;
+      ++*this;
       return temp;
     }
 
+    constexpr Iterator& operator--() {
+      --ptr_;
+      return *this;
+    }
+
+    constexpr Iterator operator--(int) {
+      Iterator temp = *this;
+      --*this;
+      return temp;
+    }
+
+    constexpr Iterator& operator+=(difference_type rhs) {
+      ptr_ += rhs;
+      return *this;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator+(Iterator lhs,
+                                                      difference_type rhs) {
+      lhs += rhs;
+      return lhs;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator+(difference_type lhs,
+                                                      const Iterator& rhs) {
+      return rhs + lhs;
+    }
+
+    constexpr Iterator& operator-=(difference_type rhs) {
+      ptr_ -= rhs;
+      return *this;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator-(Iterator lhs,
+                                                      difference_type rhs) {
+      lhs -= rhs;
+      return lhs;
+    }
+
+    [[nodiscard]] friend constexpr difference_type operator-(
+        const Iterator& lhs, const Iterator& rhs) {
+      return lhs.ptr_ - rhs.ptr_;
+    }
+
+    [[nodiscard]] constexpr reference operator*() const { return *ptr_; }
+    [[nodiscard]] constexpr pointer operator->() const { return ptr_; }
+    [[nodiscard]] constexpr reference operator[](size_t offset) const {
+      return ptr_[offset];
+    }
+
    private:
     friend class MemorySpan<T>;
 
-    explicit Iterator(T* ptr) : ptr_(ptr) {}
+    constexpr explicit Iterator(T* ptr) : ptr_(ptr) {}
 
     T* ptr_ = nullptr;
   };
 
-  Iterator begin() const { return Iterator(data_); }
-  Iterator end() const { return Iterator(data_ + size_); }
+  [[nodiscard]] Iterator begin() const { return Iterator(data_); }
+  [[nodiscard]] Iterator end() const { return Iterator(data_ + size_); }
 
  private:
   T* data_ = nullptr;
@@ -171,25 +295,26 @@ class V8_EXPORT MemorySpan {
 
 namespace detail {
 template <class T, std::size_t N, std::size_t... I>
-constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
     T (&a)[N], std::index_sequence<I...>) {
   return {{a[I]...}};
 }
 
 template <class T, std::size_t N, std::size_t... I>
-constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
     T (&&a)[N], std::index_sequence<I...>) {
   return {{std::move(a[I])...}};
 }
 }  // namespace detail
 
 template <class T, std::size_t N>
-constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
   return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{});
 }
 
 template <class T, std::size_t N>
-constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) {
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(
+    T (&&a)[N]) {
   return detail::to_array_rvalue_impl(std::move(a),
                                       std::make_index_sequence<N>{});
 }

data/vendor/v8/include/v8-message.h

@@ -9,6 +9,7 @@
 
 #include <iosfwd>
 
+#include "v8-callbacks.h"     // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-maybe.h"         // NOLINT(build/include_directory)
 #include "v8-primitive.h"     // NOLINT(build/include_directory)
@@ -61,27 +62,6 @@ class ScriptOriginOptions {
  */
 class V8_EXPORT ScriptOrigin {
  public:
-  V8_DEPRECATE_SOON("Use constructor without the isolate.")
-  V8_INLINE ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
-                         int resource_line_offset = 0,
-                         int resource_column_offset = 0,
-                         bool resource_is_shared_cross_origin = false,
-                         int script_id = -1,
-                         Local<Value> source_map_url = Local<Value>(),
-                         bool resource_is_opaque = false, bool is_wasm = false,
-                         bool is_module = false,
-                         Local<Data> host_defined_options = Local<Data>())
-      : resource_name_(resource_name),
-        resource_line_offset_(resource_line_offset),
-        resource_column_offset_(resource_column_offset),
-        options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
-                 is_module),
-        script_id_(script_id),
-        source_map_url_(source_map_url),
-        host_defined_options_(host_defined_options) {
-    VerifyHostDefinedOptions();
-  }
-
   V8_INLINE ScriptOrigin(Local<Value> resource_name,
                          int resource_line_offset = 0,
                          int resource_column_offset = 0,
@@ -206,7 +186,14 @@ class V8_EXPORT Message {
   bool IsSharedCrossOrigin() const;
   bool IsOpaque() const;
 
-  static void PrintCurrentStackTrace(Isolate* isolate, std::ostream& out);
+  /**
+   * If provided, the callback can be used to selectively include
+   * or redact frames based on their script names. (true to include a frame)
+   */
+  static void PrintCurrentStackTrace(
+      Isolate* isolate, std::ostream& out,
+      PrintCurrentStackTraceFilterCallback should_include_frame_callback =
+          nullptr);
 
   static const int kNoLineNumberInfo = 0;
   static const int kNoColumnInfo = 0;

data/vendor/v8/include/v8-metrics.h

@@ -8,9 +8,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <vector>
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -37,6 +39,10 @@ struct GarbageCollectionSizes {
 
 struct GarbageCollectionFullCycle {
   int reason = -1;
+  // The priority of the isolate during the GC cycle. A nullopt value denotes a
+  // mixed priority cycle, meaning the Isolate's priority was changed while the
+  // cycle was in progress.
+  std::optional<v8::Isolate::Priority> priority = std::nullopt;
   GarbageCollectionPhases total;
   GarbageCollectionPhases total_cpp;
   GarbageCollectionPhases main_thread;
@@ -55,6 +61,10 @@ struct GarbageCollectionFullCycle {
   double efficiency_cpp_in_bytes_per_us = -1.0;
   double main_thread_efficiency_in_bytes_per_us = -1.0;
   double main_thread_efficiency_cpp_in_bytes_per_us = -1.0;
+  double collection_weight_in_percent = -1.0;
+  double collection_weight_cpp_in_percent = -1.0;
+  double main_thread_collection_weight_in_percent = -1.0;
+  double main_thread_collection_weight_cpp_in_percent = -1.0;
   int64_t incremental_marking_start_stop_wall_clock_duration_in_us = -1;
 };
 
@@ -82,6 +92,10 @@ using GarbageCollectionFullMainThreadBatchedIncrementalSweep =
 
 struct GarbageCollectionYoungCycle {
   int reason = -1;
+  // The priority of the isolate during the GC cycle. A nullopt value denotes a
+  // mixed priority cycle, meaning the Isolate's priority was changed while the
+  // cycle was in progress.
+  std::optional<v8::Isolate::Priority> priority = std::nullopt;
   int64_t total_wall_clock_duration_in_us = -1;
   int64_t main_thread_wall_clock_duration_in_us = -1;
   double collection_rate_in_percent = -1.0;

data/vendor/v8/include/v8-microtask-queue.h

@@ -118,11 +118,6 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
  public:
   enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
 
-  V8_DEPRECATE_SOON(
-      "May be incorrect if context was created with non-default microtask "
-      "queue")
-  MicrotasksScope(Isolate* isolate, Type type);
-
   MicrotasksScope(Local<Context> context, Type type);
   MicrotasksScope(Isolate* isolate, MicrotaskQueue* microtask_queue, Type type);
   ~MicrotasksScope();