@encharm/cws 4.5.3 → 4.6.0

package/src/headers/26/node_perf.h

@@ -0,0 +1,167 @@
+#ifndef SRC_NODE_PERF_H_
+#define SRC_NODE_PERF_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object-inl.h"
+#include "histogram.h"
+#include "node.h"
+#include "node_internals.h"
+#include "node_perf_common.h"
+
+#include "v8.h"
+#include "uv.h"
+
+#include <string>
+
+namespace node {
+
+class Environment;
+class ExternalReferenceRegistry;
+
+namespace performance {
+
+inline const char* GetPerformanceMilestoneName(
+    PerformanceMilestone milestone) {
+  switch (milestone) {
+#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
+  NODE_PERFORMANCE_MILESTONES(V)
+#undef V
+    default:
+      UNREACHABLE();
+  }
+}
+
+inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
+#define V(name, label)                                                        \
+  if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
+  NODE_PERFORMANCE_MILESTONES(V)
+#undef V
+  return NODE_PERFORMANCE_MILESTONE_INVALID;
+}
+
+inline const char* GetPerformanceEntryTypeName(
+    PerformanceEntryType type) {
+  switch (type) {
+#define V(name, label) case NODE_PERFORMANCE_ENTRY_TYPE_##name: return label;
+  NODE_PERFORMANCE_ENTRY_TYPES(V)
+#undef V
+    default:
+      UNREACHABLE();
+  }
+}
+
+inline PerformanceEntryType ToPerformanceEntryTypeEnum(
+    const char* type) {
+#define V(name, label)                                                        \
+  if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
+  NODE_PERFORMANCE_ENTRY_TYPES(V)
+#undef V
+  return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
+}
+
+enum PerformanceGCKind {
+  NODE_PERFORMANCE_GC_MAJOR = v8::GCType::kGCTypeMarkSweepCompact,
+  NODE_PERFORMANCE_GC_MINOR = v8::GCType::kGCTypeScavenge,
+  NODE_PERFORMANCE_GC_MINOR_MARK_SWEEP = v8::GCType::kGCTypeMinorMarkSweep,
+  NODE_PERFORMANCE_GC_INCREMENTAL = v8::GCType::kGCTypeIncrementalMarking,
+  NODE_PERFORMANCE_GC_WEAKCB = v8::GCType::kGCTypeProcessWeakCallbacks
+};
+
+enum PerformanceGCFlags {
+  NODE_PERFORMANCE_GC_FLAGS_NO =
+    v8::GCCallbackFlags::kNoGCCallbackFlags,
+  NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
+    v8::GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
+  NODE_PERFORMANCE_GC_FLAGS_FORCED =
+    v8::GCCallbackFlags::kGCCallbackFlagForced,
+  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
+    v8::GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
+    v8::GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
+    v8::GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
+  NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
+    v8::GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
+};
+
+template <typename Traits>
+struct PerformanceEntry {
+  using Details = typename Traits::Details;
+  std::string name;
+  double start_time;
+  double duration;
+  Details details;
+
+  PerformanceEntry(
+    const std::string& name_,
+    double start_time_,
+    double duration_,
+    const Details& details_)
+    : name(name_),
+      start_time(start_time_),
+      duration(duration_),
+      details(details_) {}
+
+  static v8::MaybeLocal<v8::Object> GetDetails(
+      Environment* env,
+      const PerformanceEntry<Traits>& entry) {
+    return Traits::GetDetails(env, entry);
+  }
+
+  void Notify(Environment* env) {
+    v8::HandleScope handle_scope(env->isolate());
+    v8::Context::Scope scope(env->context());
+    AliasedUint32Array& observers = env->performance_state()->observers;
+    if (env->performance_entry_callback().IsEmpty() ||
+        !observers[Traits::kType]) {
+      return;
+    }
+
+    v8::Local<v8::Object> detail;
+    if (!Traits::GetDetails(env, *this).ToLocal(&detail)) {
+      // TODO(@jasnell): Handle the error here
+      return;
+    }
+
+    v8::Local<v8::Value> argv[] = {
+        OneByteString(env->isolate(), name),
+        OneByteString(env->isolate(),
+                      GetPerformanceEntryTypeName(Traits::kType)),
+        v8::Number::New(env->isolate(), start_time),
+        v8::Number::New(env->isolate(), duration),
+        detail};
+
+    node::MakeSyncCallback(
+        env->isolate(),
+        env->context()->Global(),
+        env->performance_entry_callback(),
+        arraysize(argv),
+        argv);
+  }
+};
+
+struct GCPerformanceEntryTraits {
+  static constexpr PerformanceEntryType kType =
+      NODE_PERFORMANCE_ENTRY_TYPE_GC;
+  struct Details {
+    PerformanceGCKind kind;
+    PerformanceGCFlags flags;
+
+    Details(PerformanceGCKind kind_, PerformanceGCFlags flags_)
+        : kind(kind_), flags(flags_) {}
+  };
+
+  static v8::MaybeLocal<v8::Object> GetDetails(
+      Environment* env,
+      const PerformanceEntry<GCPerformanceEntryTraits>& entry);
+};
+
+using GCPerformanceEntry = PerformanceEntry<GCPerformanceEntryTraits>;
+
+}  // namespace performance
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PERF_H_

