node-linux-arm64 24.9.0 → 25.0.0

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 {

package/include/node/v8-source-location.h

@@ -6,21 +6,12 @@
 #define INCLUDE_SOURCE_LOCATION_H_
 
 #include <cstddef>
+#include <source_location>
 #include <string>
 
 #include "v8config.h"  // NOLINT(build/include_directory)
 
-#if defined(__has_builtin)
-#define V8_SUPPORTS_SOURCE_LOCATION                                      \
-  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \
-   __has_builtin(__builtin_LINE))  // NOLINT
-#elif defined(V8_CC_GNU) && __GNUC__ >= 7
 #define V8_SUPPORTS_SOURCE_LOCATION 1
-#elif defined(V8_CC_INTEL) && __ICC >= 1800
-#define V8_SUPPORTS_SOURCE_LOCATION 1
-#else
-#define V8_SUPPORTS_SOURCE_LOCATION 0
-#endif
 
 namespace v8 {
 
@@ -34,15 +25,18 @@ class V8_EXPORT SourceLocation final {
    * Construct source location information corresponding to the location of the
    * call site.
    */
-#if V8_SUPPORTS_SOURCE_LOCATION
   static constexpr SourceLocation Current(
-      const char* function = __builtin_FUNCTION(),
-      const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) {
-    return SourceLocation(function, file, line);
+      const std::source_location& loc = std::source_location::current()) {
+    return SourceLocation(loc);
+  }
+#ifdef DEBUG
+  static constexpr SourceLocation CurrentIfDebug(
+      const std::source_location& loc = std::source_location::current()) {
+    return SourceLocation(loc);
   }
 #else
-  static constexpr SourceLocation Current() { return SourceLocation(); }
-#endif  // V8_SUPPORTS_SOURCE_LOCATION
+  static constexpr SourceLocation CurrentIfDebug() { return {}; }
+#endif
 
   /**
    * Constructs unspecified source location information.
@@ -55,21 +49,21 @@ class V8_EXPORT SourceLocation final {
    *
    * \returns the function name as cstring.
    */
-  constexpr const char* Function() const { return function_; }
+  constexpr const char* Function() const { return loc_.function_name(); }
 
   /**
    * Returns the name of the current source file represented by this object.
    *
    * \returns the file name as cstring.
    */
-  constexpr const char* FileName() const { return file_; }
+  constexpr const char* FileName() const { return loc_.file_name(); }
 
   /**
    * Returns the line number represented by this object.
    *
    * \returns the line number.
    */
-  constexpr size_t Line() const { return line_; }
+  constexpr size_t Line() const { return loc_.line(); }
 
   /**
    * Returns a human-readable string representing this object.
@@ -77,19 +71,18 @@ class V8_EXPORT SourceLocation final {
    * \returns a human-readable string representing source location information.
    */
   std::string ToString() const {
-    if (!file_) {
+    if (loc_.line() == 0) {
       return {};
     }
-    return std::string(function_) + "@" + file_ + ":" + std::to_string(line_);
+    return std::string(loc_.function_name()) + "@" + loc_.file_name() + ":" +
+           std::to_string(loc_.line());
   }
 
  private:
-  constexpr SourceLocation(const char* function, const char* file, size_t line)
-      : function_(function), file_(file), line_(line) {}
+  constexpr explicit SourceLocation(const std::source_location& loc)
+      : loc_(loc) {}
 
-  const char* function_ = nullptr;
-  const char* file_ = nullptr;
-  size_t line_ = 0u;
+  std::source_location loc_;
 };
 
 }  // namespace v8

package/include/node/v8-template.h

@@ -188,7 +188,8 @@ using NamedPropertyGetterCallback = Intercepted (*)(
 // Use `info.GetReturnValue().Set()` to set the return value of the
 // intercepted get request. If the property does not exist the callback should
 // not set the result and must not produce side effects.
-using GenericNamedPropertyGetterCallback =
+using GenericNamedPropertyGetterCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertyGetterCallback instead") =
     void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
 /**
@@ -221,7 +222,8 @@ using NamedPropertySetterCallback =
 // `info.GetReturnValue().Set(value)`. If the setter did not intercept the
 // request, i.e., if the request should be handled as if no interceptor is
 // present, do not not call `Set()` and do not produce side effects.
-using GenericNamedPropertySetterCallback =
+using GenericNamedPropertySetterCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertySetterCallback instead") =
     void (*)(Local<Name> property, Local<Value> value,
              const PropertyCallbackInfo<Value>& info);
 
@@ -259,7 +261,8 @@ using NamedPropertyQueryCallback = Intercepted (*)(
 // value is an integer encoding a `v8::PropertyAttribute`. If the property does
 // not exist the callback should not set the result and must not produce side
 // effects.
-using GenericNamedPropertyQueryCallback =
+using GenericNamedPropertyQueryCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertyQueryCallback instead") =
     void (*)(Local<Name> property, const PropertyCallbackInfo<Integer>& info);
 
 /**
@@ -296,7 +299,8 @@ using NamedPropertyDeleterCallback = Intercepted (*)(
 // `info.GetReturnValue().Set(value)` with a boolean `value`. The `value` is
 // used as the return value of `delete`. If the deleter does not intercept the
 // request then it should not set the result and must not produce side effects.
-using GenericNamedPropertyDeleterCallback =
+using GenericNamedPropertyDeleterCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertyDeleterCallback instead") =
     void (*)(Local<Name> property, const PropertyCallbackInfo<Boolean>& info);
 
 /**
@@ -309,7 +313,9 @@ using NamedPropertyEnumeratorCallback =
     void (*)(const PropertyCallbackInfo<Array>& info);
 // This variant will be deprecated soon.
 // This is just a renaming of the typedef.
-using GenericNamedPropertyEnumeratorCallback = NamedPropertyEnumeratorCallback;
+using GenericNamedPropertyEnumeratorCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertyEnumeratorCallback instead") =
+    NamedPropertyEnumeratorCallback;
 
 /**
  * Interceptor for defineProperty requests on an object.
@@ -341,7 +347,8 @@ using NamedPropertyDefinerCallback =
 // `info.GetReturnValue().Set(value)`. If the definer did not intercept the
 // request, i.e., if the request should be handled as if no interceptor is
 // present, do not not call `Set()` and do not produce side effects.
-using GenericNamedPropertyDefinerCallback =
+using GenericNamedPropertyDefinerCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertyDefinerCallback instead") =
     void (*)(Local<Name> property, const PropertyDescriptor& desc,
              const PropertyCallbackInfo<Value>& info);
 
@@ -377,7 +384,8 @@ using NamedPropertyDescriptorCallback = Intercepted (*)(
 // intercepted request. The return value must be an object that
 // can be converted to a PropertyDescriptor, e.g., a `v8::Value` returned from
 // `v8::Object::getOwnPropertyDescriptor`.
-using GenericNamedPropertyDescriptorCallback =
+using GenericNamedPropertyDescriptorCallback V8_DEPRECATE_SOON(
+    "Use NamedPropertyDescriptorCallback instead") =
     void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
 // TODO(ishell): Rename IndexedPropertyXxxCallbackV2 back to
@@ -390,7 +398,8 @@ using GenericNamedPropertyDescriptorCallback =
 using IndexedPropertyGetterCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 // This variant will be deprecated soon.
-using IndexedPropertyGetterCallback =
+using IndexedPropertyGetterCallback V8_DEPRECATE_SOON(
+    "Use IndexedPropertyGetterCallbackV2 instead") =
     void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 
 /**
@@ -399,7 +408,8 @@ using IndexedPropertyGetterCallback =
 using IndexedPropertySetterCallbackV2 = Intercepted (*)(
     uint32_t index, Local<Value> value, const PropertyCallbackInfo<void>& info);
 // This variant will be deprecated soon.
-using IndexedPropertySetterCallback =
+using IndexedPropertySetterCallback V8_DEPRECATE_SOON(
+    "Use IndexedPropertySetterCallbackV2 instead") =
     void (*)(uint32_t index, Local<Value> value,
              const PropertyCallbackInfo<Value>& info);
 
@@ -409,7 +419,8 @@ using IndexedPropertySetterCallback =
 using IndexedPropertyQueryCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info);
 // This variant will be deprecated soon.
-using IndexedPropertyQueryCallback =
+using IndexedPropertyQueryCallback V8_DEPRECATE_SOON(
+    "Use IndexedPropertyQueryCallbackV2 instead") =
     void (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info);
 
 /**
@@ -418,7 +429,8 @@ using IndexedPropertyQueryCallback =
 using IndexedPropertyDeleterCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info);
 // This variant will be deprecated soon.
-using IndexedPropertyDeleterCallback =
+using IndexedPropertyDeleterCallback V8_DEPRECATE_SOON(
+    "Use IndexedPropertyDeleterCallbackV2 instead") =
     void (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info);
 
 /**
@@ -437,7 +449,8 @@ using IndexedPropertyDefinerCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyDescriptor& desc,
                     const PropertyCallbackInfo<void>& info);
 // This variant will be deprecated soon.
-using IndexedPropertyDefinerCallback =
+using IndexedPropertyDefinerCallback V8_DEPRECATE_SOON(
+    "Use IndexedPropertyDefinerCallbackV2 instead") =
     void (*)(uint32_t index, const PropertyDescriptor& desc,
              const PropertyCallbackInfo<Value>& info);
 
@@ -447,7 +460,8 @@ using IndexedPropertyDefinerCallback =
 using IndexedPropertyDescriptorCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 // This variant will be deprecated soon.
-using IndexedPropertyDescriptorCallback =
+using IndexedPropertyDescriptorCallback V8_DEPRECATE_SOON(
+    "Use IndexedPropertyDescriptorCallbackV2 instead") =
     void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 
 /**
@@ -702,8 +716,8 @@ class V8_EXPORT FunctionTemplate : public Template {
   bool IsLeafTemplateForApiObject(v8::Local<v8::Value> value) const;
 
   /**
-   * Checks if the object can be promoted to read only space, seals it and
-   * prepares for promotion.
+   * Seal the object and mark it for promotion to read only space during
+   * context snapshot creation.
    *
    * This is an experimental feature and may still change significantly.
    */
@@ -1037,6 +1051,14 @@ class V8_EXPORT ObjectTemplate : public Template {
   void SetCodeLike();
   bool IsCodeLike() const;
 
+  /**
+   * Seal the object and mark it for promotion to read only space during
+   * context snapshot creation.
+   *
+   * This is an experimental feature and may still change significantly.
+   */
+  void SealAndPrepareForPromotionToReadOnly();
+
   V8_INLINE static ObjectTemplate* Cast(Data* data);
 
  private:

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

@@ -181,7 +181,7 @@ class TracedReference : public BasicTracedReference<T> {
    */
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    static_assert(std::is_base_of<T, S>::value, "type check");
+    static_assert(std::is_base_of_v<T, S>, "type check");
     if (V8_UNLIKELY(that.IsEmpty())) {
       return;
     }
@@ -202,7 +202,7 @@ class TracedReference : public BasicTracedReference<T> {
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that, IsDroppable)
       : BasicTracedReference<T>() {
-    static_assert(std::is_base_of<T, S>::value, "type check");
+    static_assert(std::is_base_of_v<T, S>, "type check");
     if (V8_UNLIKELY(that.IsEmpty())) {
       return;
     }
@@ -351,7 +351,7 @@ V8_INLINE bool operator!=(const v8::Local<U>& lhs,
 template <class T>
 template <class S>
 void TracedReference<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");
   this->Reset();
   if (V8_UNLIKELY(other.IsEmpty())) {
     return;
@@ -366,7 +366,7 @@ template <class T>
 template <class S>
 void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other,
                                IsDroppable) {
-  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 (V8_UNLIKELY(other.IsEmpty())) {
     return;
@@ -381,7 +381,7 @@ template <class T>
 template <class S>
 TracedReference<T>& TracedReference<T>::operator=(
     TracedReference<S>&& rhs) noexcept {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   *this = std::move(rhs.template As<T>());
   return *this;
 }
@@ -390,7 +390,7 @@ template <class T>
 template <class S>
 TracedReference<T>& TracedReference<T>::operator=(
     const TracedReference<S>& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   *this = rhs.template As<T>();
   return *this;
 }