libv8-node 18.13.0.1-arm64-darwin → 19.9.0.0-arm64-darwin

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

@@ -20,6 +20,7 @@ class String;
 namespace internal {
 class ExternalString;
 class ScopedExternalStringLock;
+class StringForwardingTable;
 }  // namespace internal
 
 /**
@@ -269,6 +270,7 @@ class V8_EXPORT String : public Name {
    private:
     friend class internal::ExternalString;
     friend class v8::String;
+    friend class internal::StringForwardingTable;
     friend class internal::ScopedExternalStringLock;
   };
 
@@ -785,10 +787,9 @@ String::ExternalStringResource* String::GetExternalStringResource() const {
 
   ExternalStringResource* result;
   if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value =
-        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset,
-                                    internal::kExternalStringResourceTag);
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
+        isolate, obj, I::kStringResourceOffset);
     result = reinterpret_cast<String::ExternalStringResource*>(value);
   } else {
     result = GetExternalStringResourceSlow();
@@ -809,10 +810,9 @@ String::ExternalStringResourceBase* String::GetExternalStringResourceBase(
   ExternalStringResourceBase* resource;
   if (type == I::kExternalOneByteRepresentationTag ||
       type == I::kExternalTwoByteRepresentationTag) {
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value =
-        I::ReadExternalPointerField(isolate, obj, I::kStringResourceOffset,
-                                    internal::kExternalStringResourceTag);
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
+        isolate, obj, I::kStringResourceOffset);
     resource = reinterpret_cast<ExternalStringResourceBase*>(value);
   } else {
     resource = GetExternalStringResourceBaseSlow(encoding_out);

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

@@ -331,6 +331,9 @@ class V8_EXPORT CpuProfilingOptions {
       unsigned max_samples = kNoSampleLimit, int sampling_interval_us = 0,
       MaybeLocal<Context> filter_context = MaybeLocal<Context>());
 
+  CpuProfilingOptions(CpuProfilingOptions&&) = default;
+  CpuProfilingOptions& operator=(CpuProfilingOptions&&) = default;
+
   CpuProfilingMode mode() const { return mode_; }
   unsigned max_samples() const { return max_samples_; }
   int sampling_interval_us() const { return sampling_interval_us_; }
@@ -344,7 +347,7 @@ class V8_EXPORT CpuProfilingOptions {
   CpuProfilingMode mode_;
   unsigned max_samples_;
   int sampling_interval_us_;
-  CopyablePersistentTraits<Context>::CopyablePersistent filter_context_;
+  Global<Context> filter_context_;
 };
 
 /**
@@ -542,7 +545,9 @@ class V8_EXPORT HeapGraphNode {
     kConsString = 10,    // Concatenated string. A pair of pointers to strings.
     kSlicedString = 11,  // Sliced string. A fragment of another string.
     kSymbol = 12,        // A Symbol (ES6).
-    kBigInt = 13         // BigInt.
+    kBigInt = 13,        // BigInt.
+    kObjectShape = 14,   // Internal data used for tracking the shapes (or
+                         // "hidden classes") of JS objects.
   };
 
   /** Returns node type (see HeapGraphNode::Type). */
