node-darwin-x64 25.9.0 → 26.0.0

package/include/node/v8-sandbox.h

@@ -62,41 +62,7 @@ enum class CppHeapPointerTag : uint16_t {
   kLastTag = 0x7fff,
 };
 
-// Convenience struct to represent tag ranges. This is used for type checks
-// against supertypes, which cover a range of types (their subtypes).
-// Both the lower- and the upper bound are inclusive. In other words, this
-// struct represents the range [lower_bound, upper_bound].
-// TODO(saelo): reuse internal::TagRange here.
-struct CppHeapPointerTagRange {
-  constexpr CppHeapPointerTagRange(CppHeapPointerTag lower,
-                                   CppHeapPointerTag upper)
-      : lower_bound(lower), upper_bound(upper) {}
-  CppHeapPointerTag lower_bound;
-  CppHeapPointerTag upper_bound;
-
-  // Check whether the tag of the given CppHeapPointerTable entry is within
-  // this range. This method encodes implementation details of the
-  // CppHeapPointerTable, which is necessary as it is used by
-  // ReadCppHeapPointerField below.
-  // Returns true if the check is successful and the tag of the given entry is
-  // within this range, false otherwise.
-  bool CheckTagOf(uint64_t entry) {
-    // Note: the cast to uint32_t is important here. Otherwise, the uint16_t's
-    // would be promoted to int in the range check below, which would result in
-    // undefined behavior (signed integer undeflow) if the actual value is less
-    // than the lower bound. Then, the compiler would take advantage of the
-    // undefined behavior and turn the range check into a simple
-    // `actual_tag <= last_tag` comparison, which is incorrect.
-    uint32_t actual_tag = static_cast<uint16_t>(entry);
-    // The actual_tag is shifted to the left by one and contains the marking
-    // bit in the LSB. To ignore that during the type check, simply add one to
-    // the (shifted) range.
-    constexpr int kTagShift = internal::kCppHeapPointerTagShift;
-    uint32_t first_tag = static_cast<uint32_t>(lower_bound) << kTagShift;
-    uint32_t last_tag = (static_cast<uint32_t>(upper_bound) << kTagShift) + 1;
-    return actual_tag >= first_tag && actual_tag <= last_tag;
-  }
-};
+using CppHeapPointerTagRange = internal::TagRange<CppHeapPointerTag>;
 
 constexpr CppHeapPointerTagRange kAnyCppHeapPointer(
     CppHeapPointerTag::kFirstTag, CppHeapPointerTag::kLastTag);
