node-darwin-x64 24.8.0 → 25.0.0

package/include/node/v8-isolate.h

@@ -154,6 +154,10 @@ class V8_EXPORT ResourceConstraints {
     initial_young_generation_size_ = initial_size;
   }
 
+  uint64_t physical_memory_size_in_bytes() const {
+    return physical_memory_size_;
+  }
+
  private:
   static constexpr size_t kMB = 1048576u;
   size_t code_range_size_ = 0;
@@ -161,6 +165,7 @@ class V8_EXPORT ResourceConstraints {
   size_t max_young_generation_size_ = 0;
   size_t initial_old_generation_size_ = 0;
   size_t initial_young_generation_size_ = 0;
+  uint64_t physical_memory_size_ = 0;
   uint32_t* stack_limit_ = nullptr;
 };
 
@@ -253,6 +258,17 @@ class V8_EXPORT IsolateGroup {
     return !operator==(other);
   }
 
+#ifdef V8_ENABLE_SANDBOX
+  /**
+   * Whether the sandbox of the isolate group contains a given pointer.
+   * Will always return true if the sandbox is not enabled.
+   */
+  bool SandboxContains(void* pointer) const;
+  VirtualAddressSpace* GetSandboxAddressSpace();
+#else
+  V8_INLINE bool SandboxContains(void* pointer) const { return true; }
+#endif
+
  private:
   friend class Isolate;
   friend class ArrayBuffer::Allocator;
