node-darwin-x64 24.8.0 → 25.0.0

package/include/node/v8-object.h

@@ -5,6 +5,8 @@
 #ifndef INCLUDE_V8_OBJECT_H_
 #define INCLUDE_V8_OBJECT_H_
 
+#include "cppgc/garbage-collected.h"
+#include "cppgc/name-provider.h"
 #include "v8-internal.h"           // NOLINT(build/include_directory)
 #include "v8-local-handle.h"       // NOLINT(build/include_directory)
 #include "v8-maybe.h"              // NOLINT(build/include_directory)
@@ -23,6 +25,14 @@ class FunctionTemplate;
 template <typename T>
 class PropertyCallbackInfo;
 
+/**
+ * A tag for embedder data. Objects with different C++ types should use
+ * different values of EmbedderDataTypeTag when written to embedder data. The
+ * allowed range is 0..V8_EMBEDDER_DATA_TAG_COUNT - 1. If this is not
+ * sufficient, V8_EMBEDDER_DATA_TAG_COUNT can be increased.
+ */
+using EmbedderDataTypeTag = uint16_t;
+
 /**
  * A private symbol
  *
@@ -427,15 +437,15 @@ class V8_EXPORT Object : public Value {
    * be skipped by __proto__ and it does not consult the security
    * handler.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "V8 will stop providing access to hidden prototype (i.e. "
       "JSGlobalObject). Use GetPrototypeV2() instead. "
       "See http://crbug.com/333672197.")
   Local<Value> GetPrototype();
 
   /**
-   * Get the prototype object (same as getting __proto__ property).  This does
-   * not consult the security handler.
+   * Get the prototype object (same as calling Object.getPrototypeOf(..)).
+   * This does not consult the security handler.
    * TODO(333672197): rename back to GetPrototype() once the old version goes
    * through the deprecation process and is removed.
    */
@@ -446,7 +456,7 @@ class V8_EXPORT Object : public Value {
    * be skipped by __proto__ and it does not consult the security
    * handler.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "V8 will stop providing access to hidden prototype (i.e. "
       "JSGlobalObject). Use SetPrototypeV2() instead. "
       "See http://crbug.com/333672197.")
@@ -454,8 +464,8 @@ class V8_EXPORT Object : public Value {
                                                  Local<Value> prototype);
 
   /**
-   * Set the prototype object (same as setting __proto__ property).  This does
-   * does not consult the security handler.
+   * Set the prototype object (same as calling Object.setPrototypeOf(..)).
+   * This does not consult the security handler.
    * TODO(333672197): rename back to SetPrototype() once the old version goes
    * through the deprecation process and is removed.
    */
