libv8-node 22.7.0.4-arm64-darwin → 24.1.0.0-arm64-darwin

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

@@ -32,62 +32,15 @@ class CppHeap;
 
 class CustomSpaceStatisticsReceiver;
 
-/**
- * Describes how V8 wrapper objects maintain references to garbage-collected C++
- * objects.
- */
-struct WrapperDescriptor final {
-  /**
-   * The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and
-   * related APIs to add additional data to an object which is used to identify
-   * JS->C++ references.
-   */
-  using InternalFieldIndex = int;
-
-  /**
-   * Unknown embedder id. The value is reserved for internal usages and must not
-   * be used with `CppHeap`.
-   */
-  static constexpr uint16_t kUnknownEmbedderId = UINT16_MAX;
-
-  constexpr WrapperDescriptor(InternalFieldIndex wrappable_type_index,
-                              InternalFieldIndex wrappable_instance_index,
-                              uint16_t embedder_id_for_garbage_collected)
-      : wrappable_type_index(wrappable_type_index),
-        wrappable_instance_index(wrappable_instance_index),
-        embedder_id_for_garbage_collected(embedder_id_for_garbage_collected) {}
-
-  /**
-   * Index of the wrappable type.
-   */
-  InternalFieldIndex wrappable_type_index;
-
-  /**
-   * Index of the wrappable instance.
-   */
-  InternalFieldIndex wrappable_instance_index;
-
-  /**
-   * Embedder id identifying instances of garbage-collected objects. It is
-   * expected that the first field of the wrappable type is a uint16_t holding
-   * the id. Only references to instances of wrappables types with an id of
-   * `embedder_id_for_garbage_collected` will be considered by CppHeap.
-   */
-  uint16_t embedder_id_for_garbage_collected;
-};
-
 struct V8_EXPORT CppHeapCreateParams {
-  CppHeapCreateParams(
-      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,
-      WrapperDescriptor wrapper_descriptor)
-      : custom_spaces(std::move(custom_spaces)),
-        wrapper_descriptor(wrapper_descriptor) {}
+  explicit CppHeapCreateParams(
+      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces)
+      : custom_spaces(std::move(custom_spaces)) {}
 
   CppHeapCreateParams(const CppHeapCreateParams&) = delete;
   CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;
 
   std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
-  WrapperDescriptor wrapper_descriptor;
   /**
    * Specifies which kind of marking are supported by the heap. The type may be
    * further reduced via runtime flags when attaching the heap to an Isolate.
@@ -134,6 +87,7 @@ class V8_EXPORT CppHeap {
    *
    * After this call, object allocation is prohibited.
    */
+  V8_DEPRECATED("Terminate gets automatically called in the CppHeap destructor")
   void Terminate();
 
   /**
@@ -148,7 +102,7 @@ class V8_EXPORT CppHeap {
   /**
    * Collects statistics for the given spaces and reports them to the receiver.
    *
-   * \param custom_spaces a collection of custom space indicies.
+   * \param custom_spaces a collection of custom space indices.
    * \param receiver an object that gets the results.
    */
   void CollectCustomSpaceStatisticsAtLastGC(
@@ -177,11 +131,6 @@ class V8_EXPORT CppHeap {
   void CollectGarbageInYoungGenerationForTesting(
       cppgc::EmbedderStackState stack_state);
 
-  /**
-   * \returns the wrapper descriptor of this CppHeap.
-   */
-  v8::WrapperDescriptor wrapper_descriptor() const;
-
  private:
   CppHeap() = default;
 

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

@@ -27,6 +27,11 @@ class V8_EXPORT Data {
    */
   bool IsModule() const;
 
+  /**
+   * Returns true if this data is a |v8::ModuleRequest|.
+   */
+  bool IsModuleRequest() const;
+
   /**
    * Returns tru if this data is a |v8::FixedArray|
    */

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

@@ -21,6 +21,10 @@ class V8_EXPORT Date : public Object {
   static V8_WARN_UNUSED_RESULT MaybeLocal<Value> New(Local<Context> context,
                                                      double time);
 
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse(
+      Local<Context> context,
+      Local<String> date_string);
+
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
@@ -32,6 +36,11 @@ class V8_EXPORT Date : public Object {
    */
   v8::Local<v8::String> ToISOString() const;
 
+  /**
+   * Generates UTC string representation.
+   */
+  v8::Local<v8::String> ToUTCString() const;
+
   V8_INLINE static Date* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);

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

@@ -42,6 +42,12 @@ class V8_EXPORT StackFrame {
    */
   int GetColumn() const { return GetLocation().GetColumnNumber() + 1; }
 
+  /**
+   * Returns zero based source position (character offset) for the associated
+   * function.
+   */
+  int GetSourcePosition() const;
+
   /**
    * Returns the id of the script for the function for this StackFrame.
    * This method will return Message::kNoScriptIdInfo if it is unable to
@@ -130,6 +136,11 @@ class V8_EXPORT StackTrace {
     kDetailed = kOverview | kIsEval | kIsConstructor | kScriptNameOrSourceURL
   };
 
+  /**
+   * Returns the (unique) ID of this stack trace.
+   */
+  int GetID() const;
+
   /**
    * Returns a StackFrame at a particular index.
    */

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

@@ -21,33 +21,9 @@ 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
-   * otherwise. The default implementation will keep all |TracedReference|
-   * references as roots.
-   *
-   * If this returns false, then V8 may decide that the object referred to by
-   * such a handle is reclaimed. In that case, V8 calls |ResetRoot()| for the
-   * |TracedReference|.
-   *
-   * Note that the `handle` is different from the handle that the embedder holds
-   * for retaining the object.
-   *
-   * The concrete implementations must be thread-safe.
-   */
-  virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 
   /**
    * Used in combination with |IsRoot|. Called by V8 when an
@@ -66,14 +42,10 @@ class V8_EXPORT EmbedderRootsHandler {
    * |false| is returned, |ResetRoot()| will be recalled for the same handle.
    */
   virtual bool TryResetRoot(const v8::TracedReference<v8::Value>& handle) {
-    ResetRoot(handle);
-    return true;
+    return false;
   }
 
  private:
-  const RootHandling default_traced_reference_handling_ =
-      RootHandling::kQueryEmbedderForNonDroppableReferences;
-
   friend class internal::TracedHandles;
 };
 

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

@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -44,6 +45,8 @@ class V8_EXPORT Exception {
                                     Local<Value> options = {});
   static Local<Value> WasmRuntimeError(Local<String> message,
                                        Local<Value> options = {});
+  static Local<Value> WasmSuspendError(Local<String> message,
+                                       Local<Value> options = {});
   static Local<Value> Error(Local<String> message, Local<Value> options = {});
 
   /**
@@ -58,8 +61,77 @@ class V8_EXPORT Exception {
    * of a given exception, or an empty handle if not available.
    */
   static Local<StackTrace> GetStackTrace(Local<Value> exception);
+
+  /**
+   * Captures the current stack trace and attaches it to the given object in the
+   * form of `stack` property.
+   */
+  static Maybe<bool> CaptureStackTrace(Local<Context> context,
+                                       Local<Object> object);
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+enum class ExceptionContext : uint32_t {
+  kUnknown,
+  kConstructor,
+  kOperation,
+  kAttributeGet,
+  kAttributeSet,
+  kIndexedQuery,
+  kIndexedGetter,
+  kIndexedDescriptor,
+  kIndexedSetter,
+  kIndexedDefiner,
+  kIndexedDeleter,
+  kNamedQuery,
+  kNamedGetter,
+  kNamedDescriptor,
+  kNamedSetter,
+  kNamedDefiner,
+  kNamedDeleter,
+  kNamedEnumerator
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+class ExceptionPropagationMessage {
+ public:
+  ExceptionPropagationMessage(v8::Isolate* isolate, Local<Object> exception,
+                              Local<String> interface_name,
+                              Local<String> property_name,
+                              ExceptionContext exception_context)
+      : isolate_(isolate),
+        exception_(exception),
+        interface_name_(interface_name),
+        property_name_(property_name),
+        exception_context_(exception_context) {}
+
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE Local<Object> GetException() const { return exception_; }
+  V8_INLINE Local<String> GetInterfaceName() const { return interface_name_; }
+  V8_INLINE Local<String> GetPropertyName() const { return property_name_; }
+  V8_INLINE ExceptionContext GetExceptionContext() const {
+    return exception_context_;
+  }
+
+ private:
+  Isolate* isolate_;
+  Local<Object> exception_;
+  Local<String> interface_name_;
+  Local<String> property_name_;
+  ExceptionContext exception_context_;
 };
 
+using ExceptionPropagationCallback =
+    void (*)(ExceptionPropagationMessage message);
+
 /**
  * An external exception handler.
  */

data/vendor/v8/include/v8-external-memory-accounter.h

@@ -0,0 +1,60 @@
+// Copyright 2024 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_
+#define INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_
+
+#include <stdint.h>
+
+#include "v8-isolate.h"
+
+namespace v8 {
+
+/**
+ * This class is used to give V8 an indication of the amount of externally
+ * allocated memory that is kept alive by JavaScript objects. V8 uses this to
+ * decide when to perform garbage collections. Registering externally allocated
+ * memory will trigger garbage collections more often than it would otherwise in
+ * an attempt to garbage collect the JavaScript objects that keep the externally
+ * allocated memory alive. Instances of ExternalMemoryAccounter check that the
+ * reported external memory is back to 0 on destruction.
+ */
+class V8_EXPORT ExternalMemoryAccounter {
+ public:
+  /**
+   * Returns the amount of external memory registered for `isolate`.
+   */
+  static int64_t GetTotalAmountOfExternalAllocatedMemoryForTesting(
+      const Isolate* isolate);
+
+  ExternalMemoryAccounter() = default;
+  ~ExternalMemoryAccounter();
+  ExternalMemoryAccounter(ExternalMemoryAccounter&&);
+  ExternalMemoryAccounter& operator=(ExternalMemoryAccounter&&);
+  ExternalMemoryAccounter(const ExternalMemoryAccounter&) = delete;
+  ExternalMemoryAccounter& operator=(const ExternalMemoryAccounter&) = delete;
+
+  /**
+   * Reports an increase of `size` bytes of external memory.
+   */
+  void Increase(Isolate* isolate, size_t size);
+  /**
+   * Reports an update of `delta` bytes of external memory.
+   */
+  void Update(Isolate* isolate, int64_t delta);
+  /**
+   * Reports an decrease of `size` bytes of external memory.
+   */
+  void Decrease(Isolate* isolate, size_t size);
+
+ private:
+#ifdef V8_ENABLE_MEMORY_ACCOUNTING_CHECKS
+  size_t amount_of_external_memory_ = 0;
+  v8::Isolate* isolate_ = nullptr;
+#endif
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_