node-darwin-x64 25.8.2 → 26.0.0

package/include/node/v8-function.h

@@ -31,8 +31,8 @@ class V8_EXPORT Function : public Object {
    * for a given FunctionCallback.
    */
   static MaybeLocal<Function> New(
-      Local<Context> context, FunctionCallback callback,
-      Local<Value> data = Local<Value>(), int length = 0,
+      Local<Context> context, FunctionCallback callback, Local<Data> data = {},
+      int length = 0,
       ConstructorBehavior behavior = ConstructorBehavior::kAllow,
       SideEffectType side_effect_type = SideEffectType::kHasSideEffect);
 

package/include/node/v8-initialization.h

@@ -253,6 +253,35 @@ class V8_EXPORT V8 {
   static size_t GetSandboxReservationSizeInBytes();
 #endif  // V8_ENABLE_SANDBOX
 
+  enum class WasmMemoryType {
+    kMemory32,
+    kMemory64,
+  };
+
+  /**
+   * Returns the virtual address space reservation size (in bytes) needed
+   * for one WebAssembly memory instance of the given capacity.
+   *
+   * \param type Whether this is a memory32 or memory64 instance.
+   * \param byte_capacity The maximum size, in bytes, of the WebAssembly
+   *   memory. Values exceeding the engine's maximum allocatable memory
+   *   size for the given type (determined by max_mem32_pages or
+   *   max_mem64_pages) are clamped.
+   *
+   * When trap-based bounds checking is enabled by
+   * EnableWebAssemblyTrapHandler(), the amount of virtual address space
+   * that V8 needs to reserve for each WebAssembly memory instance can
+   * be much bigger than the requested size. If the process does
+   * not have enough virtual memory available, WebAssembly memory allocation
+   * would fail. During the initialization of V8, embedders can use this method
+   * to estimate whether the process has enough virtual memory for their
+   * usage of WebAssembly, and decide whether to enable the trap handler
+   * via EnableWebAssemblyTrapHandler(), or to skip it and reduce the amount of
+   * virtual memory required to keep the application running.
+   */
+  static size_t GetWasmMemoryReservationSizeInBytes(WasmMemoryType type,
+                                                    size_t byte_capacity);
+
   /**
    * Activate trap-based bounds checking for WebAssembly.
    *

package/include/node/v8-internal.h

@@ -10,6 +10,8 @@
 #include <string.h>
 
 #include <atomic>
+#include <compare>
+#include <concepts>
 #include <iterator>
 #include <limits>
 #include <memory>
@@ -18,22 +20,6 @@
 
 #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 && \
-    defined(__cpp_lib_concepts) && __cpp_lib_concepts >= 202002L
-#include <compare>
-#include <concepts>
-
-#define V8_HAVE_SPACESHIP_OPERATOR 1
-#else
-#define V8_HAVE_SPACESHIP_OPERATOR 0
-#endif
-
 namespace v8 {
 
 class Array;
@@ -322,6 +308,13 @@ constexpr size_t kExternalPointerTableReservationSize = 256 * MB;
 // smaller than the maximum table size even after the C++ compiler multiplies
 // them by 8 to be used as indexes into a table of 64 bit pointers.
 constexpr uint32_t kExternalPointerIndexShift = 7;
+#elif defined(V8_TARGET_OS_IOS)
+// iOS restricts large memory allocations, with 128 MB being the maximum size we
+// can configure. If we exceed this, SegmentedTable::Initialize will throw a V8
+// out-of-memory error when running the JetStream benchmark
+// (https://browserbench.org/JetStream/).
+constexpr size_t kExternalPointerTableReservationSize = 128 * MB;
+constexpr uint32_t kExternalPointerIndexShift = 8;
 #else
 constexpr size_t kExternalPointerTableReservationSize = 512 * MB;
 constexpr uint32_t kExternalPointerIndexShift = 6;
@@ -421,10 +414,15 @@ constexpr size_t kMaxCppHeapPointers = 0;
 
 #endif  // V8_COMPRESS_POINTERS
 
-// The number of tags reserved for embedder data. The value is picked
-// arbitrarily. In Chrome there are 4 embedders, so at least 4 tags are needed.
-// A generic tag was used for embedder data before, so one tag is used for that.
-#define V8_EMBEDDER_DATA_TAG_COUNT 5
+// The number of tags reserved for embedder data stored in internal fields. The
+// value is picked arbitrarily, and is slightly larger than the number of tags
+// currently used in Chrome.
+#define V8_EMBEDDER_DATA_TAG_COUNT 15
+
+// The number of tags reserved for pointers stored in v8::External. The value is
+// picked arbitrarily, and is slightly larger than the number of tags currently
+// used in Chrome.
+#define V8_EXTERNAL_POINTER_TAG_COUNT 40
 
 // Generic tag range struct to represent ranges of type tags.
 //
@@ -440,6 +438,35 @@ constexpr size_t kMaxCppHeapPointers = 0;
 // the type check to use even fewer instructions (essentially replace a AND +
 // SUB with a single AND).
 //
+// Tag ranges can also to a limited degree be used for union types. For
+// example, with the type graph as above, it would be possible to specify a
+// Union(D, E, F) as the tag range [D, F]. However, this only works as long as
+// the (otherwise independent) types that form the union have adjacent tags.
+//
+//
+// There are broadly speaking two options for performing the type check when
+// given the expected type range and the actual tag of the entry.
+//
+// The first option is to simply have the equivalent of
+//
+//     CHECK(expected_tag_range.Contains(actual_tag))
+//
+// This is nice and simple, and friendly to both the branch-predictor and the
+// user/developer as it produces clear error messages. However, this approach
+// may result in quite a bit of code being generated, for example for calling
+// RuntimeAbort from generated code or similar.
+//
+// The second option is to generate code such as
+//
+//     if (!expected_tag_range.Contains(actual_tag)) return nullptr;
+//
+// With this, we are also guaranteed to crash safely when the returned pointer
+// is used, but this may result in significantly less code being generated, for
+// example because the compiler can implement this with a single conditional
+// select in combination with the zero register (e.g. on Arm).
+//
+// The choice of which approach to use therefore depends on the use case, the
+// performance and code size constraints, and the importance of debuggability.
 template <typename Tag>
 struct TagRange {
   static_assert(std::is_enum_v<Tag> &&
@@ -447,7 +474,16 @@ struct TagRange {
                 "Tag parameter must be an enum with base type uint16_t");
 
   // Construct the inclusive tag range [first, last].
-  constexpr TagRange(Tag first, Tag last) : first(first), last(last) {}
+  constexpr TagRange(Tag first, Tag last) : first(first), last(last) {
+#ifdef V8_ENABLE_CHECKS
+    // This would typically be a DCHECK, but that's not available here.
+#if V8_HAS_BUILTIN_UNREACHABLE
+    if (first > last) __builtin_unreachable();  // Invalid tag range.
+#elif defined(_MSC_VER)
+    if (first > last) __assume(0);  // Invalid tag range.
+#endif
+#endif
+  }
 
   // Construct a tag range consisting of a single tag.
   //
@@ -475,8 +511,8 @@ struct TagRange {
     // Need to perform the math with uint32_t. Otherwise, the uint16_ts would
     // be promoted to (signed) int, allowing the compiler to (wrongly) assume
     // that an underflow cannot happen as that would be undefined behavior.
-    return static_cast<uint32_t>(tag) - first <=
-           static_cast<uint32_t>(last) - first;
+    return static_cast<uint32_t>(tag) - static_cast<uint32_t>(first) <=
+           static_cast<uint32_t>(last) - static_cast<uint32_t>(first);
   }
 
   constexpr bool Contains(TagRange tag_range) const {
@@ -492,9 +528,9 @@ struct TagRange {
     return (static_cast<size_t>(first) << 16) | last;
   }
 
-  // Internally we represent tag ranges as half-open ranges [first, last).
-  const Tag first;
-  const Tag last;
+  // Internally we represent tag ranges as closed ranges [first, last].
+  Tag first;
+  Tag last;
 };
 
 //
@@ -566,11 +602,15 @@ enum ExternalPointerTag : uint16_t {
   // Placeholders for embedder data.
   kFirstEmbedderDataTag,
   kLastEmbedderDataTag = kFirstEmbedderDataTag + V8_EMBEDDER_DATA_TAG_COUNT - 1,
-  kEmbedderDataSlotPayloadTag = kLastEmbedderDataTag,
-  // This tag essentially stands for a `void*` pointer in the V8 API, and it is
-  // the Embedder's responsibility to ensure type safety (against substitution)
-  // and lifetime validity of these objects.
-  kExternalObjectValueTag,
+
+  // Placeholders for pointers store in v8::External.
+  kFirstExternalTypeTag,
+  kLastExternalTypeTag =
+      kFirstExternalTypeTag + V8_EXTERNAL_POINTER_TAG_COUNT - 1,
+  // This tag is used when a fast-api callback as a parameter of type
+  // `kPointer`. The V8 fast API is only able to use this generic tag, and is
+  // therefore not supposed to be used in Chrome.
+  kFastApiExternalTypeTag = kLastExternalTypeTag,
   kFirstMaybeReadOnlyExternalPointerTag,
   kFunctionTemplateInfoCallbackTag = kFirstMaybeReadOnlyExternalPointerTag,
   kAccessorInfoGetterTag,
@@ -621,6 +661,7 @@ enum ExternalPointerTag : uint16_t {
   kWasmFuncDataTag,
   kWasmManagedDataTag,
   kWasmNativeModuleTag,
+  kBackingStoreTag,
   kIcuBreakIteratorTag,
   kIcuUnicodeStringTag,
   kIcuListFormatterTag,
@@ -906,6 +947,9 @@ class Internals {
   static const int kExternalTwoByteRepresentationTag = 0x02;
   static const int kExternalOneByteRepresentationTag = 0x0a;
 
+  // AccessorInfo::data and InterceptorInfo::data field.
+  static const int kCallbackInfoDataOffset = 1 * kApiTaggedSize;
+
   static const uint32_t kNumIsolateDataSlots = 4;
   static const int kStackGuardSize = 8 * kApiSystemPointerSize;
   static const int kNumberOfBooleanFlags = 6;
@@ -920,15 +964,11 @@ class Internals {
       2 * kApiSystemPointerSize + 2 * kApiInt32Size;
 
   // ExternalPointerTable and TrustedPointerTable layout guarantees.
-  static const int kExternalPointerTableBasePointerOffset = 0;
+  static const int kExternalEntityTableBasePointerOffset = 0;
   static const int kSegmentedTableSegmentPoolSize = 4;
-  static const int kExternalPointerTableSize =
-      4 * kApiSystemPointerSize +
-      kSegmentedTableSegmentPoolSize * sizeof(uint32_t);
-  static const int kTrustedPointerTableSize =
+  static const int kExternalEntityTableSize =
       4 * kApiSystemPointerSize +
       kSegmentedTableSegmentPoolSize * sizeof(uint32_t);
-  static const int kTrustedPointerTableBasePointerOffset = 0;
 
   // IsolateData layout guarantees.
   static const int kIsolateCageBaseOffset = 0;
@@ -972,39 +1012,57 @@ class Internals {
   static const int kIsolateExternalPointerTableOffset =
       kIsolateEmbedderDataOffset + kNumIsolateDataSlots * kApiSystemPointerSize;
   static const int kIsolateSharedExternalPointerTableAddressOffset =
-      kIsolateExternalPointerTableOffset + kExternalPointerTableSize;
+      kIsolateExternalPointerTableOffset + kExternalEntityTableSize;
   static const int kIsolateCppHeapPointerTableOffset =
       kIsolateSharedExternalPointerTableAddressOffset + kApiSystemPointerSize;
 #ifdef V8_ENABLE_SANDBOX
   static const int kIsolateTrustedCageBaseOffset =
-      kIsolateCppHeapPointerTableOffset + kExternalPointerTableSize;
+      kIsolateCppHeapPointerTableOffset + kExternalEntityTableSize;
   static const int kIsolateTrustedPointerTableOffset =
       kIsolateTrustedCageBaseOffset + kApiSystemPointerSize;
   static const int kIsolateSharedTrustedPointerTableAddressOffset =
-      kIsolateTrustedPointerTableOffset + kTrustedPointerTableSize;
+      kIsolateTrustedPointerTableOffset + kExternalEntityTableSize;
   static const int kIsolateTrustedPointerPublishingScopeOffset =
       kIsolateSharedTrustedPointerTableAddressOffset + kApiSystemPointerSize;
   static const int kIsolateCodePointerTableBaseAddressOffset =
       kIsolateTrustedPointerPublishingScopeOffset + kApiSystemPointerSize;
-  static const int kIsolateApiCallbackThunkArgumentOffset =
+  static const int kIsolateJSDispatchTableOffset =
       kIsolateCodePointerTableBaseAddressOffset + kApiSystemPointerSize;
 #else
-  static const int kIsolateApiCallbackThunkArgumentOffset =
-      kIsolateCppHeapPointerTableOffset + kExternalPointerTableSize;
+  static const int kIsolateJSDispatchTableOffset =
+      kIsolateCppHeapPointerTableOffset + kExternalEntityTableSize;
 #endif  // V8_ENABLE_SANDBOX
 #else
-  static const int kIsolateApiCallbackThunkArgumentOffset =
+  static const int kIsolateJSDispatchTableOffset =
       kIsolateEmbedderDataOffset + kNumIsolateDataSlots * kApiSystemPointerSize;
 #endif  // V8_COMPRESS_POINTERS
-  static const int kJSDispatchTableOffset =
-      kIsolateApiCallbackThunkArgumentOffset + kApiSystemPointerSize;
+  static const int kIsolateApiCallbackThunkArgumentOffset =
+      kIsolateJSDispatchTableOffset + kExternalEntityTableSize;
   static const int kIsolateRegexpExecVectorArgumentOffset =
-      kJSDispatchTableOffset + kApiSystemPointerSize;
+      kIsolateApiCallbackThunkArgumentOffset + kApiSystemPointerSize;
   static const int kContinuationPreservedEmbedderDataOffset =
       kIsolateRegexpExecVectorArgumentOffset + kApiSystemPointerSize;
   static const int kIsolateRootsOffset =
       kContinuationPreservedEmbedderDataOffset + kApiSystemPointerSize;
 
+#if V8_TARGET_ARCH_PPC64
+  static constexpr int kFrameCPSlotCount = 1;
+#else
+  static constexpr int kFrameCPSlotCount = 0;
+#endif
+
+#if V8_TARGET_ARCH_ARM64
+  // The padding required to keep SP 16-byte aligned.
+  static constexpr int kSPAlignmentSlotCount = 1;
+#else
+  static constexpr int kSPAlignmentSlotCount = 0;
+#endif
+
+  static const int kFrameTypeApiCallExit = 18;
+  static const int kFrameTypeApiConstructExit = 19;
+  static const int kFrameTypeApiNamedAccessorExit = 20;
+  static const int kFrameTypeApiIndexedAccessorExit = 21;
+
   // Assert scopes
   static const int kDisallowGarbageCollectionAlign = alignof(uint32_t);
   static const int kDisallowGarbageCollectionSize = sizeof(uint32_t);
@@ -1025,17 +1083,9 @@ class Internals {
   using Tagged_t = uint32_t;
   struct StaticReadOnlyRoot {
 #ifdef V8_ENABLE_WEBASSEMBLY
-#ifdef V8_INTL_SUPPORT
-    static constexpr Tagged_t kBuildDependentTheHoleValue = 0x67b9;
+    static constexpr Tagged_t kBuildDependentTheHoleValue = 0x2fffd;
 #else
-    static constexpr Tagged_t kBuildDependentTheHoleValue = 0x5b1d;
-#endif
-#else
-#ifdef V8_INTL_SUPPORT
-    static constexpr Tagged_t kBuildDependentTheHoleValue = 0x6511;
-#else
-    static constexpr Tagged_t kBuildDependentTheHoleValue = 0x5875;
-#endif
+    static constexpr Tagged_t kBuildDependentTheHoleValue = 0xfffd;
 #endif
 
 #define DEF_ROOT(name, value) static constexpr Tagged_t k##name = value;
@@ -1276,7 +1326,7 @@ class Internals {
   V8_INLINE static Address* GetExternalPointerTableBase(v8::Isolate* isolate) {
     Address addr = reinterpret_cast<Address>(isolate) +
                    kIsolateExternalPointerTableOffset +
-                   kExternalPointerTableBasePointerOffset;
+                   kExternalEntityTableBasePointerOffset;
     return *reinterpret_cast<Address**>(addr);
   }
 
@@ -1285,7 +1335,7 @@ class Internals {
     Address addr = reinterpret_cast<Address>(isolate) +
                    kIsolateSharedExternalPointerTableAddressOffset;
     addr = *reinterpret_cast<Address*>(addr);
-    addr += kExternalPointerTableBasePointerOffset;
+    addr += kExternalEntityTableBasePointerOffset;
     return *reinterpret_cast<Address**>(addr);
   }
 #endif
@@ -1328,18 +1378,6 @@ class Internals {
 #endif
   }
 
-  V8_DEPRECATED(
-      "Use GetCurrentIsolateForSandbox() instead, which is guaranteed to "
-      "return the same isolate since https://crrev.com/c/6458560.")
-  V8_INLINE static v8::Isolate* GetIsolateForSandbox(Address obj) {
-#ifdef V8_ENABLE_SANDBOX
-    return GetCurrentIsolate();
-#else
-    // Not used in non-sandbox mode.
-    return nullptr;
-#endif
-  }
-
   // Returns v8::Isolate::Current(), but without needing to include the
   // v8-isolate.h header.
   V8_EXPORT static v8::Isolate* GetCurrentIsolate();
@@ -1383,6 +1421,34 @@ class Internals {
 #endif  // V8_ENABLE_SANDBOX
   }
 
+  V8_INLINE static Address ReadExternalPointerField(
+      v8::Isolate* isolate, Address heap_object_ptr, int offset,
+      ExternalPointerTagRange tag_range) {
+#ifdef V8_ENABLE_SANDBOX
+    // See src/sandbox/external-pointer-table.h. Logic duplicated here so
+    // it can be inlined and doesn't require an additional call.
+    Address* table = IsSharedExternalPointerType(tag_range)
+                         ? GetSharedExternalPointerTableBase(isolate)
+                         : GetExternalPointerTableBase(isolate);
+    internal::ExternalPointerHandle handle =
+        ReadRawField<ExternalPointerHandle>(heap_object_ptr, offset);
+    uint32_t index = handle >> kExternalPointerIndexShift;
+    std::atomic<Address>* ptr =
+        reinterpret_cast<std::atomic<Address>*>(&table[index]);
+    Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed);
+    ExternalPointerTag actual_tag = static_cast<ExternalPointerTag>(
+        (entry & kExternalPointerTagMask) >> kExternalPointerTagShift);
+    if (V8_LIKELY(tag_range.Contains(actual_tag))) {
+      return entry & kExternalPointerPayloadMask;
+    } else {
+      return 0;
+    }
+    return entry;
+#else
+    return ReadRawField<Address>(heap_object_ptr, offset);
+#endif  // V8_ENABLE_SANDBOX
+  }
+
 #ifdef V8_COMPRESS_POINTERS
   V8_INLINE static Address GetPtrComprCageBaseFromOnHeapAddress(Address addr) {
     return addr & -static_cast<intptr_t>(kPtrComprCageBaseAlignment);
@@ -1439,12 +1505,7 @@ class V8_EXPORT StrongRootAllocatorBase {
  public:
   Heap* heap() const { return heap_; }
 
-  friend bool operator==(const StrongRootAllocatorBase& a,
-                         const StrongRootAllocatorBase& b) {
-    // TODO(pkasting): Replace this body with `= default` after dropping support
-    // for old gcc versions.
-    return a.heap_ == b.heap_;
-  }
+  constexpr bool operator==(const StrongRootAllocatorBase&) const = default;
 
  protected:
   explicit StrongRootAllocatorBase(Heap* heap) : heap_(heap) {}
@@ -1480,45 +1541,29 @@ class StrongRootAllocator : private std::allocator<T> {
   using std::allocator<T>::deallocate;
 };
 
-// TODO(pkasting): Replace with `requires` clauses after dropping support for
-// old gcc versions.
-template <typename Iterator, typename = void>
-inline constexpr bool kHaveIteratorConcept = false;
 template <typename Iterator>
-inline constexpr bool kHaveIteratorConcept<
-    Iterator, std::void_t<typename Iterator::iterator_concept>> = true;
+concept HasIteratorConcept = requires { typename Iterator::iterator_concept; };
 
-template <typename Iterator, typename = void>
-inline constexpr bool kHaveIteratorCategory = false;
 template <typename Iterator>
-inline constexpr bool kHaveIteratorCategory<
-    Iterator, std::void_t<typename Iterator::iterator_category>> = true;
+concept HasIteratorCategory =
+    requires { typename Iterator::iterator_category; };
 
 // Helper struct that contains an `iterator_concept` type alias only when either
 // `Iterator` or `std::iterator_traits<Iterator>` do.
 // Default: no alias.
-template <typename Iterator, typename = void>
+template <typename Iterator>
 struct MaybeDefineIteratorConcept {};
 // Use `Iterator::iterator_concept` if available.
-template <typename Iterator>
-struct MaybeDefineIteratorConcept<
-    Iterator, std::enable_if_t<kHaveIteratorConcept<Iterator>>> {
+template <HasIteratorConcept Iterator>
+struct MaybeDefineIteratorConcept<Iterator> {
   using iterator_concept = typename Iterator::iterator_concept;
 };
 // Otherwise fall back to `std::iterator_traits<Iterator>` if possible.
 template <typename Iterator>
-struct MaybeDefineIteratorConcept<
-    Iterator, std::enable_if_t<kHaveIteratorCategory<Iterator> &&
-                               !kHaveIteratorConcept<Iterator>>> {
-  // 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>)
+  requires(HasIteratorCategory<Iterator> && !HasIteratorConcept<Iterator>)
+struct MaybeDefineIteratorConcept<Iterator> {
   using iterator_concept =
       typename std::iterator_traits<Iterator>::iterator_concept;
-#endif
 };
 
 // A class of iterators that wrap some different iterator type.
@@ -1555,11 +1600,8 @@ class WrappedIterator : public MaybeDefineIteratorConcept<Iterator> {
   constexpr WrappedIterator() noexcept = default;
   constexpr explicit WrappedIterator(Iterator it) noexcept : it_(it) {}
 
-  // TODO(pkasting): Switch to `requires` and concepts after dropping support
-  // for old gcc and libstdc++ versions.
-  template <typename OtherIterator, typename OtherElementType,
-            typename = std::enable_if_t<
-                std::is_convertible_v<OtherIterator, Iterator>>>
+  template <typename OtherIterator, typename OtherElementType>
+    requires std::is_convertible_v<OtherIterator, Iterator>
   constexpr WrappedIterator(
       const WrappedIterator<OtherIterator, OtherElementType>& other) noexcept
       : it_(other.base()) {}
@@ -1579,7 +1621,7 @@ class WrappedIterator : public MaybeDefineIteratorConcept<Iterator> {
       const noexcept {
     return it_ == other.base();
   }
-#if V8_HAVE_SPACESHIP_OPERATOR
+
   template <typename OtherIterator, typename OtherElementType>
   [[nodiscard]] constexpr auto operator<=>(
       const WrappedIterator<OtherIterator, OtherElementType>& other)
@@ -1603,41 +1645,6 @@ class WrappedIterator : public MaybeDefineIteratorConcept<Iterator> {
                                    : std::partial_ordering::unordered;
     }
   }
-#else
-  // Assume that if spaceship isn't present, operator rewriting might not be
-  // either.
-  template <typename OtherIterator, typename OtherElementType>
-  [[nodiscard]] constexpr bool operator!=(
-      const WrappedIterator<OtherIterator, OtherElementType>& other)
-      const noexcept {
-    return it_ != other.base();
-  }
-
-  template <typename OtherIterator, typename OtherElementType>
-  [[nodiscard]] constexpr bool operator<(
-      const WrappedIterator<OtherIterator, OtherElementType>& other)
-      const noexcept {
-    return it_ < other.base();
-  }
-  template <typename OtherIterator, typename OtherElementType>
-  [[nodiscard]] constexpr bool operator<=(
-      const WrappedIterator<OtherIterator, OtherElementType>& other)
-      const noexcept {
-    return it_ <= other.base();
-  }
-  template <typename OtherIterator, typename OtherElementType>
-  [[nodiscard]] constexpr bool operator>(
-      const WrappedIterator<OtherIterator, OtherElementType>& other)
-      const noexcept {
-    return it_ > other.base();
-  }
-  template <typename OtherIterator, typename OtherElementType>
-  [[nodiscard]] constexpr bool operator>=(
-      const WrappedIterator<OtherIterator, OtherElementType>& other)
-      const noexcept {
-    return it_ >= other.base();
-  }
-#endif
 
   constexpr WrappedIterator& operator++() noexcept {
     ++it_;

package/include/node/v8-isolate.h

@@ -8,6 +8,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
@@ -356,16 +357,6 @@ class V8_EXPORT Isolate {
      */
     bool allow_atomics_wait = true;
 
-    /**
-     * The following parameters describe the offsets for addressing type info
-     * for wrapped API objects and are used by the fast C API
-     * (for details see v8-fast-api-calls.h).
-     */
-    V8_DEPRECATE_SOON("This field is unused.")
-    int embedder_wrapper_type_index = -1;
-    V8_DEPRECATE_SOON("This field is unused.")
-    int embedder_wrapper_object_index = -1;
-
     /**
      * Callbacks to invoke in case of fatal or OOM errors.
      */
@@ -668,6 +659,7 @@ class V8_EXPORT Isolate {
     kWithStatement = 180,
     kHtmlWrapperMethods = 181,
     kWasmCustomDescriptors = 182,
+    kWasmResizableBuffers = 183,
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
@@ -861,6 +853,12 @@ class V8_EXPORT Isolate {
    */
   void MemoryPressureNotification(MemoryPressureLevel level);
 
+  /**
+   * This triggers garbage collections until either `allocate` succeeds, or
+   * until v8 gives up and triggers an OOM error.
+   */
+  bool RetryCustomAllocate(std::function<bool()> allocate);
+
   /**
    * Optional request from the embedder to tune v8 towards energy efficiency
    * rather than speed if `battery_saver_mode_enabled` is true, because the
@@ -1001,13 +999,6 @@ class V8_EXPORT Isolate {
    */
   void GetHeapStatistics(HeapStatistics* heap_statistics);
 
-  /**
-   * Get total allocated bytes since isolate creation.
-   * This should be used only by Node.JS, since it's a temporary method
-   * to avoid breaking ABI on HeapStatistics.
-   */
-  uint64_t GetTotalAllocatedBytes();
-
   /**
    * Returns the number of spaces in the heap.
    */
@@ -1489,6 +1480,13 @@ class V8_EXPORT Isolate {
    */
   void SetAddCrashKeyCallback(AddCrashKeyCallback);
 
+  /**
+   * Enables the host application to provide a mechanism for allocating a new
+   * crash key and setting/updating values for them.
+   */
+  void SetCrashKeyStringCallbacks(AllocateCrashKeyStringCallback,
+                                  SetCrashKeyStringCallback);
+
   /**
    * Optional notification that the system is running low on memory.
    * V8 uses these notifications to attempt to free memory.
@@ -1550,6 +1548,19 @@ class V8_EXPORT Isolate {
    */
   void SetIsLoading(bool is_loading);
 
+  /**
+   * Optional notification to tell V8 whether the embedder is currently
+   * handling user input. If the embedder uses this notification, it should
+   * call SetIsInputHandling(true) when input handling starts, and
+   * SetIsInputHandling(false) when it ends.
+   * Calling SetIsInputHandling(true) while handling input, or calling
+   * SetIsInputHandling(false) while not handling input, both have no effect.
+   * V8 uses these notifications to guide heuristics.
+   * This is an unfinished experimental feature. Semantics and implementation
+   * may change frequently.
+   */
+  void SetIsInputHandling(bool is_input_handling);
+
   /**
    * Optional notification to tell V8 whether the embedder is currently frozen.
    * V8 uses these notifications to guide heuristics.
@@ -1662,6 +1673,13 @@ class V8_EXPORT Isolate {
   /** Set the callback to invoke in case of OOM errors. */
   void SetOOMErrorHandler(OOMErrorCallback that);
 
+  /**
+   * \copydoc SetOOMErrorHandler(OOMErrorCallback)
+   *
+   * \param data Additional data that should be passed to the callback.
+   */
+  void SetOOMErrorHandler(OOMErrorCallbackWithData that, void* data);
+
   /**
    * Add a callback to invoke in case the heap size is close to the heap limit.
    * If multiple callbacks are added, only the most recently added callback is
@@ -1715,17 +1733,12 @@ class V8_EXPORT Isolate {
 
   void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback);
 
-  void SetWasmImportedStringsEnabledCallback(
-      WasmImportedStringsEnabledCallback callback);
-
   void SetWasmCustomDescriptorsEnabledCallback(
       WasmCustomDescriptorsEnabledCallback callback);
 
   void SetSharedArrayBufferConstructorEnabledCallback(
       SharedArrayBufferConstructorEnabledCallback callback);
 
-  void SetWasmJSPIEnabledCallback(WasmJSPIEnabledCallback callback);
-
   /**
    * This function can be called by the embedder to signal V8 that the dynamic
    * enabling of features has finished. V8 can now set up dynamically added

package/include/node/v8-local-handle.h

@@ -389,7 +389,7 @@ class V8_TRIVIAL_ABI Local : public LocalBase<T>,
    * objects to which they refer are physically equal.
    *
    * If both handles refer to JS objects, this is the same as strict
-   * non-equality. For primitives, such as numbers or strings, a `true` return
+   * non-equality. For primitives, such as numbers or strings, a `false` return
    * value does not indicate that the values aren't equal in the JavaScript
    * sense. Use `Value::StrictEquals()` to check primitives for equality.
    */