package/src/headers/26/node_perf_common.h

@@ -0,0 +1,103 @@
+#ifndef SRC_NODE_PERF_COMMON_H_
+#define SRC_NODE_PERF_COMMON_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "node.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <string>
+
+namespace node {
+namespace performance {
+
+#define PERFORMANCE_NOW() uv_hrtime()
+
+// These occur before the environment is created. Cache them
+// here and add them to the milestones when the env is init'd.
+extern const uint64_t performance_process_start;
+extern const double performance_process_start_timestamp;
+extern uint64_t performance_v8_start;
+
+#define NODE_PERFORMANCE_MILESTONES(V)                                         \
+  V(TIME_ORIGIN_TIMESTAMP, "timeOriginTimestamp")                              \
+  V(TIME_ORIGIN, "timeOrigin")                                                 \
+  V(ENVIRONMENT, "environment")                                                \
+  V(NODE_START, "nodeStart")                                                   \
+  V(V8_START, "v8Start")                                                       \
+  V(LOOP_START, "loopStart")                                                   \
+  V(LOOP_EXIT, "loopExit")                                                     \
+  V(BOOTSTRAP_COMPLETE, "bootstrapComplete")
+
+#define NODE_PERFORMANCE_ENTRY_TYPES(V)                                        \
+  V(GC, "gc")                                                                  \
+  V(HTTP, "http")                                                              \
+  V(HTTP2, "http2")                                                            \
+  V(NET, "net")                                                                \
+  V(DNS, "dns")                                                                \
+  V(QUIC, "quic")
+
+enum PerformanceMilestone {
+#define V(name, _) NODE_PERFORMANCE_MILESTONE_##name,
+  NODE_PERFORMANCE_MILESTONES(V)
+#undef V
+  NODE_PERFORMANCE_MILESTONE_INVALID
+};
+
+enum PerformanceEntryType {
+#define V(name, _) NODE_PERFORMANCE_ENTRY_TYPE_##name,
+  NODE_PERFORMANCE_ENTRY_TYPES(V)
+#undef V
+  NODE_PERFORMANCE_ENTRY_TYPE_INVALID
+};
+
+class PerformanceState {
+ public:
+  struct SerializeInfo {
+    AliasedBufferIndex root;
+    AliasedBufferIndex milestones;
+    AliasedBufferIndex observers;
+  };
+
+  explicit PerformanceState(v8::Isolate* isolate,
+                            uint64_t time_origin,
+                            double time_origin_timestamp,
+                            const SerializeInfo* info);
+  SerializeInfo Serialize(v8::Local<v8::Context> context,
+                          v8::SnapshotCreator* creator);
+  void Deserialize(v8::Local<v8::Context> context,
+                   uint64_t time_origin,
+                   double time_origin_timestamp);
+  friend std::ostream& operator<<(std::ostream& o, const SerializeInfo& i);
+
+  AliasedUint8Array root;
+  AliasedFloat64Array milestones;
+  AliasedUint32Array observers;
+
+  uint64_t performance_last_gc_start_mark = 0;
+  uint16_t current_gc_type = 0;
+
+  void Mark(enum PerformanceMilestone milestone,
+            uint64_t ts = PERFORMANCE_NOW());
+
+ private:
+  void Initialize(uint64_t time_origin, double time_origin_timestamp);
+  void ResetMilestones();
+  struct performance_state_internal {
+    // doubles first so that they are always sizeof(double)-aligned
+    double milestones[NODE_PERFORMANCE_MILESTONE_INVALID];
+    uint32_t observers[NODE_PERFORMANCE_ENTRY_TYPE_INVALID];
+  };
+};
+
+}  // namespace performance
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PERF_COMMON_H_

package/src/headers/26/node_platform.h

@@ -0,0 +1,290 @@
+#ifndef SRC_NODE_PLATFORM_H_
+#define SRC_NODE_PLATFORM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <concepts>
+#include <functional>
+#include <queue>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "libplatform/libplatform.h"
+#include "node.h"
+#include "node_mutex.h"
+#include "uv.h"
+
+namespace node {
+
+class NodePlatform;
+class IsolateData;
+class PerIsolatePlatformData;
+
+template <typename T>
+concept has_priority = requires(T t) { t.priority; };
+
+template <class T>
+class TaskQueue {
+ public:
+  class Locked {
+   public:
+    void Push(std::unique_ptr<T> task, bool outstanding = false);
+    std::unique_ptr<T> Pop();
+    std::unique_ptr<T> BlockingPop();
+    void NotifyOfOutstandingCompletion();
+    void BlockingDrain();
+    void Stop();
+    // All queued tasks, in the order Pop() would have returned them.
+    std::vector<std::unique_ptr<T>> PopAll();
+
+   private:
+    friend class TaskQueue;
+    explicit Locked(TaskQueue* queue);
+
+    TaskQueue* queue_;
+    Mutex::ScopedLock lock_;
+  };
+
+  TaskQueue();
+  ~TaskQueue() = default;
+
+  Locked Lock() { return Locked(this); }
+
+ private:
+  struct Item {
+    std::unique_ptr<T> task;
+    uint64_t sequence;
+  };
+  // Higher priority first if the entry type has one; posting order otherwise
+  // and among equal priorities (a sequence number breaks the tie).
+  struct ItemCompare {
+    bool operator()(const Item& a, const Item& b) const {
+      if constexpr (has_priority<T>) {
+        if (a.task->priority != b.task->priority) {
+          return a.task->priority < b.task->priority;
+        }
+      }
+      return a.sequence > b.sequence;
+    }
+  };
+  using PriorityQueue =
+      std::priority_queue<Item, std::vector<Item>, ItemCompare>;
+
+  std::unique_ptr<T> PopTask();
+
+  Mutex lock_;
+  ConditionVariable tasks_available_;
+  ConditionVariable outstanding_tasks_drained_;
+  int outstanding_tasks_;
+  bool stopped_;
+  uint64_t next_sequence_ = 0;
+  PriorityQueue task_queue_;
+};
+
+struct TaskQueueEntry {
+  std::unique_ptr<v8::Task> task;
+  v8::TaskPriority priority;
+  TaskQueueEntry(std::unique_ptr<v8::Task> t, v8::TaskPriority p)
+      : task(std::move(t)), priority(p) {}
+  inline bool is_outstanding() const {
+    return priority == v8::TaskPriority::kUserBlocking;
+  }
+};
+
+struct DelayedTask {
+  std::unique_ptr<v8::Task> task;
+  v8::TaskPriority priority;
+  uv_timer_t timer;
+  double timeout;
+  std::shared_ptr<PerIsolatePlatformData> platform_data;
+};
+
+enum class PlatformDebugLogLevel {
+  kNone = 0,
+  kMinimal = 1,
+  kVerbose = 2,
+};
+
+// This acts as the foreground task runner for a given Isolate.
+class PerIsolatePlatformData
+    : public IsolatePlatformDelegate,
+      public v8::TaskRunner,
+      public std::enable_shared_from_this<PerIsolatePlatformData> {
+ public:
+  PerIsolatePlatformData(
+      v8::Isolate* isolate,
+      uv_loop_t* loop,
+      PlatformDebugLogLevel debug_log_level = PlatformDebugLogLevel::kNone);
+  ~PerIsolatePlatformData() override;
+
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() override;
+  bool IdleTasksEnabled() override { return false; }
+
+  // Non-nestable tasks are treated like regular tasks.
+  bool NonNestableTasksEnabled() const override { return true; }
+  bool NonNestableDelayedTasksEnabled() const override { return true; }
+
+  void AddShutdownCallback(void (*callback)(void*), void* data);
+  void Shutdown();
+
+  // Returns true if work was dispatched or executed. New tasks that are
+  // posted during flushing of the queue are postponed until the next
+  // flushing.
+  bool FlushForegroundTasksInternal();
+
+  const uv_loop_t* event_loop() const { return loop_; }
+
+ private:
+  // v8::TaskRunner implementation.
+  void PostTaskImpl(std::unique_ptr<v8::Task> task,
+                    const v8::SourceLocation& location) override;
+  void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task,
+                           double delay_in_seconds,
+                           const v8::SourceLocation& location) override;
+  void PostIdleTaskImpl(std::unique_ptr<v8::IdleTask> task,
+                        const v8::SourceLocation& location) override;
+  void PostNonNestableTaskImpl(std::unique_ptr<v8::Task> task,
+                               const v8::SourceLocation& location) override;
+  void PostNonNestableDelayedTaskImpl(
+      std::unique_ptr<v8::Task> task,
+      double delay_in_seconds,
+      const v8::SourceLocation& location) override;
+
+  void DeleteFromScheduledTasks(DelayedTask* task);
+  void DecreaseHandleCount();
+
+  static void FlushTasks(uv_async_t* handle);
+  void RunForegroundTask(std::unique_ptr<v8::Task> task);
+  static void RunForegroundTask(uv_timer_t* timer);
+
+  uv_async_t* flush_tasks_ = nullptr;
+
+  struct ShutdownCallback {
+    void (*cb)(void*);
+    void* data;
+  };
+  typedef std::vector<ShutdownCallback> ShutdownCbList;
+  ShutdownCbList shutdown_callbacks_;
+  // shared_ptr to self to keep this object alive during shutdown.
+  std::shared_ptr<PerIsolatePlatformData> self_reference_;
+  uint32_t uv_handle_count_ = 1;  // 1 = flush_tasks_
+
+  v8::Isolate* const isolate_;
+  uv_loop_t* const loop_;
+
+  // When acquiring locks for both task queues, lock foreground_tasks_
+  // first then foreground_delayed_tasks_ to avoid deadlocks.
+  TaskQueue<TaskQueueEntry> foreground_tasks_;
+  TaskQueue<DelayedTask> foreground_delayed_tasks_;
+
+  // Use a custom deleter because libuv needs to close the handle first.
+  typedef std::unique_ptr<DelayedTask, void (*)(DelayedTask*)>
+      DelayedTaskPointer;
+  std::vector<DelayedTaskPointer> scheduled_delayed_tasks_;
+  PlatformDebugLogLevel debug_log_level_ = PlatformDebugLogLevel::kNone;
+};
+
+// This acts as the single worker thread task runner for all Isolates.
+class WorkerThreadsTaskRunner {
+ public:
+  explicit WorkerThreadsTaskRunner(int thread_pool_size,
+                                   PlatformDebugLogLevel debug_log_level);
+
+  void PostTask(v8::TaskPriority priority,
+                std::unique_ptr<v8::Task> task,
+                const v8::SourceLocation& location);
+  void PostDelayedTask(v8::TaskPriority priority,
+                       std::unique_ptr<v8::Task> task,
+                       const v8::SourceLocation& location,
+                       double delay_in_seconds);
+
+  void BlockingDrain();
+  void Shutdown();
+
+  int NumberOfWorkerThreads() const;
+
+ private:
+  // A queue shared by all threads. The consumers are the worker threads which
+  // take tasks from it to run in PlatformWorkerThread(). The producers can be
+  // any thread. Both the foreground thread and the worker threads can push
+  // tasks into the queue via v8::Platform::PostTaskOnWorkerThread() which
+  // eventually calls PostTask() on this class. When any thread calls
+  // v8::Platform::PostDelayedTaskOnWorkerThread(), the DelayedTaskScheduler
+  // thread will schedule a timer that pushes the delayed tasks back into this
+  // queue when the timer expires.
+  TaskQueue<TaskQueueEntry> pending_worker_tasks_;
+
+  class DelayedTaskScheduler;
+  std::unique_ptr<DelayedTaskScheduler> delayed_task_scheduler_;
+
+  std::vector<std::unique_ptr<uv_thread_t>> threads_;
+  PlatformDebugLogLevel debug_log_level_ = PlatformDebugLogLevel::kNone;
+};
+
+class NodePlatform : public MultiIsolatePlatform {
+ public:
+  NodePlatform(int thread_pool_size,
+               v8::TracingController* tracing_controller,
+               v8::PageAllocator* page_allocator = nullptr);
+  ~NodePlatform() override;
+
+  void DrainTasks(v8::Isolate* isolate) override;
+  void Shutdown();
+
+  // v8::Platform implementation.
+  int NumberOfWorkerThreads() override;
+  void PostTaskOnWorkerThreadImpl(v8::TaskPriority priority,
+                                  std::unique_ptr<v8::Task> task,
+                                  const v8::SourceLocation& location) override;
+  void PostDelayedTaskOnWorkerThreadImpl(
+      v8::TaskPriority priority,
+      std::unique_ptr<v8::Task> task,
+      double delay_in_seconds,
+      const v8::SourceLocation& location) override;
+  bool IdleTasksEnabled(v8::Isolate* isolate) override;
+  double MonotonicallyIncreasingTime() override;
+  double CurrentClockTimeMillis() override;
+  v8::TracingController* GetTracingController() override;
+  bool FlushForegroundTasks(v8::Isolate* isolate) override;
+  std::unique_ptr<v8::JobHandle> CreateJobImpl(
+      v8::TaskPriority priority,
+      std::unique_ptr<v8::JobTask> job_task,
+      const v8::SourceLocation& location) override;
+
+  void RegisterIsolate(v8::Isolate* isolate, uv_loop_t* loop) override;
+  void RegisterIsolate(v8::Isolate* isolate,
+                       IsolatePlatformDelegate* delegate) override;
+
+  void UnregisterIsolate(v8::Isolate* isolate) override;
+  void AddIsolateFinishedCallback(v8::Isolate* isolate,
+                                  void (*callback)(void*),
+                                  void* data) override;
+
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
+      v8::Isolate* isolate, v8::TaskPriority priority) override;
+
+  Platform::StackTracePrinter GetStackTracePrinter() override;
+  v8::PageAllocator* GetPageAllocator() override;
+
+ private:
+  IsolatePlatformDelegate* ForIsolate(v8::Isolate* isolate);
+  std::shared_ptr<PerIsolatePlatformData> ForNodeIsolate(v8::Isolate* isolate);
+
+  Mutex per_isolate_mutex_;
+  using DelegatePair = std::pair<IsolatePlatformDelegate*,
+                                 std::shared_ptr<PerIsolatePlatformData>>;
+  std::unordered_map<v8::Isolate*, DelegatePair> per_isolate_;
+
+  v8::TracingController* tracing_controller_;
+  v8::PageAllocator* page_allocator_;
+  std::shared_ptr<WorkerThreadsTaskRunner> worker_thread_task_runner_;
+  bool has_shut_down_ = false;
+  PlatformDebugLogLevel debug_log_level_ = PlatformDebugLogLevel::kNone;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PLATFORM_H_

package/src/headers/26/node_process-inl.h

@@ -0,0 +1,26 @@
+#ifndef SRC_NODE_PROCESS_INL_H_
+#define SRC_NODE_PROCESS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_process.h"
+#include "v8.h"
+#include "debug_utils-inl.h"
+
+namespace node {
+
+// Call process.emitWarning(str), fmt is a snprintf() format string
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args) {
+  std::string warning = SPrintF(fmt, std::forward<Args>(args)...);
+
+  return ProcessEmitWarningGeneric(env, warning.c_str());
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PROCESS_INL_H_

package/src/headers/26/node_process.h

@@ -0,0 +1,112 @@
+#ifndef SRC_NODE_PROCESS_H_
+#define SRC_NODE_PROCESS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_debug.h"
+#include "node_snapshotable.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+class IsolateData;
+class MemoryTracker;
+class ExternalReferenceRegistry;
+class Realm;
+
+void CreateEnvProxyTemplate(IsolateData* isolate_data);
+
+// Most of the time, it's best to use `console.error` to write
+// to the process.stderr stream.  However, in some cases, such as
+// when debugging the stream.Writable class or the process.nextTick
+// function, it is useful to bypass JavaScript entirely.
+void RawDebug(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+v8::MaybeLocal<v8::Value> ProcessEmit(Environment* env,
+                                      std::string_view event,
+                                      v8::Local<v8::Value> message);
+
+v8::Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
+                                          std::string_view warning,
+                                          std::string_view type = "",
+                                          std::string_view code = "");
+
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args);
+
+v8::Maybe<void> ProcessEmitWarningSync(Environment* env,
+                                       std::string_view message);
+v8::Maybe<bool> ProcessEmitExperimentalWarning(Environment* env,
+                                               const std::string& warning);
+v8::Maybe<bool> ProcessEmitDeprecationWarning(
+    Environment* env,
+    const std::string& warning,
+    std::string_view deprecation_code);
+
+v8::MaybeLocal<v8::Object> CreateProcessObject(Realm* env);
+void PatchProcessObject(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+namespace process {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex hrtime_buffer;
+  };
+
+  static void AddMethods(v8::Isolate* isolate,
+                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(process_binding_data)
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> object,
+              InternalFieldInfo* info = nullptr);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(BindingData)
+  SET_SELF_SIZE(BindingData)
+
+  static BindingData* FromV8Value(v8::Local<v8::Value> receiver);
+  static void HrtimeImpl(BindingData* receiver);
+
+  static void FastHrtime(v8::Local<v8::Value> receiver) {
+    TRACK_V8_FAST_API_CALL("process.hrtime");
+    HrtimeImpl(FromV8Value(receiver));
+  }
+
+  static void SlowHrtime(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void HrtimeBigIntImpl(BindingData* receiver);
+
+  static void FastHrtimeBigInt(v8::Local<v8::Value> receiver) {
+    TRACK_V8_FAST_API_CALL("process.hrtimeBigInt");
+    HrtimeBigIntImpl(FromV8Value(receiver));
+  }
+
+  static void SlowHrtimeBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void LoadEnvFile(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  // Buffer length in uint32.
+  static constexpr size_t kHrTimeBufferLength = 3;
+  AliasedUint32Array hrtime_buffer_;
+  InternalFieldInfo* internal_field_info_ = nullptr;
+
+  // These need to be static so that we have their addresses available to
+  // register as external references in the snapshot at environment creation
+  // time.
+  static v8::CFunction fast_hrtime_;
+  static v8::CFunction fast_hrtime_bigint_;
+};
+
+}  // namespace process
+}  // namespace node
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_PROCESS_H_