@@ -544,10 +554,43 @@ class V8_EXPORT Object : public Value {
    * a field, GetAlignedPointerFromInternalField must be used, everything else
    * leads to undefined behavior.
    */
+  V8_DEPRECATE_SOON(
+      "Use SetAlignedPointerInInternalField with EmbedderDataTypeTag parameter "
+      "instead.")
   void SetAlignedPointerInInternalField(int index, void* value);
+
+  void SetAlignedPointerInInternalField(int index, void* value,
+                                        EmbedderDataTypeTag tag);
+
+  V8_DEPRECATE_SOON(
+      "Use SetAlignedPointerInInternalField with EmbedderDataTypeTag "
+      "parameter instead.")
   void SetAlignedPointerInInternalFields(int argc, int indices[],
                                          void* values[]);
 
+  // Type information for a Wrappable object that got wrapped with
+  // `v8::Object::Wrap()`.
+  struct WrapperTypeInfo {
+    const int16_t type_id;
+  };
+
+  // v8::Object::Wrappable serves as the base class for all C++ objects that can
+  // be wrapped by a JavaScript object using `v8::Object::Wrap()`.
+  //
+  // Note that v8::Object::Wrappable` inherits from `NameProvider` and provides
+  // `GetWrapperTypeInfo` to allow subclasses to have smaller object sizes.
+  class Wrappable : public cppgc::GarbageCollected<Wrappable>,
+                    public cppgc::NameProvider {
+   public:
+    virtual const WrapperTypeInfo* GetWrapperTypeInfo() const {
+      return nullptr;
+    }
+
+    const char* GetHumanReadableName() const override { return "internal"; }
+
+    virtual void Trace(cppgc::Visitor* visitor) const {}
+  };
+
   /**
    * Unwraps a JS wrapper object.
    *
@@ -593,24 +636,37 @@ class V8_EXPORT Object : public Value {
   template <CppHeapPointerTag tag>
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const v8::Local<v8::Object>& wrapper,
-                             void* wrappable);
+                             Wrappable* wrappable);
   template <CppHeapPointerTag tag>
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const PersistentBase<Object>& wrapper,
-                             void* wrappable);
+                             Wrappable* wrappable);
   template <CppHeapPointerTag tag>
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const BasicTracedReference<Object>& wrapper,
-                             void* wrappable);
+                             Wrappable* wrappable);
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const v8::Local<v8::Object>& wrapper,
-                             void* wrappable, CppHeapPointerTag tag);
+                             Wrappable* wrappable, CppHeapPointerTag tag);
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const PersistentBase<Object>& wrapper,
-                             void* wrappable, CppHeapPointerTag tag);
+                             Wrappable* wrappable, CppHeapPointerTag tag);
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const BasicTracedReference<Object>& wrapper,
-                             void* wrappable, CppHeapPointerTag tag);
+                             Wrappable* wrappable, CppHeapPointerTag tag);
+
+  // Version of Wrap() function for v8::Context::Global() objects.
+  // Unlike the functions above it wraps both JSGlobalProxy and its hidden
+  // prototype (JSGlobalObject or remote object).
+  static void WrapGlobal(v8::Isolate* isolate,
+                         const v8::Local<v8::Object>& wrapper,
+                         Wrappable* wrappable, CppHeapPointerTag tag);
+
+  // Checks that wrappables set on JSGlobalProxy and its hidden prototype are
+  // the same.
+  static bool CheckGlobalWrappable(v8::Isolate* isolate,
+                                   const v8::Local<v8::Object>& wrapper,
+                                   CppHeapPointerTagRange tag_range);
 
   /**
    * HasOwnProperty() is like JavaScript's
@@ -795,8 +851,14 @@ class V8_EXPORT Object : public Value {
   /**
    * Return the isolate to which the Object belongs to.
    */
+  V8_DEPRECATED(
+      "Use Isolate::GetCurrent() instead, which is guaranteed to return the "
+      "same isolate since https://crrev.com/c/6458560.")
   Isolate* GetIsolate();
 
+  V8_DEPRECATED(
+      "Use Isolate::GetCurrent() instead, which is guaranteed to return the "
+      "same isolate since https://crrev.com/c/6458560.")
   V8_INLINE static Isolate* GetIsolate(const TracedReference<Object>& handle) {
     return handle.template value<Object>()->GetIsolate();
   }
@@ -871,8 +933,7 @@ Local<Data> Object::GetInternalField(int index) {
     value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value));
 #endif
 
-    auto isolate = reinterpret_cast<v8::Isolate*>(
-        internal::IsolateFromNeverReadOnlySpaceObject(obj));
+    auto* isolate = I::GetCurrentIsolate();
     return Local<Data>::New(isolate, value);
   }
 #endif
