libv8-node 20.12.1.0-x86_64-linux-musl → 22.5.1.0-x86_64-linux-musl

data/vendor/v8/include/cppgc/type-traits.h

@@ -128,13 +128,13 @@ struct IsSubclassOfBasicMemberTemplate {
  private:
   template <typename T, typename CheckingPolicy, typename StorageType>
   static std::true_type SubclassCheck(
-      BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy,
-                  StorageType>*);
+      const BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy,
+                        StorageType>*);
   static std::false_type SubclassCheck(...);
 
  public:
-  static constexpr bool value =
-      decltype(SubclassCheck(std::declval<BasicMemberCandidate*>()))::value;
+  static constexpr bool value = decltype(SubclassCheck(
+      std::declval<std::decay_t<BasicMemberCandidate>*>()))::value;
 };
 
 template <typename T,
@@ -180,6 +180,14 @@ constexpr bool IsStrictlyBaseOfV =
     std::is_base_of_v<std::decay_t<B>, std::decay_t<D>> &&
     !IsDecayedSameV<B, D>;
 
+template <typename T>
+constexpr bool IsAnyMemberTypeV = false;
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType>
+constexpr bool IsAnyMemberTypeV<internal::BasicMember<
+    T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy, StorageType>> = true;
+
 }  // namespace internal
 
 /**
@@ -245,6 +253,19 @@ constexpr bool IsWeakV = internal::IsWeak<T>::value;
 template <typename T>
 constexpr bool IsCompleteV = internal::IsComplete<T>::value;
 
+/**
+ * Value is true for member types `Member<T>` and `WeakMember<T>`.
+ */
+template <typename T>
+constexpr bool IsMemberOrWeakMemberTypeV =
+    IsMemberTypeV<T> || IsWeakMemberTypeV<T>;
+
+/**
+ * Value is true for any member type.
+ */
+template <typename T>
+constexpr bool IsAnyMemberTypeV = internal::IsAnyMemberTypeV<std::decay_t<T>>;
+
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_TYPE_TRAITS_H_

data/vendor/v8/include/cppgc/visitor.h

@@ -5,10 +5,13 @@
 #ifndef INCLUDE_CPPGC_VISITOR_H_
 #define INCLUDE_CPPGC_VISITOR_H_
 
+#include <type_traits>
+
 #include "cppgc/custom-space.h"
 #include "cppgc/ephemeron-pair.h"
 #include "cppgc/garbage-collected.h"
 #include "cppgc/internal/logging.h"
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/liveness-broker.h"
 #include "cppgc/member.h"
@@ -113,6 +116,30 @@ class V8_EXPORT Visitor {
   }
 #endif  // defined(CPPGC_POINTER_COMPRESSION)
 