@@ -115,16 +81,6 @@ 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 {
@@ -133,7 +89,7 @@ namespace internal {
 V8_INLINE static Address* GetCppHeapPointerTableBase(v8::Isolate* isolate) {
   Address addr = reinterpret_cast<Address>(isolate) +
                  Internals::kIsolateCppHeapPointerTableOffset +
-                 Internals::kExternalPointerTableBasePointerOffset;
+                 Internals::kExternalEntityTableBasePointerOffset;
   return *reinterpret_cast<Address**>(addr);
 }
 #endif  // V8_COMPRESS_POINTERS
@@ -142,9 +98,12 @@ template <typename T>
 V8_INLINE static T* ReadCppHeapPointerField(v8::Isolate* isolate,
                                             Address heap_object_ptr, int offset,
                                             CppHeapPointerTagRange tag_range) {
+  // This is a specialized version of the the CppHeapPointerTable accessors
+  // which (1) allows the code to be inlined into the callers for performance
+  // and (2) is optimized for code size as there are a huge number of callers
+  // from auto-generated bindings code.
+
 #ifdef V8_COMPRESS_POINTERS
-  // See src/sandbox/cppheap-pointer-table-inl.h. Logic duplicated here so
-  // it can be inlined and doesn't require an additional call.
   const CppHeapPointerHandle handle =
       Internals::ReadRawField<CppHeapPointerHandle>(heap_object_ptr, offset);
   const uint32_t index = handle >> kExternalPointerIndexShift;
@@ -153,9 +112,21 @@ V8_INLINE static T* ReadCppHeapPointerField(v8::Isolate* isolate,
       reinterpret_cast<const std::atomic<Address>*>(&table[index]);
   Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed);
 
-  Address pointer = entry;
-  if (V8_LIKELY(tag_range.CheckTagOf(entry))) {
-    pointer = entry >> kCppHeapPointerPayloadShift;
+  // Note: the cast to uint32_t is important here. Otherwise, the uint16_t's
+  // would be promoted to int in the range check below, which would result in
+  // undefined behavior (signed integer underflow) if the actual value is less
+  // than the lower bound. Then, the compiler would take advantage of the
+  // undefined behavior and turn the range check into a simple
+  // `actual_tag <= last_tag` comparison, which is incorrect.
+  uint32_t actual_tag = static_cast<uint16_t>(entry);
+  // The actual_tag is shifted to the left by one and contains the marking
+  // bit in the LSB. To ignore that during the type check, simply add one to
+  // the (shifted) range.
+  constexpr int kTagShift = internal::kCppHeapPointerTagShift;
+  uint32_t first_tag = static_cast<uint32_t>(tag_range.first) << kTagShift;
+  uint32_t last_tag = (static_cast<uint32_t>(tag_range.last) << kTagShift) + 1;
+  if (V8_LIKELY(actual_tag >= first_tag && actual_tag <= last_tag)) {
+    entry = entry >> kCppHeapPointerPayloadShift;
   } else {
     // If the type check failed, we simply return nullptr here. That way:
     //  1. The null handle always results in nullptr being returned here, which
@@ -174,15 +145,25 @@ V8_INLINE static T* ReadCppHeapPointerField(v8::Isolate* isolate,
     //     between returning nullptr or the original entry, since it will
     //     simply compile to a `csel x0, x8, xzr, lo` instead of a
     //     `csel x0, x10, x8, lo` instruction.
-    pointer = 0;
+    //  3. The machine code sequence ends up being pretty short, which is
+    //     important here as this code will be inlined into a lot of functions.
+    entry = 0;
   }
-  return reinterpret_cast<T*>(pointer);
+  return reinterpret_cast<T*>(entry);
 #else   // !V8_COMPRESS_POINTERS
   return reinterpret_cast<T*>(
       Internals::ReadRawField<Address>(heap_object_ptr, offset));
 #endif  // !V8_COMPRESS_POINTERS
 }
 
+// TODO(saelo): temporary workaround needed to introduce range-based type
+// checks for the external pointer table. See comment above
+// ExternalPointerCanBeEmpty(ExternalPointerTagRange) function for details.
+V8_INLINE static constexpr bool ExternalPointerCanBeEmpty(
+    CppHeapPointerTagRange tag_range) {
+  return true;
+}
+
 }  // namespace internal
 }  // namespace v8
 

package/include/node/v8-script.h

@@ -64,7 +64,13 @@ class V8_EXPORT UnboundScript : public Data {
    */
   Local<Script> BindToCurrentContext();
 
+  /*
+   * A unique id.
+   */
+  int ScriptId() const;
+  V8_DEPRECATE_SOON("Use ScriptId")
   int GetId() const;
+
   Local<Value> GetScriptName();
 
   /**
@@ -104,8 +110,17 @@ class V8_EXPORT UnboundModuleScript : public Data {
    * Data read from magic sourceMappingURL comments.
    */
   Local<Value> GetSourceMappingURL();
+
+  /*
+   * A unique id.
+   */
+  int ScriptId() const;
+
+  static const int kNoScriptId = 0;
 };
 
+static_assert(UnboundModuleScript::kNoScriptId == UnboundScript::kNoScriptId);
+
 /**
  * A location in JavaScript source.
  */
@@ -187,6 +202,13 @@ class V8_EXPORT Module : public Data {
     kErrored
   };
 
+  /**
+   * If the module is a Source Text Module, returns the name that was passed
+   * by the embedder as resource_name to the ScriptOrigin. If it's a Synthetic
+   * Module, returns the module_name passed to CreateSyntheticModule().
+   */
+  Local<Value> GetResourceName() const;
+
   /**
    * Returns the module's current status.
    */
@@ -390,6 +412,11 @@ class V8_EXPORT Script : public Data {
    */
   Local<UnboundScript> GetUnboundScript();
 
+  /**
+   * Returns the id of the corresponding context-unbound script.
+   */
+  int ScriptId() const;
+
   /**
    * The name that was passed by the embedder as ResourceName to the
    * ScriptOrigin. This can be either a v8::String or v8::Undefined.

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

@@ -22,7 +22,7 @@ namespace v8 {
 class V8_EXPORT SourceLocation final {
  public:
   /**
-   * Construct source location information corresponding to the location of the
+   * Constructs source location information corresponding to the location of the
    * call site.
    */
   static constexpr SourceLocation Current(
@@ -70,13 +70,14 @@ class V8_EXPORT SourceLocation final {
    *
    * \returns a human-readable string representing source location information.
    */
-  std::string ToString() const {
-    if (loc_.line() == 0) {
-      return {};
-    }
-    return std::string(loc_.function_name()) + "@" + loc_.file_name() + ":" +
-           std::to_string(loc_.line());
-  }
+  std::string ToString() const;
+
+  /**
+   * Checks whether this object is initialized.
+   *
+   * \returns true if this object is initialized, false otherwise.
+   */
+  operator bool() const { return loc_.line() != 0; }
 
  private:
   constexpr explicit SourceLocation(const std::source_location& loc)

package/include/node/v8-statistics.h

@@ -154,6 +154,13 @@ class V8_EXPORT HeapStatistics {
   size_t number_of_native_contexts() { return number_of_native_contexts_; }
   size_t number_of_detached_contexts() { return number_of_detached_contexts_; }
 
+  /**
+   * Returns the total number of bytes allocated since the Isolate was created.
+   * This includes all heap objects allocated in any space (new, old, code,
+   * etc.).
+   */
+  uint64_t total_allocated_bytes() { return total_allocated_bytes_; }
+
   /**
    * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap
    * garbage with a bit pattern.
@@ -175,6 +182,7 @@ class V8_EXPORT HeapStatistics {
   size_t number_of_detached_contexts_;
   size_t total_global_handles_size_;
   size_t used_global_handles_size_;
+  uint64_t total_allocated_bytes_;
 
   friend class V8;
   friend class Isolate;

package/include/node/v8-template.h

@@ -135,11 +135,14 @@ class V8_EXPORT Template : public Data {
 /**
  * Interceptor callbacks use this value to indicate whether the request was
  * intercepted or not.
+ *
+ * The values for constants and type are chosen this way for better
+ * performance.
  */
-enum class Intercepted : uint8_t { kNo = 0, kYes = 1 };
+enum class Intercepted : uint32_t { kNo = 1, kYes = 0 };
 
 /**
- * Interceptor for get requests on an object.
+ * Interceptor for [[Get]] requests on an object.
  *
  * If the interceptor handles the request (i.e. the property should not be
  * looked up beyond the interceptor or in case an exception was thrown) it
@@ -153,8 +156,8 @@ enum class Intercepted : uint8_t { kNo = 0, kYes = 1 };
  * \param property The name of the property for which the request was
  * intercepted.
  * \param info Information about the intercepted request, such as
- * isolate, receiver, return value, or whether running in `'use strict'` mode.
- * See `PropertyCallbackInfo`.
+ * isolate, object holding the property, return value. See
+ * `PropertyCallbackInfo`.
  *
  * \code
  *  Intercepted GetterCallback(
@@ -183,21 +186,20 @@ enum class Intercepted : uint8_t { kNo = 0, kYes = 1 };
  */
 using NamedPropertyGetterCallback = Intercepted (*)(
     Local<Name> property, const PropertyCallbackInfo<Value>& info);
-// This variant will be deprecated soon.
-//
-// 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 V8_DEPRECATE_SOON(
-    "Use NamedPropertyGetterCallback instead") =
-    void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
 /**
- * Interceptor for set requests on an object.
+ * Interceptor for [[Set]] requests on an object.
  *
  * If the interceptor handles the request (i.e. the property should not be
  * looked up beyond the interceptor or in case an exception was thrown) it
- * should return `Intercepted::kYes`.
+ * should
+ *  - use `info.GetReturnValue().Set(false)` to indicate that the operation
+ *    failed,
+ *  - (optionally) upon operation failure and info.ShouldThrowOnError()
+ *    is true (indicating execution in `'use strict'` mode) the callback can
+ *    throw TypeError if the error message needs to include more details than
+ *    a TypeError thrown by V8 in this case,
+ *  - return `Intercepted::kYes`.
  * If the interceptor does not handle the request it must return
  * `Intercepted::kNo` and it must not produce side effects.
  *
@@ -206,31 +208,19 @@ using GenericNamedPropertyGetterCallback V8_DEPRECATE_SOON(
  * \param value The value which the property will have if the request
  * is not intercepted.
  * \param info Information about the intercepted request, such as
- * isolate, receiver, return value, or whether running in `'use strict'` mode.
- * See `PropertyCallbackInfo`.
+ * isolate, object holding the property, return value, or whether running in
+ * `'use strict'` mode. See `PropertyCallbackInfo`.
  *
  * See also `ObjectTemplate::SetHandler.`
  */
 using NamedPropertySetterCallback =
     Intercepted (*)(Local<Name> property, Local<Value> value,
                     const PropertyCallbackInfo<void>& info);
-// This variant will be deprecated soon.
-//
-// Use `info.GetReturnValue()` to indicate whether the request was intercepted
-// or not. If the setter successfully intercepts the request, i.e., if the
-// request should not be further executed, call
-// `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 V8_DEPRECATE_SOON(
-    "Use NamedPropertySetterCallback instead") =
-    void (*)(Local<Name> property, Local<Value> value,
-             const PropertyCallbackInfo<Value>& info);
 
 /**
- * Intercepts all requests that query the attributes of the
- * property, e.g., getOwnPropertyDescriptor(), propertyIsEnumerable(), and
- * defineProperty().
+ * Intercepts all requests that query the attributes of the property,
+ * e.g. [[GetOwnProperty]], [[DefineOwnProperty]], [[Set]] and derived ones
+ * like Object.prototype.propertyIsEnumerable() and similar.
  *
  * If the interceptor handles the request (i.e. the property should not be
  * looked up beyond the interceptor or in case an exception was thrown) it
@@ -255,24 +245,19 @@ using GenericNamedPropertySetterCallback V8_DEPRECATE_SOON(
  */
 using NamedPropertyQueryCallback = Intercepted (*)(
     Local<Name> property, const PropertyCallbackInfo<Integer>& info);
-// This variant will be deprecated soon.
-//
-// Use `info.GetReturnValue().Set(value)` to set the property attributes. The
-// 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 V8_DEPRECATE_SOON(
-    "Use NamedPropertyQueryCallback instead") =
-    void (*)(Local<Name> property, const PropertyCallbackInfo<Integer>& info);
 
 /**
- * Interceptor for delete requests on an object.
+ * Interceptor for [[Delete]] requests on an object.
  *
  * If the interceptor handles the request (i.e. the property should not be
  * looked up beyond the interceptor or in case an exception was thrown) it
  * should
- *  - (optionally) use `info.GetReturnValue().Set()` to set to a Boolean value
- *    indicating whether the property deletion was successful or not,
+ *  - use `info.GetReturnValue().Set(false)` to indicate that the operation
+ *    failed,
+ *  - (optionally) upon operation failure and info.ShouldThrowOnError()
+ *    is true (indicating execution in `'use strict'` mode) the callback can
+ *    throw TypeError if the error message needs to include more details than
+ *    a TypeError thrown by V8 in this case,
  *  - return `Intercepted::kYes`.
  * If the interceptor does not handle the request it must return
  * `Intercepted::kNo` and it must not produce side effects.
@@ -280,28 +265,13 @@ using GenericNamedPropertyQueryCallback V8_DEPRECATE_SOON(
  * \param property The name of the property for which the request was
  * intercepted.
  * \param info Information about the intercepted request, such as
- * isolate, receiver, return value, or whether running in `'use strict'` mode.
- * See `PropertyCallbackInfo`.
- *
- * \note If you need to mimic the behavior of `delete`, i.e., throw in strict
- * mode instead of returning false, use `info.ShouldThrowOnError()` to determine
- * if you are in strict mode.
+ * isolate, object holding the property, return value, or whether running in
+ * `'use strict'` mode. See `PropertyCallbackInfo`.
  *
  * See also `ObjectTemplate::SetHandler.`
  */
 using NamedPropertyDeleterCallback = Intercepted (*)(
     Local<Name> property, const PropertyCallbackInfo<Boolean>& info);
-// This variant will be deprecated soon.
-//
-// Use `info.GetReturnValue()` to indicate whether the request was intercepted
-// or not. If the deleter successfully intercepts the request, i.e., if the
-// request should not be further executed, call
-// `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 V8_DEPRECATE_SOON(
-    "Use NamedPropertyDeleterCallback instead") =
-    void (*)(Local<Name> property, const PropertyCallbackInfo<Boolean>& info);
 
 /**
  * Returns an array containing the names of the properties the named
@@ -311,18 +281,20 @@ using GenericNamedPropertyDeleterCallback V8_DEPRECATE_SOON(
  */
 using NamedPropertyEnumeratorCallback =
     void (*)(const PropertyCallbackInfo<Array>& info);
-// This variant will be deprecated soon.
-// This is just a renaming of the typedef.
-using GenericNamedPropertyEnumeratorCallback V8_DEPRECATE_SOON(
-    "Use NamedPropertyEnumeratorCallback instead") =
-    NamedPropertyEnumeratorCallback;
 
 /**
- * Interceptor for defineProperty requests on an object.
+ * Interceptor for [[DefineOwnProperty]] requests on an object.
  *
  * If the interceptor handles the request (i.e. the property should not be
  * looked up beyond the interceptor or in case an exception was thrown) it
- * should return `Intercepted::kYes`.
+ * should
+ *  - use `info.GetReturnValue().Set(false)` to indicate that the operation
+ *    failed,
+ *  - (optionally) upon operation failure and info.ShouldThrowOnError()
+ *    is true (indicating execution in `'use strict'` mode) the callback can
+ *    throw TypeError if the error message needs to include more details than
+ *    a TypeError thrown by V8 in this case,
+ *  - return `Intercepted::kYes`.
  * If the interceptor does not handle the request it must return
  * `Intercepted::kNo` and it must not produce side effects.
  *
@@ -331,29 +303,17 @@ using GenericNamedPropertyEnumeratorCallback V8_DEPRECATE_SOON(
  * \param desc The property descriptor which is used to define the
  * property if the request is not intercepted.
  * \param info Information about the intercepted request, such as
- * isolate, receiver, return value, or whether running in `'use strict'` mode.
- * See `PropertyCallbackInfo`.
+ * isolate, object holding the property, return value, or whether running in
+ * `'use strict'` mode. See `PropertyCallbackInfo`.
  *
  * See also `ObjectTemplate::SetHandler`.
  */
 using NamedPropertyDefinerCallback =
     Intercepted (*)(Local<Name> property, const PropertyDescriptor& desc,
                     const PropertyCallbackInfo<void>& info);
-// This variant will be deprecated soon.
-//
-// Use `info.GetReturnValue()` to indicate whether the request was intercepted
-// or not. If the definer successfully intercepts the request, i.e., if the
-// request should not be further executed, call
-// `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 V8_DEPRECATE_SOON(
-    "Use NamedPropertyDefinerCallback instead") =
-    void (*)(Local<Name> property, const PropertyDescriptor& desc,
-             const PropertyCallbackInfo<Value>& info);
 
 /**
- * Interceptor for getOwnPropertyDescriptor requests on an object.
+ * Interceptor for [[GetOwnProperty]] requests on an object.
  *
  * If the interceptor handles the request (i.e. the property should not be
  * looked up beyond the interceptor or in case an exception was thrown) it
@@ -371,22 +331,10 @@ using GenericNamedPropertyDefinerCallback V8_DEPRECATE_SOON(
  * isolate, receiver, return value, or whether running in `'use strict'` mode.
  * See `PropertyCallbackInfo`.
  *
- * \note If GetOwnPropertyDescriptor is intercepted, it will
- * always return true, i.e., indicate that the property was found.
- *
  * See also `ObjectTemplate::SetHandler`.
  */
 using NamedPropertyDescriptorCallback = Intercepted (*)(
     Local<Name> property, const PropertyCallbackInfo<Value>& info);
-// This variant will be deprecated soon.
-//
-// Use `info.GetReturnValue().Set()` to set the return value of the
-// 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 V8_DEPRECATE_SOON(
-    "Use NamedPropertyDescriptorCallback instead") =
-    void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
 // TODO(ishell): Rename IndexedPropertyXxxCallbackV2 back to
 // IndexedPropertyXxxCallback once the old IndexedPropertyXxxCallback is