@@ -893,7 +954,8 @@ void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate,
                  (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
     A value =
-        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+        I::ReadExternalPointerField<{internal::kFirstEmbedderDataTag,
+                                     internal::kLastEmbedderDataTag}>(
             isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
@@ -913,9 +975,10 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
     int offset = I::kJSAPIObjectWithEmbedderSlotsHeaderSize +
                  (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
-    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    Isolate* isolate = I::GetCurrentIsolateForSandbox();
     A value =
-        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+        I::ReadExternalPointerField<{internal::kFirstEmbedderDataTag,
+                                     internal::kLastEmbedderDataTag}>(
             isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
@@ -1011,7 +1074,7 @@ T* Object::Unwrap(v8::Isolate* isolate,
 // static
 template <CppHeapPointerTag tag>
 void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
-                  void* wrappable) {
+                  v8::Object::Wrappable* wrappable) {
   auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
   Wrap(isolate, obj, tag, wrappable);
 }
@@ -1019,7 +1082,7 @@ void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
 // static
 template <CppHeapPointerTag tag>
 void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
-                  void* wrappable) {
+                  v8::Object::Wrappable* wrappable) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);
@@ -1029,7 +1092,7 @@ void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
 template <CppHeapPointerTag tag>
 void Object::Wrap(v8::Isolate* isolate,
                   const BasicTracedReference<Object>& wrapper,
-                  void* wrappable) {
+                  v8::Object::Wrappable* wrappable) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);
@@ -1037,14 +1100,14 @@ void Object::Wrap(v8::Isolate* isolate,
 
 // static
 void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
-                  void* wrappable, CppHeapPointerTag tag) {
+                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
   auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
   Wrap(isolate, obj, tag, wrappable);
 }
 
 // static
 void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
-                  void* wrappable, CppHeapPointerTag tag) {
+                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);
@@ -1052,8 +1115,8 @@ void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
 
 // static
 void Object::Wrap(v8::Isolate* isolate,
-                  const BasicTracedReference<Object>& wrapper, void* wrappable,
-                  CppHeapPointerTag tag) {
+                  const BasicTracedReference<Object>& wrapper,
+                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);

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