@@ -898,6 +903,8 @@ class V8_EXPORT HeapProfiler {
   enum SamplingFlags {
     kSamplingNoFlags = 0,
     kSamplingForceGC = 1 << 0,
+    kSamplingIncludeObjectsCollectedByMajorGC = 1 << 1,
+    kSamplingIncludeObjectsCollectedByMinorGC = 1 << 2,
   };
 
   /**
@@ -975,14 +982,71 @@ class V8_EXPORT HeapProfiler {
     virtual ~ObjectNameResolver() = default;
   };
 
+  enum class HeapSnapshotMode {
+    /**
+     * Heap snapshot for regular developers.
+     */
+    kRegular,
+    /**
+     * Heap snapshot is exposing internals that may be useful for experts.
+     */
+    kExposeInternals,
+  };
+
+  enum class NumericsMode {
+    /**
+     * Numeric values are hidden as they are values of the corresponding
+     * objects.
+     */
+    kHideNumericValues,
+    /**
+     * Numeric values are exposed in artificial fields.
+     */
+    kExposeNumericValues
+  };
+
+  struct HeapSnapshotOptions final {
+    // Manually define default constructor here to be able to use it in
+    // `TakeSnapshot()` below.
+    // NOLINTNEXTLINE
+    HeapSnapshotOptions() {}
+
+    /**
+     * The control used to report intermediate progress to.
+     */
+    ActivityControl* control = nullptr;
+    /**
+     * The resolver used by the snapshot generator to get names for V8 objects.
+     */
+    ObjectNameResolver* global_object_name_resolver = nullptr;
+    /**
+     * Mode for taking the snapshot, see `HeapSnapshotMode`.
+     */
+    HeapSnapshotMode snapshot_mode = HeapSnapshotMode::kRegular;
+    /**
+     * Mode for dealing with numeric values, see `NumericsMode`.
+     */
+    NumericsMode numerics_mode = NumericsMode::kHideNumericValues;
+  };
+
   /**
-   * Takes a heap snapshot and returns it.
+   * Takes a heap snapshot.
+   *
+   * \returns the snapshot.
+   */
+  const HeapSnapshot* TakeHeapSnapshot(
+      const HeapSnapshotOptions& options = HeapSnapshotOptions());
+
+  /**
+   * Takes a heap snapshot. See `HeapSnapshotOptions` for details on the
+   * parameters.
+   *
+   * \returns the snapshot.
    */
   const HeapSnapshot* TakeHeapSnapshot(
-      ActivityControl* control = nullptr,
+      ActivityControl* control,
       ObjectNameResolver* global_object_name_resolver = nullptr,
-      bool treat_global_objects_as_roots = true,
-      bool capture_numeric_value = false);
+      bool hide_internals = true, bool capture_numeric_value = false);
 
   /**
    * Starts tracking of heap objects population statistics. After calling
@@ -1035,10 +1099,8 @@ class V8_EXPORT HeapProfiler {
    * |stack_depth| parameter controls the maximum number of stack frames to be
    * captured on each allocation.
    *
-   * NOTE: This is a proof-of-concept at this point. Right now we only sample
-   * newspace allocations. Support for paged space allocation (e.g. pre-tenured
-   * objects, large objects, code objects, etc.) and native allocations
-   * doesn't exist yet, but is anticipated in the future.
+   * NOTE: Support for native allocations doesn't exist yet, but is anticipated
+   * in the future.
    *
    * Objects allocated before the sampling is started will not be included in
    * the profile.
@@ -1101,18 +1163,18 @@ struct HeapStatsUpdate {
   uint32_t size;  // New value of size field for the interval with this index.
 };
 
-#define CODE_EVENTS_LIST(V) \
-  V(Builtin)                \
-  V(Callback)               \
-  V(Eval)                   \
-  V(Function)               \
-  V(InterpretedFunction)    \
-  V(Handler)                \
-  V(BytecodeHandler)        \
-  V(LazyCompile)            \
-  V(RegExp)                 \
-  V(Script)                 \
-  V(Stub)                   \
+#define CODE_EVENTS_LIST(V)                          \
+  V(Builtin)                                         \
+  V(Callback)                                        \
+  V(Eval)                                            \
+  V(Function)                                        \
+  V(InterpretedFunction)                             \
+  V(Handler)                                         \
+  V(BytecodeHandler)                                 \
+  V(LazyCompile) /* Unused, use kFunction instead */ \
+  V(RegExp)                                          \
+  V(Script)                                          \
+  V(Stub)                                            \
   V(Relocation)
 
 /**

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

@@ -37,9 +37,10 @@ class V8_EXPORT RegExp : public Object {
     kDotAll = 1 << 5,
     kLinear = 1 << 6,
     kHasIndices = 1 << 7,
+    kUnicodeSets = 1 << 8,
   };
 
-  static constexpr int kFlagCount = 8;
+  static constexpr int kFlagCount = 9;
 
   /**
    * Creates a regular expression from the given pattern string and

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

@@ -20,6 +20,7 @@
 namespace v8 {
 
 class Function;
+class Message;
 class Object;
 class PrimitiveArray;
 class Script;
@@ -47,8 +48,6 @@ class V8_EXPORT ScriptOrModule {
    * The options that were passed by the embedder as HostDefinedOptions to
    * the ScriptOrigin.
    */