+  template <typename T>
+  void TraceMultiple(const subtle::UncompressedMember<T>* start, size_t len) {
+    static_assert(sizeof(T), "Pointee type must be fully defined.");
+    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
+                  "T must be GarbageCollected or GarbageCollectedMixin type");
+    VisitMultipleUncompressedMember(start, len,
+                                    &TraceTrait<T>::GetTraceDescriptor);
+  }
+
+  template <typename T,
+            std::enable_if_t<!std::is_same_v<
+                Member<T>, subtle::UncompressedMember<T>>>* = nullptr>
+  void TraceMultiple(const Member<T>* start, size_t len) {
+    static_assert(sizeof(T), "Pointee type must be fully defined.");
+    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
+                  "T must be GarbageCollected or GarbageCollectedMixin type");
+#if defined(CPPGC_POINTER_COMPRESSION)
+    static_assert(std::is_same_v<Member<T>, subtle::CompressedMember<T>>,
+                  "Member and CompressedMember must be the same.");
+    VisitMultipleCompressedMember(start, len,
+                                  &TraceTrait<T>::GetTraceDescriptor);
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+  }
+
   /**
    * Trace method for inlined objects that are not allocated themselves but
    * otherwise follow managed heap layout and have a Trace() method.
@@ -131,6 +158,26 @@ class V8_EXPORT Visitor {
     TraceTrait<T>::Trace(this, &object);
   }
 
+  template <typename T>
+  void TraceMultiple(const T* start, size_t len) {
+#if V8_ENABLE_CHECKS
+    // This object is embedded in potentially multiple nested objects. The
+    // outermost object must not be in construction as such objects are (a) not
+    // processed immediately, and (b) only processed conservatively if not
+    // otherwise possible.
+    CheckObjectNotInConstruction(start);
+#endif  // V8_ENABLE_CHECKS
+    for (size_t i = 0; i < len; ++i) {
+      const T* object = &start[i];
+      if constexpr (std::is_polymorphic_v<T>) {
+        // The object's vtable may be uninitialized in which case the object is
+        // not traced.
+        if (*reinterpret_cast<const uintptr_t*>(object) == 0) continue;
+      }
+      TraceTrait<T>::Trace(this, object);
+    }
+  }
+
   /**
    * Registers a weak callback method on the object of type T. See
    * LivenessBroker for an usage example.
@@ -314,6 +361,39 @@ class V8_EXPORT Visitor {
                                   WeakCallback callback, const void* data) {}
   virtual void HandleMovableReference(const void**) {}
 
+  virtual void VisitMultipleUncompressedMember(
+      const void* start, size_t len,
+      TraceDescriptorCallback get_trace_descriptor) {
+    // Default implementation merely delegates to Visit().
+    const char* it = static_cast<const char*>(start);
+    const char* end = it + len * internal::kSizeOfUncompressedMember;
+    for (; it < end; it += internal::kSizeOfUncompressedMember) {
+      const auto* current = reinterpret_cast<const internal::RawPointer*>(it);
+      const void* object = current->LoadAtomic();
+      if (!object) continue;
+
+      Visit(object, get_trace_descriptor(object));
+    }
+  }
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+  virtual void VisitMultipleCompressedMember(
+      const void* start, size_t len,
+      TraceDescriptorCallback get_trace_descriptor) {
+    // Default implementation merely delegates to Visit().
+    const char* it = static_cast<const char*>(start);
+    const char* end = it + len * internal::kSizeofCompressedMember;
+    for (; it < end; it += internal::kSizeofCompressedMember) {
+      const auto* current =
+          reinterpret_cast<const internal::CompressedPointer*>(it);
+      const void* object = current->LoadAtomic();
+      if (!object) continue;
+
+      Visit(object, get_trace_descriptor(object));
+    }
+  }
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
  private:
   template <typename T, void (T::*method)(const LivenessBroker&)>
   static void WeakCallbackMethodDelegate(const LivenessBroker& info,
@@ -326,8 +406,7 @@ class V8_EXPORT Visitor {
   template <typename PointerType>
   static void HandleWeak(const LivenessBroker& info, const void* object) {
     const PointerType* weak = static_cast<const PointerType*>(object);
-    auto* raw_ptr = weak->GetFromGC();
-    if (!info.IsHeapObjectAlive(raw_ptr)) {
+    if (!info.IsHeapObjectAlive(weak->GetFromGC())) {
       weak->ClearFromGC();
     }
   }
@@ -413,8 +492,7 @@ class V8_EXPORT RootVisitor {
   template <typename PointerType>
   static void HandleWeak(const LivenessBroker& info, const void* object) {
     const PointerType* weak = static_cast<const PointerType*>(object);
-    auto* raw_ptr = weak->GetFromGC();
-    if (!info.IsHeapObjectAlive(raw_ptr)) {
+    if (!info.IsHeapObjectAlive(weak->GetFromGC())) {
       weak->ClearFromGC();
     }
   }

data/vendor/v8/include/libplatform/libplatform.h

@@ -23,6 +23,8 @@ enum class MessageLoopBehavior : bool {
   kWaitForWork = true
 };
 
+enum class PriorityMode : bool { kDontApply, kApply };
+
 /**
  * Returns a new instance of the default v8::Platform implementation.
  *
@@ -35,13 +37,17 @@ enum class MessageLoopBehavior : bool {
  * calling v8::platform::RunIdleTasks to process the idle tasks.
  * If |tracing_controller| is nullptr, the default platform will create a
  * v8::platform::TracingController instance and use it.
+ * If |priority_mode| is PriorityMode::kApply, the default platform will use
+ * multiple task queues executed by threads different system-level priorities
+ * (where available) to schedule tasks.
  */
 V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform> NewDefaultPlatform(
     int thread_pool_size = 0,
     IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
     InProcessStackDumping in_process_stack_dumping =
         InProcessStackDumping::kDisabled,
-    std::unique_ptr<v8::TracingController> tracing_controller = {});
+    std::unique_ptr<v8::TracingController> tracing_controller = {},
+    PriorityMode priority_mode = PriorityMode::kDontApply);
 
 /**
  * The same as NewDefaultPlatform but disables the worker thread pool.

data/vendor/v8/include/v8-array-buffer.h

@@ -318,6 +318,12 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
+  /**
+   * More efficient shortcut for
+   * GetBackingStore()->IsResizableByUserJavaScript().
+   */
+  bool IsResizableByUserJavaScript() const;
+
   /**
    * More efficient shortcut for GetBackingStore()->Data(). The returned pointer
    * is valid as long as the ArrayBuffer is alive.

data/vendor/v8/include/v8-callbacks.h

@@ -147,14 +147,18 @@ using JitCodeEventHandler = void (*)(const JitCodeEvent* event);
  * the callback functions, you therefore cannot manipulate objects (set or
  * delete properties for example) since it is possible such operations will
  * result in the allocation of objects.
+ * TODO(v8:12612): Deprecate kGCTypeMinorMarkSweep after updating blink.
  */
 enum GCType {
   kGCTypeScavenge = 1 << 0,
-  kGCTypeMinorMarkCompact = 1 << 1,
+  kGCTypeMinorMarkSweep = 1 << 1,
+  kGCTypeMinorMarkCompact V8_DEPRECATE_SOON(
+      "Use kGCTypeMinorMarkSweep instead of kGCTypeMinorMarkCompact.") =
+      kGCTypeMinorMarkSweep,
   kGCTypeMarkSweepCompact = 1 << 2,
   kGCTypeIncrementalMarking = 1 << 3,
   kGCTypeProcessWeakCallbacks = 1 << 4,
-  kGCTypeAll = kGCTypeScavenge | kGCTypeMinorMarkCompact |
+  kGCTypeAll = kGCTypeScavenge | kGCTypeMinorMarkSweep |
                kGCTypeMarkSweepCompact | kGCTypeIncrementalMarking |
                kGCTypeProcessWeakCallbacks
 };
@@ -323,20 +327,20 @@ using WasmAsyncResolvePromiseCallback = void (*)(
 using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate,
                                                     const char* name);
 
-// --- Callback for checking if WebAssembly Simd is enabled ---
-using WasmSimdEnabledCallback = bool (*)(Local<Context> context);
-
-// --- Callback for checking if WebAssembly exceptions are enabled ---
-using WasmExceptionsEnabledCallback = bool (*)(Local<Context> context);
-
-// --- Callback for checking if WebAssembly GC is enabled ---
-// If the callback returns true, it will also enable Wasm stringrefs.
-using WasmGCEnabledCallback = bool (*)(Local<Context> context);
+// --- Callback for checking if WebAssembly imported strings are enabled ---
+using WasmImportedStringsEnabledCallback = bool (*)(Local<Context> context);
 
 // --- Callback for checking if the SharedArrayBuffer constructor is enabled ---
 using SharedArrayBufferConstructorEnabledCallback =
     bool (*)(Local<Context> context);
 
+// --- Callback for checking if the compile hints magic comments are enabled ---
+using JavaScriptCompileHintsMagicEnabledCallback =
+    bool (*)(Local<Context> context);
+
+// --- Callback for checking if WebAssembly JSPI is enabled ---
+using WasmJSPIEnabledCallback = bool (*)(Local<Context> context);
+
 /**
  * HostImportModuleDynamicallyCallback is called when we
  * require the embedder to load a module. This is used as part of the dynamic
@@ -347,11 +351,11 @@ using SharedArrayBufferConstructorEnabledCallback =
  *
  * The specifier is the name of the module that should be imported.
  *
- * The import_assertions are import assertions for this request in the form:
+ * The import_attributes are import attributes for this request in the form:
  * [key1, value1, key2, value2, ...] where the keys and values are of type
  * v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and
  * returned from ModuleRequest::GetImportAssertions(), this array does not
- * contain the source Locations of the assertions.
+ * contain the source Locations of the attributes.
  *
  * The embedder must compile, instantiate, evaluate the Module, and
  * obtain its namespace object.
@@ -363,15 +367,10 @@ using SharedArrayBufferConstructorEnabledCallback =
  * fails (e.g. due to stack overflow), the embedder must propagate
  * that exception by returning an empty MaybeLocal.
  */