@@ -431,7 +431,7 @@ internal::Address* PersistentBase<T>::New(Isolate* isolate, T* that) {
 template <class T, class M>
 template <class S, class M2>
 void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   this->Reset();
   if (that.IsEmpty()) return;
   this->slot() = api_internal::CopyGlobalReference(that.slot());
@@ -459,7 +459,7 @@ void PersistentBase<T>::Reset() {
 template <class T>
 template <class S>
 void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   Reset();
   if (other.IsEmpty()) return;
   this->slot() = New(isolate, *other);
@@ -473,7 +473,7 @@ template <class T>
 template <class S>
 void PersistentBase<T>::Reset(Isolate* isolate,
                               const PersistentBase<S>& other) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   Reset();
   if (other.IsEmpty()) return;
   this->slot() = New(isolate, other.template value<S>());
@@ -546,7 +546,7 @@ Global<T>::Global(Global&& other) : PersistentBase<T>(other.slot()) {
 template <class T>
 template <class S>
 Global<T>& Global<T>::operator=(Global<S>&& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   if (this != &rhs) {
     this->Reset();
     if (!rhs.IsEmpty()) {

package/include/node/v8-platform.h

@@ -11,6 +11,7 @@
 #include <stdlib.h>  // For abort.
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "v8-source-location.h"  // NOLINT(build/include_directory)
@@ -80,7 +81,7 @@ class TaskRunner {
    * Embedders should override PostTaskImpl instead of this.
    */
   void PostTask(std::unique_ptr<Task> task,
-                const SourceLocation& location = SourceLocation::Current()) {
+                SourceLocation location = SourceLocation::Current()) {
     PostTaskImpl(std::move(task), location);
   }
 
@@ -103,7 +104,7 @@ class TaskRunner {
    */
   void PostNonNestableTask(
       std::unique_ptr<Task> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     PostNonNestableTaskImpl(std::move(task), location);
   }
 
@@ -114,9 +115,8 @@ class TaskRunner {
    *
    * Embedders should override PostDelayedTaskImpl instead of this.
    */
-  void PostDelayedTask(
-      std::unique_ptr<Task> task, double delay_in_seconds,
-      const SourceLocation& location = SourceLocation::Current()) {
+  void PostDelayedTask(std::unique_ptr<Task> task, double delay_in_seconds,
+                       SourceLocation location = SourceLocation::Current()) {
     PostDelayedTaskImpl(std::move(task), delay_in_seconds, location);
   }
 
@@ -140,7 +140,7 @@ class TaskRunner {
    */
   void PostNonNestableDelayedTask(
       std::unique_ptr<Task> task, double delay_in_seconds,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     PostNonNestableDelayedTaskImpl(std::move(task), delay_in_seconds, location);
   }
 
@@ -154,9 +154,8 @@ class TaskRunner {
    *
    * Embedders should override PostIdleTaskImpl instead of this.
    */
-  void PostIdleTask(
-      std::unique_ptr<IdleTask> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+  void PostIdleTask(std::unique_ptr<IdleTask> task,
+                    SourceLocation location = SourceLocation::Current()) {
     PostIdleTaskImpl(std::move(task), location);
   }
 
@@ -499,12 +498,59 @@ class PageAllocator {
     kNoAccessWillJitLater
   };
 
+  /**
+   * Optional hints for AllocatePages().
+   */
+  class AllocationHint final {
+   public:
+    AllocationHint() = default;
+
+    V8_WARN_UNUSED_RESULT constexpr AllocationHint WithAddress(
+        void* address) const {
+      return AllocationHint(address, may_grow_);
+    }
+
+    V8_WARN_UNUSED_RESULT constexpr AllocationHint WithMayGrow() const {
+      return AllocationHint(address_, true);
+    }
+
+    bool MayGrow() const { return may_grow_; }
+    void* Address() const { return address_; }
+
+   private:
+    constexpr AllocationHint(void* address, bool may_grow)
+        : address_(address), may_grow_(may_grow) {}
+
+    void* address_ = nullptr;
+    bool may_grow_ = false;
+  };
+
   /**
    * Allocates memory in range with the given alignment and permission.
    */
   virtual void* AllocatePages(void* address, size_t length, size_t alignment,
                               Permission permissions) = 0;
 
+  /**
+   * Allocates memory in range with the given alignment and permission. In
+   * addition to AllocatePages it allows to pass in allocation hints. The
+   * underlying implementation may not make use of hints.
+   */
+  virtual void* AllocatePages(size_t length, size_t alignment,
+                              Permission permissions, AllocationHint hint) {
+    return AllocatePages(hint.Address(), length, alignment, permissions);
+  }
+
+  /**
+   * Resizes the previously allocated memory at the given address. Returns true
+   * if the allocation could be resized. Returns false if this operation is
+   * either not supported or the object could not be resized in-place.
+   */
+  virtual bool ResizeAllocationAt(void* address, size_t old_length,
+                                  size_t new_length, Permission permissions) {
+    return false;
+  }
+
   /**
    * Frees memory in a range that was allocated by a call to AllocatePages.
    */
@@ -655,14 +701,6 @@ class ThreadIsolatedAllocator {
    * Return the pkey used to implement the thread isolation if Type == kPkey.
    */
   virtual int Pkey() const { return -1; }
-
-  /**
-   * Per-thread permissions can be reset on signal handler entry. Even reading
-   * ThreadIsolated memory will segfault in that case.
-   * Call this function on signal handler entry to ensure that read permissions
-   * are restored.
-   */
-  static void SetDefaultPermissionsForSignalHandler();
 };
 
 // Opaque type representing a handle to a shared memory region.
@@ -948,6 +986,29 @@ class VirtualAddressSpace {
    */
   virtual void FreeSharedPages(Address address, size_t size) = 0;
 
+  /**
+   * Memory protection key support.
+   *
+   * If supported by the hardware and operating system, virtual address spaces
+   * can use memory protection keys in addition to the regular page
+   * permissions. The MemoryProtectionKeyId type identifies a memory protection
+   * key and is used by the related APIs in this class.
+   *
+   * TODO(saelo): consider renaming to just MemoryProtectionKey, but currently
+   * there's a naming conflict with base::MemoryProtectionKey.
+   */
+  using MemoryProtectionKeyId = int;
+
+  /**
+   * The memory protection key used by this space, if any.
+   *
+   * If this space uses a memory protection key, then all memory pages in it
+   * will have this key set. In that case, this API will return that key.
+   *
+   * \returns the memory protection key used by this space or std::nullopt.
+   */
+  virtual std::optional<MemoryProtectionKeyId> ActiveMemoryProtectionKey() = 0;
+
   /**
    * Whether this instance can allocate subspaces or not.
    *
@@ -974,11 +1035,15 @@ class VirtualAddressSpace {
    * \param max_page_permissions The maximum permissions that pages allocated in
    * the subspace can obtain.
    *
+   * \param key Optional memory protection key for the subspace. If used, the
+   * returned subspace will use this key for all its memory pages.
+   *
    * \returns a new subspace or nullptr on failure.
    */
   virtual std::unique_ptr<VirtualAddressSpace> AllocateSubspace(
       Address hint, size_t size, size_t alignment,
-      PagePermissions max_page_permissions) = 0;
+      PagePermissions max_page_permissions,
+      std::optional<MemoryProtectionKeyId> key = std::nullopt) = 0;
 
   //
   // TODO(v8) maybe refactor the methods below before stabilizing the API. For
@@ -1117,9 +1182,8 @@ class Platform {
    * CallOnWorkerThread().
    */
   V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
-  void CallOnWorkerThread(
-      std::unique_ptr<Task> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+  void CallOnWorkerThread(std::unique_ptr<Task> task,
+                          SourceLocation location = SourceLocation::Current()) {
     PostTaskOnWorkerThreadImpl(TaskPriority::kUserVisible, std::move(task),
                                location);
   }
@@ -1133,7 +1197,7 @@ class Platform {
   V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
   void CallBlockingTaskOnWorkerThread(
       std::unique_ptr<Task> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     // Embedders may optionally override this to process these tasks in a high
     // priority pool.
     PostTaskOnWorkerThreadImpl(TaskPriority::kUserBlocking, std::move(task),
@@ -1148,7 +1212,7 @@ class Platform {
   V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
   void CallLowPriorityTaskOnWorkerThread(
       std::unique_ptr<Task> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     // Embedders may optionally override this to process these tasks in a low
     // priority pool.
     PostTaskOnWorkerThreadImpl(TaskPriority::kBestEffort, std::move(task),
@@ -1164,7 +1228,7 @@ class Platform {
   V8_DEPRECATE_SOON("Use PostDelayedTaskOnWorkerThread instead.")
   void CallDelayedOnWorkerThread(
       std::unique_ptr<Task> task, double delay_in_seconds,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     PostDelayedTaskOnWorkerThreadImpl(TaskPriority::kUserVisible,
                                       std::move(task), delay_in_seconds,
                                       location);
@@ -1177,7 +1241,7 @@ class Platform {
    */
   void PostTaskOnWorkerThread(
       TaskPriority priority, std::unique_ptr<Task> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     PostTaskOnWorkerThreadImpl(priority, std::move(task), location);
   }
 
@@ -1190,7 +1254,7 @@ class Platform {
   void PostDelayedTaskOnWorkerThread(
       TaskPriority priority, std::unique_ptr<Task> task,
       double delay_in_seconds,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     PostDelayedTaskOnWorkerThreadImpl(priority, std::move(task),
                                       delay_in_seconds, location);
   }
@@ -1247,7 +1311,7 @@ class Platform {
    */
   std::unique_ptr<JobHandle> PostJob(
       TaskPriority priority, std::unique_ptr<JobTask> job_task,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     auto handle = CreateJob(priority, std::move(job_task), location);
     handle->NotifyConcurrencyIncrease();
     return handle;
@@ -1270,7 +1334,7 @@ class Platform {
    */
   std::unique_ptr<JobHandle> CreateJob(
       TaskPriority priority, std::unique_ptr<JobTask> job_task,
-      const SourceLocation& location = SourceLocation::Current()) {
+      SourceLocation location = SourceLocation::Current()) {
     return CreateJobImpl(priority, std::move(job_task), location);
   }
 

package/include/node/v8-primitive.h

@@ -635,11 +635,10 @@ class V8_EXPORT String : public Name {
   bool StringEquals(Local<String> str) const;
 
   /**
-   * Converts an object to a UTF-8-encoded character array.  Useful if
-   * you want to print the object.  If conversion to a string fails
-   * (e.g. due to an exception in the toString() method of the object)
-   * then the length() method returns 0 and the * operator returns
-   * NULL.
+   * Converts an object to a null-terminated UTF-8-encoded character array.
+   * Useful if you want to print the object.  If conversion to a string fails
+   * (e.g. due to an exception in the toString() method of the object) then the
+   * length() method returns 0 and the * operator returns NULL.
    *
    * WARNING: This will unconditionally copy the contents of the JavaScript
    * string, and should be avoided in situations where performance is a concern.
@@ -647,8 +646,7 @@ class V8_EXPORT String : public Name {
    */
   class V8_EXPORT Utf8Value {
    public:
-    Utf8Value(Isolate* isolate, Local<v8::Value> obj,
-              WriteOptions options = REPLACE_INVALID_UTF8);
+    Utf8Value(Isolate* isolate, Local<v8::Value> obj);
     ~Utf8Value();
     char* operator*() { return str_; }
     const char* operator*() const { return str_; }
@@ -851,6 +849,19 @@ class V8_EXPORT Number : public Numeric {
  public:
   double Value() const;
   static Local<Number> New(Isolate* isolate, double value);
+  template <typename Int>
+    requires(std::is_integral<Int>::value && !std::is_same<Int, bool>::value &&
+             std::is_signed_v<Int> && sizeof(Int) <= sizeof(int32_t))
+  V8_INLINE static Local<Number> New(Isolate* isolate, Int value) {
+    return NewFromInt32(isolate, value);
+  }
+  template <typename UInt>
+    requires(std::is_integral<UInt>::value &&
+             !std::is_same<UInt, bool>::value && std::is_unsigned_v<UInt> &&
+             sizeof(UInt) <= sizeof(uint32_t))
+  V8_INLINE static Local<Number> New(Isolate* isolate, UInt value) {
+    return NewFromUint32(isolate, value);
+  }
   V8_INLINE static Number* Cast(v8::Data* data) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(data);
@@ -860,6 +871,8 @@ class V8_EXPORT Number : public Numeric {
 
  private:
   Number();
+  static Local<Number> NewFromInt32(Isolate* isolate, int32_t value);
+  static Local<Number> NewFromUint32(Isolate* isolate, uint32_t value);
   static void CheckCast(v8::Data* that);
 };
 
@@ -994,7 +1007,7 @@ String::ExternalStringResource* String::GetExternalStringResource() const {
 
   ExternalStringResource* result;
   if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
-    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    Isolate* isolate = I::GetCurrentIsolateForSandbox();
     A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
         isolate, obj, I::kStringResourceOffset);
     result = reinterpret_cast<String::ExternalStringResource*>(value);
@@ -1039,7 +1052,7 @@ String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
   ExternalStringResourceBase* resource;
   if (type == I::kExternalOneByteRepresentationTag ||
       type == I::kExternalTwoByteRepresentationTag) {
-    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    Isolate* isolate = I::GetCurrentIsolateForSandbox();
     A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
         isolate, obj, I::kStringResourceOffset);
     resource = reinterpret_cast<ExternalStringResourceBase*>(value);

package/include/node/v8-profiler.h

@@ -71,6 +71,10 @@ class V8_EXPORT CpuProfileNode {
     /** The 1-based number of the source line where the function originates. */
     int line;
 
+    /** The 1-based number of the source column where the function originates.
+     */
+    int column;
+
     /** The count of samples associated with the source line. */
     unsigned int hit_count;
   };

package/include/node/v8-sandbox.h

@@ -101,6 +101,12 @@ struct CppHeapPointerTagRange {
 constexpr CppHeapPointerTagRange kAnyCppHeapPointer(
     CppHeapPointerTag::kFirstTag, CppHeapPointerTag::kLastTag);
 
+/**
+ * Hardware support for the V8 Sandbox.
+ *
+ * This is an experimental feature that may change or be removed without
+ * further notice. Use at your own risk.
+ */
 class SandboxHardwareSupport {
  public:
   /**
@@ -109,6 +115,16 @@ class SandboxHardwareSupport {
    * hardware permissions to the memory that will be inherited on clone.
    */
   V8_EXPORT static void InitializeBeforeThreadCreation();
+
+  /**
+   * Prepares the current thread for executing sandboxed code.
+   *
+   * This must be called on newly created threads before they execute any
+   * sandboxed code (in particular any JavaScript or WebAssembly code). It
+   * should not be invoked on threads that never execute sandboxed code,
+   * although it is fine to do so from a security point of view.
+   */
+  V8_EXPORT static void PrepareCurrentThreadForHardwareSandboxing();
 };
 
 namespace internal {