-  V8_DEPRECATED("Use HostDefinedOptions")
-  Local<PrimitiveArray> GetHostDefinedOptions();
   Local<Data> HostDefinedOptions();
 };
 
@@ -78,7 +77,13 @@ class V8_EXPORT UnboundScript {
    * Returns zero based line number of the code_pos location in the script.
    * -1 will be returned if no information available.
    */
-  int GetLineNumber(int code_pos);
+  int GetLineNumber(int code_pos = 0);
+
+  /**
+   * Returns zero based column number of the code_pos location in the script.
+   * -1 will be returned if no information available.
+   */
+  int GetColumnNumber(int code_pos = 0);
 
   static const int kNoScriptId = 0;
 };
@@ -87,7 +92,15 @@ class V8_EXPORT UnboundScript {
  * A compiled JavaScript module, not yet tied to a Context.
  */
 class V8_EXPORT UnboundModuleScript : public Data {
-  // Only used as a container for code caching.
+ public:
+  /**
+   * Data read from magic sourceURL comments.
+   */
+  Local<Value> GetSourceURL();
+  /**
+   * Data read from magic sourceMappingURL comments.
+   */
+  Local<Value> GetSourceMappingURL();
 };
 
 /**
@@ -286,6 +299,16 @@ class V8_EXPORT Module : public Data {
   V8_WARN_UNUSED_RESULT Maybe<bool> SetSyntheticModuleExport(
       Isolate* isolate, Local<String> export_name, Local<Value> export_value);
 
+  /**
+   * Search the modules requested directly or indirectly by the module for
+   * any top-level await that has not yet resolved. If there is any, the
+   * returned vector contains a tuple of the unresolved module and a message
+   * with the pending top-level await.
+   * An embedder may call this before exiting to improve error messages.
+   */
+  std::vector<std::tuple<Local<Module>, Local<Message>>>
+  GetStalledTopLevelAwaitMessage(Isolate* isolate);
+
   V8_INLINE static Module* Cast(Data* data);
 
  private:
@@ -489,7 +512,7 @@ class V8_EXPORT ScriptCompiler {
   /**
    * A task which the embedder must run on a background thread to
    * consume a V8 code cache. Returned by
-   * ScriptCompiler::StarConsumingCodeCache.
+   * ScriptCompiler::StartConsumingCodeCache.
    */
   class V8_EXPORT ConsumeCodeCacheTask final {
    public:
@@ -497,6 +520,36 @@ class V8_EXPORT ScriptCompiler {
 
     void Run();
 
+    /**
+     * Provides the source text string and origin information to the consumption
+     * task. May be called before, during, or after Run(). This step checks
+     * whether the script matches an existing script in the Isolate's
+     * compilation cache. To check whether such a script was found, call
+     * ShouldMergeWithExistingScript.
+     *
+     * The Isolate provided must be the same one used during
+     * StartConsumingCodeCache and must be currently entered on the thread that
+     * calls this function. The source text and origin provided in this step
+     * must precisely match those used later in the ScriptCompiler::Source that
+     * will contain this ConsumeCodeCacheTask.
+     */
+    void SourceTextAvailable(Isolate* isolate, Local<String> source_text,
+                             const ScriptOrigin& origin);
+
+    /**
+     * Returns whether the embedder should call MergeWithExistingScript. This
+     * function may be called from any thread, any number of times, but its
+     * return value is only meaningful after SourceTextAvailable has completed.
+     */
+    bool ShouldMergeWithExistingScript() const;
+
+    /**
+     * Merges newly deserialized data into an existing script which was found
+     * during SourceTextAvailable. May be called only after Run() has completed.
+     * Can execute on any thread, like Run().
+     */
+    void MergeWithExistingScript();
+
    private:
     friend class ScriptCompiler;
 
@@ -581,7 +634,8 @@ class V8_EXPORT ScriptCompiler {
    */
   static ScriptStreamingTask* StartStreaming(
       Isolate* isolate, StreamedSource* source,
-      ScriptType type = ScriptType::kClassic);
+      ScriptType type = ScriptType::kClassic,
+      CompileOptions options = kNoCompileOptions);
 
   static ConsumeCodeCacheTask* StartConsumingCodeCache(
       Isolate* isolate, std::unique_ptr<CachedData> source);
@@ -650,6 +704,7 @@ class V8_EXPORT ScriptCompiler {
    * It is possible to specify multiple context extensions (obj in the above
    * example).
    */
+  V8_DEPRECATED("Use CompileFunction")
   static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInContext(
       Local<Context> context, Source* source, size_t arguments_count,
       Local<String> arguments[], size_t context_extension_count,
@@ -657,6 +712,7 @@ class V8_EXPORT ScriptCompiler {
       CompileOptions options = kNoCompileOptions,
       NoCacheReason no_cache_reason = kNoCacheNoReason,
       Local<ScriptOrModule>* script_or_module_out = nullptr);
+
   static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunction(
       Local<Context> context, Source* source, size_t arguments_count = 0,
       Local<String> arguments[] = nullptr, size_t context_extension_count = 0,

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

@@ -14,7 +14,6 @@
 
 namespace v8 {
 
-class AccessorSignature;
 class CFunction;
 class FunctionTemplate;
 class ObjectTemplate;
@@ -83,28 +82,7 @@ class V8_EXPORT Template : public Data {
    *   cross-context access.
    * \param attribute The attributes of the property for which an accessor
    *   is added.
-   * \param signature The signature describes valid receivers for the accessor
-   *   and is used to perform implicit instance checks against them. If the
-   *   receiver is incompatible (i.e. is not an instance of the constructor as
-   *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
-   *   thrown and no callback is invoked.
    */
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetNativeDataProperty(
-      Local<String> name, AccessorGetterCallback getter,
-      AccessorSetterCallback setter, Local<Value> data,
-      PropertyAttribute attribute, Local<AccessorSignature> signature,
-      AccessControl settings = DEFAULT,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetNativeDataProperty(
-      Local<Name> name, AccessorNameGetterCallback getter,
-      AccessorNameSetterCallback setter, Local<Value> data,
-      PropertyAttribute attribute, Local<AccessorSignature> signature,
-      AccessControl settings = DEFAULT,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetNativeDataProperty(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
@@ -151,7 +129,8 @@ class V8_EXPORT Template : public Data {
  * Interceptor for get requests on an object.
  *
  * Use `info.GetReturnValue().Set()` to set the return value of the
- * intercepted get request.
+ * intercepted get request. If the property does not exist the callback should
+ * not set the result and must not produce side effects.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -192,9 +171,9 @@ using GenericNamedPropertyGetterCallback =
  * 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()`.
+ * `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.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -217,7 +196,9 @@ using GenericNamedPropertySetterCallback =
  * defineProperty().
  *
  * Use `info.GetReturnValue().Set(value)` to set the property attributes. The
- * value is an integer encoding a `v8::PropertyAttribute`.
+ * 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.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -242,7 +223,8 @@ using GenericNamedPropertyQueryCallback =
  * 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`.
+ * 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.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -274,9 +256,9 @@ using GenericNamedPropertyEnumeratorCallback =
  * 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()`.
+ * `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.
  *
  * \param property The name of the property for which the request was
  * intercepted.
@@ -821,27 +803,7 @@ class V8_EXPORT ObjectTemplate : public Template {
    *   cross-context access.
    * \param attribute The attributes of the property for which an accessor
    *   is added.
-   * \param signature The signature describes valid receivers for the accessor
-   *   and is used to perform implicit instance checks against them. If the
-   *   receiver is incompatible (i.e. is not an instance of the constructor as
-   *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
-   *   thrown and no callback is invoked.
    */
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetAccessor(
-      Local<String> name, AccessorGetterCallback getter,
-      AccessorSetterCallback setter, Local<Value> data, AccessControl settings,
-      PropertyAttribute attribute, Local<AccessorSignature> signature,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
-  V8_DEPRECATED("Do signature check in accessor")
-  void SetAccessor(
-      Local<Name> name, AccessorNameGetterCallback getter,
-      AccessorNameSetterCallback setter, Local<Value> data,
-      AccessControl settings, PropertyAttribute attribute,
-      Local<AccessorSignature> signature,
-      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
-      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
   void SetAccessor(
       Local<String> name, AccessorGetterCallback getter,
       AccessorSetterCallback setter = nullptr,
@@ -1019,24 +981,6 @@ class V8_EXPORT Signature : public Data {
   static void CheckCast(Data* that);
 };
 
-/**
- * An AccessorSignature specifies which receivers are valid parameters
- * to an accessor callback.
- */
-class V8_EXPORT AccessorSignature : public Data {
- public:
-  static Local<AccessorSignature> New(
-      Isolate* isolate,
-      Local<FunctionTemplate> receiver = Local<FunctionTemplate>());
-
-  V8_INLINE static AccessorSignature* Cast(Data* data);
-
- private:
-  AccessorSignature();
-
-  static void CheckCast(Data* that);
-};
-
 // --- Implementation ---
 
 void Template::Set(Isolate* isolate, const char* name, Local<Data> value,
@@ -1067,13 +1011,6 @@ Signature* Signature::Cast(Data* data) {
   return reinterpret_cast<Signature*>(data);
 }
 
-AccessorSignature* AccessorSignature::Cast(Data* data) {
-#ifdef V8_ENABLE_CHECKS
-  CheckCast(data);
-#endif
-  return reinterpret_cast<AccessorSignature*>(data);
-}
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_TEMPLATE_H_

data/vendor/v8/include/v8-unwinder-state.h

@@ -17,10 +17,10 @@ struct CalleeSavedRegisters {
   void* arm_r9;
   void* arm_r10;
 };
-#elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||   \
-    V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC ||    \
-    V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || \
-    V8_TARGET_ARCH_LOONG64
+#elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||     \
+    V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_PPC64 ||     \
+    V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || V8_TARGET_ARCH_LOONG64 || \
+    V8_TARGET_ARCH_RISCV32
 struct CalleeSavedRegisters {};
 #else
 #error Target architecture was not detected as supported by v8

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

@@ -537,7 +537,6 @@ class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
       : GlobalValueMap<K, V, Traits>(isolate) {}
 };
 
-
 class DefaultPersistentValueVectorTraits {
  public:
   typedef std::vector<PersistentContainerValue> Impl;
@@ -562,7 +561,6 @@ class DefaultPersistentValueVectorTraits {
   }
 };
 
-
 /**
  * A vector wrapper that safely stores Global values.
  * C++11 embedders don't need this class, as they can use Global
@@ -573,8 +571,8 @@ class DefaultPersistentValueVectorTraits {
  * PersistentContainerValue, with all conversion into and out of V8
  * handles being transparently handled by this class.
  */
-template<typename V, typename Traits = DefaultPersistentValueVectorTraits>
-class PersistentValueVector {
+template <typename V, typename Traits = DefaultPersistentValueVectorTraits>
+class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
  public:
   explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }
 

data/vendor/v8/include/v8-value-serializer.h

@@ -8,6 +8,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
@@ -26,8 +27,37 @@ class Value;
 
 namespace internal {
 struct ScriptStreamingData;
+class SharedObjectConveyorHandles;
+class ValueDeserializer;
+class ValueSerializer;
 }  // namespace internal
 
+/**
+ * A move-only class for managing the lifetime of shared value conveyors used
+ * by V8 to keep JS shared values alive in transit when serialized.
+ *
+ * This class is not directly constructible and is always passed to a
+ * ValueSerializer::Delegate via ValueSerializer::SetSharedValueConveyor.
+ *
+ * The embedder must not destruct the SharedValueConveyor until the associated
+ * serialized data will no longer be deserialized.
+ */
+class V8_EXPORT SharedValueConveyor final {
+ public:
+  SharedValueConveyor(SharedValueConveyor&&) noexcept;
+  ~SharedValueConveyor();
+
+  SharedValueConveyor& operator=(SharedValueConveyor&&) noexcept;
+
+ private:
+  friend class internal::ValueSerializer;
+  friend class internal::ValueDeserializer;
+
+  explicit SharedValueConveyor(Isolate* isolate);
+
+  std::unique_ptr<internal::SharedObjectConveyorHandles> private_;
+};
+
 /**
  * Value serialization compatible with the HTML structured clone algorithm.
  * The format is backward-compatible (i.e. safe to store to disk).
@@ -69,20 +99,20 @@ class V8_EXPORT ValueSerializer {
         Isolate* isolate, Local<WasmModuleObject> module);
 
     /**
-     * Returns whether shared values are supported. GetSharedValueId is only
-     * called if SupportsSharedValues() returns true.
-     */
-    virtual bool SupportsSharedValues() const;
-
-    /**
-     * Called when the ValueSerializer serializes a value that is shared across
-     * Isolates. The embedder must return an ID for the object. This function
-     * must be idempotent for the same object. When deserializing, the ID will
-     * be passed to ValueDeserializer::Delegate::GetSharedValueFromId as
-     * |shared_value_id|.
+     * Called when the first shared value is serialized. All subsequent shared
+     * values will use the same conveyor.
+     *
+     * The embedder must ensure the lifetime of the conveyor matches the
+     * lifetime of the serialized data.
+     *
+     * If the embedder supports serializing shared values, this method should
+     * return true. Otherwise the embedder should throw an exception and return
+     * false.
+     *
+     * This method is called at most once per serializer.
      */
-    virtual Maybe<uint32_t> GetSharedValueId(Isolate* isolate,
-                                             Local<Value> shared_value);
+    virtual bool AdoptSharedValueConveyor(Isolate* isolate,
+                                          SharedValueConveyor&& conveyor);
 
     /**
      * Allocates memory for the buffer of at least the size provided. The actual
@@ -196,17 +226,10 @@ class V8_EXPORT ValueDeserializer {
         Isolate* isolate, uint32_t clone_id);
 
     /**
-     * Returns whether shared values are supported. GetSharedValueFromId is only
-     * called if SupportsSharedValues() returns true.
-     */
-    virtual bool SupportsSharedValues() const;
-
-    /**
-     * Get a value shared across Isolates given a shared_value_id provided by
-     * ValueSerializer::Delegate::GetSharedValueId.
+     * Get the SharedValueConveyor previously provided by
+     * ValueSerializer::Delegate::AdoptSharedValueConveyor.
      */
-    virtual MaybeLocal<Value> GetSharedValueFromId(Isolate* isolate,
-                                                   uint32_t shared_value_id);
+    virtual const SharedValueConveyor* GetSharedValueConveyor(Isolate* isolate);
   };
 
   ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size);

data/vendor/v8/include/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 10
-#define V8_MINOR_VERSION 2
-#define V8_BUILD_NUMBER 154
-#define V8_PATCH_LEVEL 23
+#define V8_MINOR_VERSION 8
+#define V8_BUILD_NUMBER 168
+#define V8_PATCH_LEVEL 25
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)