@@ -397,41 +345,24 @@ using GenericNamedPropertyDescriptorCallback V8_DEPRECATE_SOON(
  */
 using IndexedPropertyGetterCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
-// This variant will be deprecated soon.
-using IndexedPropertyGetterCallback V8_DEPRECATE_SOON(
-    "Use IndexedPropertyGetterCallbackV2 instead") =
-    void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::NamedPropertySetterCallback`.
  */
 using IndexedPropertySetterCallbackV2 = Intercepted (*)(
     uint32_t index, Local<Value> value, const PropertyCallbackInfo<void>& info);
-// This variant will be deprecated soon.
-using IndexedPropertySetterCallback V8_DEPRECATE_SOON(
-    "Use IndexedPropertySetterCallbackV2 instead") =
-    void (*)(uint32_t index, Local<Value> value,
-             const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::NamedPropertyQueryCallback`.
  */
 using IndexedPropertyQueryCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info);
-// This variant will be deprecated soon.
-using IndexedPropertyQueryCallback V8_DEPRECATE_SOON(
-    "Use IndexedPropertyQueryCallbackV2 instead") =
-    void (*)(uint32_t index, const PropertyCallbackInfo<Integer>& info);
 
 /**
  * See `v8::NamedPropertyDeleterCallback`.
  */
 using IndexedPropertyDeleterCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info);
-// This variant will be deprecated soon.
-using IndexedPropertyDeleterCallback V8_DEPRECATE_SOON(
-    "Use IndexedPropertyDeleterCallbackV2 instead") =
-    void (*)(uint32_t index, const PropertyCallbackInfo<Boolean>& info);
 
 /**
  * Returns an array containing the indices of the properties the indexed
@@ -448,21 +379,12 @@ using IndexedPropertyEnumeratorCallback =
 using IndexedPropertyDefinerCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyDescriptor& desc,
                     const PropertyCallbackInfo<void>& info);
-// This variant will be deprecated soon.
-using IndexedPropertyDefinerCallback V8_DEPRECATE_SOON(
-    "Use IndexedPropertyDefinerCallbackV2 instead") =
-    void (*)(uint32_t index, const PropertyDescriptor& desc,
-             const PropertyCallbackInfo<Value>& info);
 
 /**
  * See `v8::NamedPropertyDescriptorCallback`.
  */
 using IndexedPropertyDescriptorCallbackV2 =
     Intercepted (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
-// This variant will be deprecated soon.
-using IndexedPropertyDescriptorCallback V8_DEPRECATE_SOON(
-    "Use IndexedPropertyDescriptorCallbackV2 instead") =
-    void (*)(uint32_t index, const PropertyCallbackInfo<Value>& info);
 
 /**
  * Returns true if the given context should be allowed to access the given
@@ -632,7 +554,7 @@ class V8_EXPORT FunctionTemplate : public Template {
    * API call, see the comment above the class declaration.
    */
   void SetCallHandler(
-      FunctionCallback callback, Local<Value> data = Local<Value>(),
+      FunctionCallback callback, Local<Data> data = {},
       SideEffectType side_effect_type = SideEffectType::kHasSideEffect,
       const MemorySpan<const CFunction>& c_function_overloads = {});
 
@@ -1071,7 +993,7 @@ class V8_EXPORT ObjectTemplate : public Template {
 /**
  * A template to create dictionary objects at runtime.
  */
-class V8_EXPORT DictionaryTemplate final {
+class V8_EXPORT DictionaryTemplate final : public Data {
  public:
   /** Creates a new template. Also declares data properties that can be passed
    * on instantiation of the template. Properties can only be declared on

package/include/node/v8-version.h

@@ -9,9 +9,9 @@
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
 #define V8_MAJOR_VERSION 14
-#define V8_MINOR_VERSION 1
-#define V8_BUILD_NUMBER 146
-#define V8_PATCH_LEVEL 11
+#define V8_MINOR_VERSION 6
+#define V8_BUILD_NUMBER 202
+#define V8_PATCH_LEVEL 33
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)