-using HostImportModuleDynamicallyWithImportAssertionsCallback =
-    MaybeLocal<Promise> (*)(Local<Context> context,
-                            Local<ScriptOrModule> referrer,
-                            Local<String> specifier,
-                            Local<FixedArray> import_assertions);
 using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)(
     Local<Context> context, Local<Data> host_defined_options,
     Local<Value> resource_name, Local<String> specifier,
-    Local<FixedArray> import_assertions);
+    Local<FixedArray> import_attributes);
 
 /**
  * Callback for requesting a compile hint for a function from the embedder. The
@@ -419,6 +418,45 @@ using PrepareStackTraceCallback = MaybeLocal<Value> (*)(Local<Context> context,
                                                         Local<Value> error,
                                                         Local<Array> sites);
 
+#if defined(V8_OS_WIN)
+/**
+ * Callback to selectively enable ETW tracing based on the document URL.
+ * Implemented by the embedder, it should never call back into V8.
+ *
+ * Windows allows passing additional data to the ETW EnableCallback:
+ * https://learn.microsoft.com/en-us/windows/win32/api/evntprov/nc-evntprov-penablecallback
+ *
+ * This data can be configured in a WPR (Windows Performance Recorder)
+ * profile, adding a CustomFilter to an EventProvider like the following:
+ *
+ * <EventProvider Id=".." Name="57277741-3638-4A4B-BDBA-0AC6E45DA56C" Level="5">
+ *   <CustomFilter Type="0x80000000" Value="AQABAAAAAAA..." />
+ * </EventProvider>
+ *
+ * Where:
+ * - Name="57277741-3638-4A4B-BDBA-0AC6E45DA56C" is the GUID of the V8
+ *     ETW provider, (see src/libplatform/etw/etw-provider-win.h),
+ * - Type="0x80000000" is EVENT_FILTER_TYPE_SCHEMATIZED,
+ * - Value="AQABAAAAAA..." is a base64-encoded byte array that is
+ *     base64-decoded by Windows and passed to the ETW enable callback in
+ *     the 'PEVENT_FILTER_DESCRIPTOR FilterData' argument; see:
+ * https://learn.microsoft.com/en-us/windows/win32/api/evntprov/ns-evntprov-event_filter_descriptor.
+ *
+ * This array contains a struct EVENT_FILTER_HEADER followed by a
+ * variable length payload, and as payload we pass a string in JSON format,
+ * with a list of regular expressions that should match the document URL
+ * in order to enable ETW tracing:
+ *   {
+ *     "version": "1.0",
+ *     "filtered_urls": [
+ *         "https:\/\/.*\.chromium\.org\/.*", "https://v8.dev/";, "..."
+ *     ]
+ *  }
+ */
+using FilterETWSessionByURLCallback =
+    bool (*)(Local<Context> context, const std::string& etw_filter_payload);
+#endif  // V8_OS_WIN
+
 }  // namespace v8
 
 #endif  // INCLUDE_V8_ISOLATE_CALLBACKS_H_

data/vendor/v8/include/v8-container.h

@@ -8,6 +8,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <functional>
+
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
@@ -43,6 +45,58 @@ class V8_EXPORT Array : public Object {
     return static_cast<Array*>(value);
   }
 
+  /**
+   * Creates a JavaScript array from a provided callback.
+   *
+   * \param context The v8::Context to create the array in.
+   * \param length The length of the array to be created.
+   * \param next_value_callback The callback that is invoked to retrieve
+   *     elements for the array. The embedder can signal that the array
+   *     initialization should be aborted by throwing an exception and returning
+   *     an empty MaybeLocal.
+   * \returns The v8::Array if all elements were constructed successfully and an
+   *     empty MaybeLocal otherwise.
+   */
+  static MaybeLocal<Array> New(
+      Local<Context> context, size_t length,
+      std::function<MaybeLocal<v8::Value>()> next_value_callback);
+
+  enum class CallbackResult {
+    kException,
+    kBreak,
+    kContinue,
+  };
+  using IterationCallback = CallbackResult (*)(uint32_t index,
+                                               Local<Value> element,
+                                               void* data);
+
+  /**
+   * Calls {callback} for every element of this array, passing {callback_data}
+   * as its {data} parameter.
+   * This function will typically be faster than calling {Get()} repeatedly.
+   * As a consequence of being optimized for low overhead, the provided
+   * callback must adhere to the following restrictions:
+   *  - It must not allocate any V8 objects and continue iterating; it may
+   *    allocate (e.g. an error message/object) and then immediately terminate
+   *    the iteration.
+   *  - It must not modify the array being iterated.
+   *  - It must not call back into V8 (unless it can guarantee that such a
+   *    call does not violate the above restrictions, which is difficult).
+   *  - The {Local<Value> element} must not "escape", i.e. must not be assigned
+   *    to any other {Local}. Creating a {Global} from it, or updating a
+   *    v8::TypecheckWitness with it, is safe.
+   * These restrictions may be lifted in the future if use cases arise that
+   * justify a slower but more robust implementation.
+   *
+   * Returns {Nothing} on exception; use a {TryCatch} to catch and handle this
+   * exception.
+   * When the {callback} returns {kException}, iteration is terminated
+   * immediately, returning {Nothing}. By returning {kBreak}, the callback
+   * can request non-exceptional early termination of the iteration.
+   */
+  Maybe<void> Iterate(Local<Context> context, IterationCallback callback,
+                      void* callback_data);
+
  private:
   Array();
   static void CheckCast(Value* obj);

data/vendor/v8/include/v8-context.h

@@ -84,6 +84,29 @@ class V8_EXPORT Context : public Data {
    * created by a previous call to Context::New with the same global
    * template. The state of the global object will be completely reset
    * and only object identify will remain.
+   *
+   * \param internal_fields_deserializer An optional callback used
+   * to deserialize fields set by
+   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects
+   * from the default context snapshot. It should match the
+   * SerializeInternalFieldsCallback() used by
+   * v8::SnapshotCreator::SetDefaultContext() when the default context
+   * snapshot is created. It does not need to be configured if the default
+   * context snapshot contains no wrapper objects with pointer internal
+   * fields, or if no custom startup snapshot is configured
+   * in the v8::CreateParams used to create the isolate.
+   *
+   * \param microtask_queue An optional microtask queue used to manage
+   * the microtasks created in this context. If not set the per-isolate
+   * default microtask queue would be used.
+   *
+   * \param context_data_deserializer An optional callback used
+   * to deserialize embedder data set by
+   * v8::Context::SetAlignedPointerInEmbedderData() in the default
+   * context from the default context snapshot. It does not need to be
+   * configured if the default context snapshot contains no pointer embedder
+   * data, or if no custom startup snapshot is configured in the
+   * v8::CreateParams used to create the isolate.
    */
   static Local<Context> New(
       Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
@@ -91,7 +114,9 @@ class V8_EXPORT Context : public Data {
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
       DeserializeInternalFieldsCallback internal_fields_deserializer =
           DeserializeInternalFieldsCallback(),
-      MicrotaskQueue* microtask_queue = nullptr);
+      MicrotaskQueue* microtask_queue = nullptr,
+      DeserializeContextDataCallback context_data_deserializer =
+          DeserializeContextDataCallback());
 
   /**
    * Create a new context from a (non-default) context snapshot. There
@@ -103,21 +128,37 @@ class V8_EXPORT Context : public Data {
    * \param context_snapshot_index The index of the context snapshot to
    * deserialize from. Use v8::Context::New for the default snapshot.
    *
-   * \param embedder_fields_deserializer Optional callback to deserialize
-   * internal fields. It should match the SerializeInternalFieldCallback used
-   * to serialize.
+   * \param internal_fields_deserializer An optional callback used
+   * to deserialize fields set by
+   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects
+   * from the default context snapshot. It does not need to be
+   * configured if there are no wrapper objects with no internal
+   * pointer fields in the default context snapshot or if no startup
+   * snapshot is configured when the isolate is created.
    *
    * \param extensions See v8::Context::New.
    *
    * \param global_object See v8::Context::New.
+   *
+   * \param internal_fields_deserializer Similar to
+   * internal_fields_deserializer in v8::Context::New but applies to
+   * the context specified by the context_snapshot_index.
+   *
+   * \param microtask_queue  See v8::Context::New.
+   *
+   * \param context_data_deserializer  Similar to
+   * context_data_deserializer in v8::Context::New but applies to
+   * the context specified by the context_snapshot_index.
    */
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
-      DeserializeInternalFieldsCallback embedder_fields_deserializer =
+      DeserializeInternalFieldsCallback internal_fields_deserializer =
           DeserializeInternalFieldsCallback(),
       ExtensionConfiguration* extensions = nullptr,
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
-      MicrotaskQueue* microtask_queue = nullptr);
+      MicrotaskQueue* microtask_queue = nullptr,
+      DeserializeContextDataCallback context_data_deserializer =
+          DeserializeContextDataCallback());
 
   /**
    * Returns an global object that isn't backed by an actual context.
@@ -182,7 +223,7 @@ class V8_EXPORT Context : public Data {
      * parameter. Returns true if the operation completed successfully.
      */
     virtual bool FreezeEmbedderObjectAndGetChildren(
-        Local<Object> obj, std::vector<Local<Object>>& children_out) = 0;
+        Local<Object> obj, LocalVector<Object>& children_out) = 0;
   };
 
   /**
@@ -309,18 +350,6 @@ class V8_EXPORT Context : public Data {
                                                 Local<Context> context);
   void SetAbortScriptExecution(AbortScriptExecutionCallback callback);
 
-  /**
-   * Returns the value that was set or restored by
-   * SetContinuationPreservedEmbedderData(), if any.
-   */
-  Local<Value> GetContinuationPreservedEmbedderData() const;
-
-  /**
-   * Sets a value that will be stored on continuations and reset while the
-   * continuation runs.
-   */
-  void SetContinuationPreservedEmbedderData(Local<Value> context);
-
   /**
    * Set or clear hooks to be invoked for promise lifecycle operations.
    * To clear a hook, set it to an empty v8::Function. Each function will
@@ -395,7 +424,7 @@ Local<Value> Context::GetEmbedderData(int index) {
 #ifndef V8_ENABLE_CHECKS
   using A = internal::Address;
   using I = internal::Internals;
-  A ctx = *reinterpret_cast<const A*>(this);
+  A ctx = internal::ValueHelper::ValueAsAddress(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
   int value_offset =
@@ -407,15 +436,9 @@ Local<Value> Context::GetEmbedderData(int index) {
   value = I::DecompressTaggedField(embedder_data, static_cast<uint32_t>(value));
 #endif
 
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-  return Local<Value>(reinterpret_cast<Value*>(value));
-#else
-  internal::Isolate* isolate = internal::IsolateFromNeverReadOnlySpaceObject(
-      *reinterpret_cast<A*>(this));
-  A* result = HandleScope::CreateHandle(isolate, value);
-  return Local<Value>(reinterpret_cast<Value*>(result));
-#endif
-
+  auto isolate = reinterpret_cast<v8::Isolate*>(
+      internal::IsolateFromNeverReadOnlySpaceObject(ctx));
+  return Local<Value>::New(isolate, value);
 #else
   return SlowGetEmbedderData(index);
 #endif
@@ -442,9 +465,12 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
 
 template <class T>
 MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {
-  T* data = reinterpret_cast<T*>(GetDataFromSnapshotOnce(index));
-  if (data) internal::PerformCastCheck(data);
-  return Local<T>(data);
+  if (auto slot = GetDataFromSnapshotOnce(index); slot) {
+    internal::PerformCastCheck(
+        internal::ValueHelper::SlotAsValue<T, false>(slot));
+    return Local<T>::FromSlot(slot);
+  }
+  return {};
 }
 
 Context* Context::Cast(v8::Data* data) {

data/vendor/v8/include/v8-embedder-heap.h

@@ -9,6 +9,9 @@
 #include "v8config.h"          // NOLINT(build/include_directory)
 
 namespace v8 {
+namespace internal {
+class TracedHandles;
+}  // namespace internal
 
 class Isolate;
 class Value;
@@ -18,8 +21,17 @@ class Value;
  */
 class V8_EXPORT EmbedderRootsHandler {
  public:
+  enum class RootHandling {
+    kQueryEmbedderForNonDroppableReferences,
+    kDontQueryEmbedderForAnyReference,
+  };
+
   virtual ~EmbedderRootsHandler() = default;
 
+  EmbedderRootsHandler() = default;
+  explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling)
+      : default_traced_reference_handling_(default_traced_reference_handling) {}
+
   /**
    * Returns true if the |TracedReference| handle should be considered as root
    * for the currently running non-tracing garbage collection and false
@@ -31,9 +43,9 @@ class V8_EXPORT EmbedderRootsHandler {
    * |TracedReference|.
    *
    * Note that the `handle` is different from the handle that the embedder holds
-   * for retaining the object. The embedder may use |WrapperClassId()| to
-   * distinguish cases where it wants handles to be treated as roots from not
-   * being treated as roots.
+   * for retaining the object.
+   *
+   * The concrete implementations must be thread-safe.
    */
   virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 
@@ -47,6 +59,22 @@ class V8_EXPORT EmbedderRootsHandler {
    * handle via the object or class id.
    */
   virtual void ResetRoot(const v8::TracedReference<v8::Value>& handle) = 0;
+
+  /**
+   * Similar to |ResetRoot()|, but opportunistic. The function is called in
+   * parallel for different handles and as such must be thread-safe. In case,
+   * |false| is returned, |ResetRoot()| will be recalled for the same handle.
+   */
+  virtual bool TryResetRoot(const v8::TracedReference<v8::Value>& handle) {
+    ResetRoot(handle);
+    return true;
+  }
+
+ private:
+  const RootHandling default_traced_reference_handling_ =
+      RootHandling::kQueryEmbedderForNonDroppableReferences;
+
+  friend class internal::TracedHandles;
 };
 
 }  // namespace v8

data/vendor/v8/include/v8-embedder-state-scope.h

@@ -7,12 +7,13 @@
 
 #include <memory>
 
-#include "v8-context.h"       // NOLINT(build/include_directory)
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 
+class Context;
+
 namespace internal {
 class EmbedderState;
 }  // namespace internal