@@ -345,7 +361,9 @@ class V8_EXPORT Isolate {
      * 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;
 
     /**
@@ -557,7 +575,8 @@ class V8_EXPORT Isolate {
     kBreakIteratorTypeWord = 88,
     kBreakIteratorTypeLine = 89,
     kInvalidatedArrayBufferDetachingProtector = 90,
-    kInvalidatedArrayConstructorProtector = 91,
+    kInvalidatedArrayConstructorProtector V8_DEPRECATE_SOON(
+        "The ArrayConstructorProtector has been removed") = 91,
     kInvalidatedArrayIteratorLookupChainProtector = 92,
     kInvalidatedArraySpeciesLookupChainProtector = 93,
     kInvalidatedIsConcatSpreadableLookupChainProtector = 94,
@@ -575,8 +594,8 @@ class V8_EXPORT Isolate {
     kWasmSimdOpcodes = 106,
     kVarRedeclaredCatchBinding = 107,
     kWasmRefTypes = 108,
-    kOBSOLETE_WasmBulkMemory = 109,
-    kOBSOLETE_WasmMultiValue = 110,
+    kWasmBulkMemory = 109,
+    kWasmMultiValue = 110,
     kWasmExceptionHandling = 111,
     kInvalidatedMegaDOMProtector = 112,
     kFunctionPrototypeArguments = 113,
@@ -634,6 +653,21 @@ class V8_EXPORT Isolate {
     kFloat16Array = 165,
     kExplicitResourceManagement = 166,
     kWasmBranchHinting = 167,
+    kWasmMutableGlobals = 168,
+    kUint8ArrayToFromBase64AndHex = 169,
+    kAtomicsPause = 170,
+    kTopLevelAwait = 171,
+    kLogicalAssignment = 172,
+    kNullishCoalescing = 173,
+    kInvalidatedNoDateTimeConfigurationChangeProtector = 174,
+    kWasmNonTrappingFloatToInt = 175,
+    kWasmSignExtensionOps = 176,
+    kRegExpCompile = 177,
+    kRegExpStaticProperties = 178,
+    kRegExpStaticPropertiesWithLastMatch = 179,
+    kWithStatement = 180,
+    kHtmlWrapperMethods = 181,
+    kWasmCustomDescriptors = 182,
 
     // 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
@@ -937,14 +971,31 @@ class V8_EXPORT Isolate {
    * Returns the value that was set or restored by
    * SetContinuationPreservedEmbedderData(), if any.
    */
+  V8_DEPRECATED("Use GetContinuationPreservedEmbedderDataV2 instead")
   Local<Value> GetContinuationPreservedEmbedderData();
 
   /**
    * Sets a value that will be stored on continuations and reset while the
    * continuation runs.
    */
+  V8_DEPRECATED("Use SetContinuationPreservedEmbedderDataV2 instead")
   void SetContinuationPreservedEmbedderData(Local<Value> data);
 
+  /**
+   * Returns the value set by `SetContinuationPreservedEmbedderDataV2()` or
+   * restored during microtask execution for the currently running continuation,
+   * if any. Returns undefiend if no continuation preserved embedder data was
+   * set.
+   */
+  Local<Data> GetContinuationPreservedEmbedderDataV2();
+
+  /**
+   * Sets a value that will be stored on continuations and restored while the
+   * continuation runs. If `data` is empty, the continuation preserved embedder
+   * data is set to undefined.
+   */
+  void SetContinuationPreservedEmbedderDataV2(Local<Data> data);
+
   /**
    * Get statistics about the heap memory usage.
    */
@@ -1660,21 +1711,14 @@ class V8_EXPORT Isolate {
   void SetWasmImportedStringsEnabledCallback(
       WasmImportedStringsEnabledCallback callback);
 
+  void SetWasmCustomDescriptorsEnabledCallback(
+      WasmCustomDescriptorsEnabledCallback callback);
+
   void SetSharedArrayBufferConstructorEnabledCallback(
       SharedArrayBufferConstructorEnabledCallback callback);
 
   void SetWasmJSPIEnabledCallback(WasmJSPIEnabledCallback callback);
 
-  /**
-   * Register callback to control whether compile hints magic comments are
-   * enabled.
-   */
-  V8_DEPRECATED(
-      "Will be removed, use ScriptCompiler::CompileOptions for enabling the "
-      "compile hints magic comments")
-  void SetJavaScriptCompileHintsMagicEnabledCallback(
-      JavaScriptCompileHintsMagicEnabledCallback 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
@@ -1697,7 +1741,7 @@ class V8_EXPORT Isolate {
    * If data is specified, it will be passed to the callback when it is called.
    * Otherwise, the exception object will be passed to the callback instead.
    */
-  bool AddMessageListener(MessageCallback that,
+  bool AddMessageListener(MessageCallback callback,
                           Local<Value> data = Local<Value>());
 
   /**
@@ -1711,14 +1755,14 @@ class V8_EXPORT Isolate {
    *
    * A listener can listen for particular error levels by providing a mask.
    */
-  bool AddMessageListenerWithErrorLevel(MessageCallback that,
+  bool AddMessageListenerWithErrorLevel(MessageCallback callback,
                                         int message_levels,
                                         Local<Value> data = Local<Value>());
 
   /**
    * Remove all message listeners from the specified callback function.
    */
-  void RemoveMessageListeners(MessageCallback that);
+  void RemoveMessageListeners(MessageCallback callback);
 
   /** Callback function for reporting failed access checks.*/
   void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
@@ -1789,6 +1833,21 @@ class V8_EXPORT Isolate {
    */
   std::string GetDefaultLocale();
 
+  /**
+   * Returns a canonical and case-regularized form of locale if Intl support is
+   * enabled. If the locale is not syntactically well-formed, throws a
+   * RangeError.
+   *
+   * If Intl support is not enabled, returns Nothing<std::string>().
+   *
+   * Corresponds to the combination of the abstract operations
+   * IsStructurallyValidLanguageTag and CanonicalizeUnicodeLocaleId. See:
+   * https://tc39.es/ecma402/#sec-isstructurallyvalidlanguagetag
+   * https://tc39.es/ecma402/#sec-canonicalizeunicodelocaleid
+   */
+  V8_WARN_UNUSED_RESULT Maybe<std::string>
+  ValidateAndCanonicalizeUnicodeLocaleId(std::string_view locale);
+
   /**
    * Returns the hash seed for that isolate, for testing purposes.
    */

package/include/node/v8-json.h

@@ -5,7 +5,10 @@
 #ifndef INCLUDE_V8_JSON_H_
 #define INCLUDE_V8_JSON_H_
 
+#include <optional>
+
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-message.h"       // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -25,10 +28,14 @@ class V8_EXPORT JSON {
    *
    * \param the context in which to parse and create the value.
    * \param json_string The string to parse.
+   * \param origin Optional script origin to use for error reporting.
+   * If not provided, error reporting will use default origin options
+   * or attempt to infer origin from the current stack.
    * \return The corresponding value if successfully parsed.
    */
   static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse(
-      Local<Context> context, Local<String> json_string);
+      Local<Context> context, Local<String> json_string,
+      std::optional<ScriptOrigin> origin = std::nullopt);
 
   /**
    * Tries to stringify the JSON-serializable object |json_object| and returns

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

@@ -42,6 +42,7 @@ class BasicTracedReference;
 template <class F>
 class TracedReference;
 
+class ArrayBuffer;
 class Boolean;
 class Context;
 class EscapableHandleScope;
@@ -62,6 +63,8 @@ template <class F>
 class Traced;
 class TypecheckWitness;
 class Utils;
+class Uint32;
+class Value;
 
 namespace debug {
 class ConsoleCallArguments;
@@ -78,6 +81,25 @@ class SamplingHeapProfiler;
 namespace api_internal {
 // Called when ToLocalChecked is called on an empty Local.
 V8_EXPORT void ToLocalEmpty();
+
+#ifdef V8_ENABLE_CHECKS
+template <typename T, typename V = Value>
+void TypeCheckLocal(V* value) {
+  // If `T` does not provide a `Cast` method we cannot check anything.
+  if constexpr (requires { T::Cast(value); }) {
+    // TODO(419454582): Remove all these exceptions.
+    if (std::is_same_v<Array, T> && value->IsArgumentsObject()) return;
+    if (std::is_same_v<ArrayBuffer, T> && value->IsSharedArrayBuffer()) return;
+    if (std::is_same_v<Object, T> && value->IsNull()) return;
+    if (std::is_same_v<Object, T> && value->IsString()) return;
+    if (std::is_same_v<Object, T> && value->IsUndefined()) return;
+    if (std::is_same_v<Uint32, T> && value->IsInt32()) return;
+    if (std::is_same_v<Object, T> && value->IsNumber()) return;
+    // Execute the actual check (part of the cast).
+    T::Cast(value);
+  }
+}
+#endif
 }  // namespace api_internal
 
 /**
@@ -96,18 +118,16 @@ V8_EXPORT void ToLocalEmpty();
  */
 class V8_EXPORT V8_NODISCARD HandleScope {
  public:
-  explicit HandleScope(Isolate* isolate);
+  V8_INLINE explicit HandleScope(Isolate* isolate);
 
-  ~HandleScope();
+  V8_INLINE ~HandleScope();
 
   /**
    * Counts the number of allocated handles.
    */
   static int NumberOfHandles(Isolate* isolate);
 
-  V8_INLINE Isolate* GetIsolate() const {
-    return reinterpret_cast<Isolate*>(i_isolate_);
-  }
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
 
   HandleScope(const HandleScope&) = delete;
   void operator=(const HandleScope&) = delete;
@@ -118,12 +138,29 @@ class V8_EXPORT V8_NODISCARD HandleScope {
  protected:
   V8_INLINE HandleScope() = default;
 
-  void Initialize(Isolate* isolate);
+  V8_INLINE void Initialize(Isolate* isolate);
 
-  static internal::Address* CreateHandle(internal::Isolate* i_isolate,
-                                         internal::Address value);
+  V8_INLINE static internal::Address* CreateHandle(Isolate* i_isolate,
+                                                   internal::Address value);
 
  private:
+  // Extend the HandleScope making room for more handles.  Not inlined.
+  static internal::Address* Extend(Isolate* isolate);
+  // Delete any extensions in HandleScope destructor.  Not called unless there
+  // are extensions.  Not inlined.
+  void DeleteExtensions(Isolate* isolate);
+
+#ifdef V8_ENABLE_CHECKS
+  // Non-inlined asserts on HandleScope constructor.
+  void DoInitializeAsserts(Isolate* isolate);
+  // Non-inlined assert for HandleScope destructor.
+  void AssertScopeLevelsMatch();
+  // Non-inlined asserts for HandleScope destructor.  Also zaps the slots
+  // if this is enabled.
+  void DoCloseScopeAsserts(int before, internal::Address* limit,
+                           internal::HandleScopeData* current);
+#endif
+
   // Declaring operator new and delete as deleted is not spec compliant.
   // Therefore declare them private instead to disable dynamic alloc
   void* operator new(size_t size);
@@ -131,7 +168,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);
 
-  internal::Isolate* i_isolate_;
+  Isolate* isolate_;
   internal::Address* prev_next_;
   internal::Address* prev_limit_;
 #ifdef V8_ENABLE_CHECKS
@@ -148,6 +185,61 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   friend class Context;
 };
 
+HandleScope::HandleScope(Isolate* v8_isolate) { Initialize(v8_isolate); }
+
+void HandleScope::Initialize(Isolate* v8_isolate) {
+  using I = internal::Internals;
+  internal::HandleScopeData* current = I::GetHandleScopeData(v8_isolate);
+  isolate_ = v8_isolate;
+  prev_next_ = current->next;
+  prev_limit_ = current->limit;
+  current->level++;
+#ifdef V8_ENABLE_CHECKS
+  DoInitializeAsserts(v8_isolate);
+  scope_level_ = current->level;
+#endif
+}
+
+HandleScope::~HandleScope() {
+  if (V8_UNLIKELY(isolate_ == nullptr)) return;
+#ifdef V8_ENABLE_CHECKS
+  AssertScopeLevelsMatch();
+  int handle_count_before = NumberOfHandles(isolate_);
+#endif
+
+  using I = internal::Internals;
+  internal::HandleScopeData* current = I::GetHandleScopeData(isolate_);
+  std::swap(current->next, prev_next_);
+  current->level--;
+  internal::Address* limit = prev_next_;
+  if (V8_UNLIKELY(current->limit != prev_limit_)) {
+    current->limit = prev_limit_;
+    limit = prev_limit_;
+    DeleteExtensions(isolate_);
+  }
+#ifdef V8_ENABLE_CHECKS
+  DoCloseScopeAsserts(handle_count_before, limit, current);
+#else
+  (void)limit;  // Avoid unused variable warning.
+#endif
+}
+
+internal::Address* HandleScope::CreateHandle(Isolate* v8_isolate,
+                                             internal::Address value) {
+  using I = internal::Internals;
+  internal::HandleScopeData* data = I::GetHandleScopeData(v8_isolate);
+  internal::Address* result = data->next;
+  if (V8_UNLIKELY(result == data->limit)) {
+    result = Extend(v8_isolate);
+  }
+  // Update the current next field, set the value in the created handle,
+  // and return the result.
+  data->next = reinterpret_cast<internal::Address*>(
+      reinterpret_cast<internal::Address>(result) + sizeof(internal::Address));
+  *result = value;
+  return result;
+}
+
 /**
  * A base class for local handles.
  * Its implementation depends on whether direct handle support is enabled.
@@ -164,7 +256,11 @@ class LocalBase : public api_internal::DirectHandleBase {
 
   V8_INLINE LocalBase() = default;
 
-  V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {}
+  V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {
+#ifdef V8_ENABLE_CHECKS
+    if (!IsEmpty()) api_internal::TypeCheckLocal<T>(value<Value>());
+#endif
+  }
 
   template <typename S>
   V8_INLINE LocalBase(const LocalBase<S>& other) : DirectHandleBase(other) {}
@@ -200,14 +296,17 @@ class LocalBase : public api_internal::IndirectHandleBase {
   V8_INLINE LocalBase() = default;
 
   V8_INLINE explicit LocalBase(internal::Address* location)
-      : IndirectHandleBase(location) {}
+      : IndirectHandleBase(location) {
+#ifdef V8_ENABLE_CHECKS
+    if (!IsEmpty()) api_internal::TypeCheckLocal<T>(value<Value>());
+#endif
+  }
 
   template <typename S>
   V8_INLINE LocalBase(const LocalBase<S>& other) : IndirectHandleBase(other) {}
 
   V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) {
-    return LocalBase(HandleScope::CreateHandle(
-        reinterpret_cast<internal::Isolate*>(isolate), value));
+    return LocalBase(HandleScope::CreateHandle(isolate, value));
   }
 
   V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) {

package/include/node/v8-maybe.h

@@ -14,6 +14,12 @@
 
 namespace v8 {
 
+namespace internal {
+struct NullMaybeType {};
+
+constexpr NullMaybeType kNullMaybe;
+}  // namespace internal
+
 namespace api_internal {
 // Called when ToChecked is called on an empty Maybe.
 V8_EXPORT void FromJustIsNothing();
@@ -32,9 +38,19 @@ V8_EXPORT void FromJustIsNothing();
 template <class T>
 class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
+  constexpr Maybe() = default;
+
+  V8_INLINE Maybe(internal::NullMaybeType) {}
+
   V8_INLINE bool IsNothing() const { return !has_value_; }
   V8_INLINE bool IsJust() const { return has_value_; }
 
+  /**
+   * Same as IsNothing(). It's useful for unified handling of empty states
+   * with v8::MaybeLocal<T>.
+   */
+  V8_INLINE bool IsEmpty() const { return IsNothing(); }
+
   /**
    * An alias for |FromJust|. Will crash if the Maybe<> is nothing.
    */
@@ -57,6 +73,16 @@ class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
     return IsJust();
   }
 
+  /**
+   * Converts this Maybe<> to a value of type T, moving out of it. If this
+   * Maybe<> is nothing (empty), |false| is returned and |out| is left
+   * untouched.
+   */
+  V8_WARN_UNUSED_RESULT V8_INLINE bool MoveTo(T* out) && {
+    if (V8_LIKELY(IsJust())) *out = std::move(value_);
+    return IsJust();
+  }
+
   /**
    * Converts this Maybe<> to a value of type T. If this Maybe<> is
    * nothing (empty), V8 will crash the process.
@@ -93,15 +119,12 @@ class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
   }
 
  private:
-  Maybe() : has_value_(false) {}
   explicit Maybe(const T& t) : has_value_(true), value_(t) {}
   explicit Maybe(T&& t) : has_value_(true), value_(std::move(t)) {}
 
-  bool has_value_;
+  bool has_value_ = false;
   T value_;
 
-  template <class U>
-  friend Maybe<U> Nothing();
   template <class U>
   friend Maybe<U> Just(const U& u);
   template <class U, std::enable_if_t<!std::is_lvalue_reference_v<U>>*>
@@ -109,8 +132,8 @@ class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
 };
 
 template <class T>
-inline Maybe<T> Nothing() {
-  return Maybe<T>();
+inline constexpr Maybe<T> Nothing() {
+  return {};
 }
 
 template <class T>
@@ -130,7 +153,11 @@ inline Maybe<T> Just(T&& t) {
 template <>
 class Maybe<void> {
  public:
+  constexpr Maybe() = default;
+  constexpr Maybe(internal::NullMaybeType) {}
+
   V8_INLINE bool IsNothing() const { return !is_valid_; }
+  V8_INLINE bool IsEmpty() const { return IsNothing(); }
   V8_INLINE bool IsJust() const { return is_valid_; }
 
   V8_INLINE bool operator==(const Maybe& other) const {
@@ -144,13 +171,10 @@ class Maybe<void> {
  private:
   struct JustTag {};
 
-  Maybe() : is_valid_(false) {}
   explicit Maybe(JustTag) : is_valid_(true) {}
 
-  bool is_valid_;
+  bool is_valid_ = false;
 
-  template <class U>
-  friend Maybe<U> Nothing();
   friend Maybe<void> JustVoid();
 };
 

package/include/node/v8-memory-span.h

@@ -87,15 +87,20 @@ class V8_EXPORT MemorySpan {
   static constexpr bool is_compatible_iterator_v =
       is_compatible_iterator<It>::value;
 
+  // SFINAE-compatible wrapper for `std::to_address()`.
+  // Adapted from "base/types/to_address.h" in chromium.
   template <typename U>
+    requires(!std::is_function_v<U>)
   [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
     return p;
   }
 
-  template <typename It,
-            typename = std::void_t<decltype(std::declval<It&>().operator->())>>
-  [[nodiscard]] static constexpr auto to_address(It it) noexcept {
-    return it.operator->();
+  template <typename It>
+    requires(
+        requires(const It& it) { std::pointer_traits<It>::to_address(it); } ||
+        requires(const It& it) { it.operator->(); })
+  [[nodiscard]] static constexpr auto to_address(const It& it) noexcept {
+    return std::to_address(it);
   }
 
  public:

package/include/node/v8-message.h

@@ -111,6 +111,9 @@ class V8_EXPORT Message {
   /**
    * Return the isolate to which the Message belongs.
    */
+  V8_DEPRECATED(
+      "Use Isolate::GetCurrent() instead, which is guaranteed to return the "
+      "same isolate since https://crrev.com/c/6458560.")
   Isolate* GetIsolate() const;
 
   V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSource(