@encharm/cws 4.5.1 → 4.5.3

package/src/headers/24/node_wasi.h

@@ -0,0 +1,185 @@
+#ifndef SRC_NODE_WASI_H_
+#define SRC_NODE_WASI_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "node_mem.h"
+#include "uvwasi.h"
+#include "v8-fast-api-calls.h"
+
+namespace node {
+namespace wasi {
+
+struct WasmMemory {
+  char* data;
+  size_t size;
+};
+
+class WASI : public BaseObject,
+             public mem::NgLibMemoryManager<WASI, uvwasi_mem_t> {
+ public:
+  WASI(Environment* env,
+       v8::Local<v8::Object> object,
+       uvwasi_options_t* options);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(WASI)
+  SET_SELF_SIZE(WASI)
+
+  static uint32_t ArgsGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t ArgsSizesGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t ClockResGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t ClockTimeGet(WASI&, WasmMemory, uint32_t, uint64_t, uint32_t);
+  static uint32_t EnvironGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t EnvironSizesGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdAdvise(
+      WASI&, WasmMemory, uint32_t, uint64_t, uint64_t, uint32_t);
+  static uint32_t FdAllocate(WASI&, WasmMemory, uint32_t, uint64_t, uint64_t);
+  static uint32_t FdClose(WASI&, WasmMemory, uint32_t);
+  static uint32_t FdDatasync(WASI&, WasmMemory, uint32_t);
+  static uint32_t FdFdstatGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdFdstatSetFlags(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdFdstatSetRights(
+      WASI&, WasmMemory, uint32_t, uint64_t, uint64_t);
+  static uint32_t FdFilestatGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdFilestatSetSize(WASI&, WasmMemory, uint32_t, uint64_t);
+  static uint32_t FdFilestatSetTimes(
+      WASI&, WasmMemory, uint32_t, uint64_t, uint64_t, uint32_t);
+  static uint32_t FdPread(WASI&,
+                          WasmMemory memory,
+                          uint32_t,
+                          uint32_t,
+                          uint32_t,
+                          uint64_t,
+                          uint32_t);
+  static uint32_t FdPrestatGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdPrestatDirName(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t FdPwrite(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint64_t, uint32_t);
+  static uint32_t FdRead(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t FdReaddir(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint64_t, uint32_t);
+  static uint32_t FdRenumber(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdSeek(
+      WASI&, WasmMemory, uint32_t, int64_t, uint32_t, uint32_t);
+  static uint32_t FdSync(WASI&, WasmMemory, uint32_t);
+  static uint32_t FdTell(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t FdWrite(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathCreateDirectory(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathFilestatGet(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathFilestatSetTimes(WASI&,
+                                       WasmMemory,
+                                       uint32_t,
+                                       uint32_t,
+                                       uint32_t,
+                                       uint32_t,
+                                       uint64_t,
+                                       uint64_t,
+                                       uint32_t);
+  static uint32_t PathLink(WASI&,
+                           WasmMemory,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t);
+  static uint32_t PathOpen(WASI&,
+                           WasmMemory,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint64_t,
+                           uint64_t,
+                           uint32_t,
+                           uint32_t);
+  static uint32_t PathReadlink(WASI&,
+                               WasmMemory,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t,
+                               uint32_t);
+  static uint32_t PathRemoveDirectory(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathRename(WASI&,
+                             WasmMemory,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t,
+                             uint32_t);
+  static uint32_t PathSymlink(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t PathUnlinkFile(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t PollOneoff(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t);
+  static void ProcExit(WASI&, WasmMemory, uint32_t);
+  static uint32_t ProcRaise(WASI&, WasmMemory, uint32_t);
+  static uint32_t RandomGet(WASI&, WasmMemory, uint32_t, uint32_t);
+  static uint32_t SchedYield(WASI&, WasmMemory);
+  static uint32_t SockAccept(WASI&, WasmMemory, uint32_t, uint32_t, uint32_t);
+  static uint32_t SockRecv(WASI&,
+                           WasmMemory,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t,
+                           uint32_t);
+  static uint32_t SockSend(
+      WASI&, WasmMemory, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+  static uint32_t SockShutdown(WASI&, WasmMemory, uint32_t, uint32_t);
+
+  static void _SetMemory(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // Implementation for mem::NgLibMemoryManager
+  void CheckAllocatedSize(size_t previous_size) const;
+  void IncreaseAllocatedSize(size_t size);
+  void DecreaseAllocatedSize(size_t size);
+
+  // <typename FT, FT F> as a C++14 desugaring of `<auto F>`
+  template <typename FT, FT F, typename R, typename... Args>
+  class WasiFunction {
+   public:
+    static void SetFunction(Environment*,
+                            const char*,
+                            v8::Local<v8::FunctionTemplate>);
+
+   private:
+    static R FastCallback(v8::Local<v8::Object> unused,
+                          v8::Local<v8::Object> receiver,
+                          Args...,
+                          v8::FastApiCallbackOptions&);
+
+    static void SlowCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+  };
+
+ private:
+  ~WASI() override;
+  uvwasi_t uvw_;
+  v8::Global<v8::WasmMemoryObject> memory_;
+  uvwasi_mem_t alloc_info_;
+  size_t current_uvwasi_memory_ = 0;
+};
+
+
+}  // namespace wasi
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_WASI_H_

package/src/headers/24/node_wasm_web_api.h

@@ -0,0 +1,55 @@
+#ifndef SRC_NODE_WASM_WEB_API_H_
+#define SRC_NODE_WASM_WEB_API_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object-inl.h"
+#include "v8.h"
+
+namespace node {
+namespace wasm_web_api {
+
+// Wrapper for interacting with a v8::WasmStreaming instance from JavaScript.
+class WasmStreamingObject final : public BaseObject {
+ public:
+  static v8::Local<v8::Function> Initialize(Environment* env);
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(WasmStreamingObject)
+  SET_SELF_SIZE(WasmStreamingObject)
+
+  static v8::MaybeLocal<v8::Object> Create(
+      Environment* env, std::shared_ptr<v8::WasmStreaming> streaming);
+
+ private:
+  WasmStreamingObject(Environment* env, v8::Local<v8::Object> object)
+      : BaseObject(env, object) {
+    MakeWeak();
+  }
+
+  ~WasmStreamingObject() override {}
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Push(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Finish(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Abort(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  std::shared_ptr<v8::WasmStreaming> streaming_;
+  size_t wasm_size_ = 0;
+};
+
+// This is a v8::WasmStreamingCallback implementation that must be passed to
+// v8::Isolate::SetWasmStreamingCallback when setting up the isolate in order to
+// enable the WebAssembly.(compile|instantiate)Streaming APIs.
+void StartStreamingCompilation(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+}  // namespace wasm_web_api
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_WASM_WEB_API_H_

package/src/headers/24/node_watchdog.h

@@ -0,0 +1,154 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_NODE_WATCHDOG_H_
+#define SRC_NODE_WATCHDOG_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <vector>
+#include "handle_wrap.h"
+#include "memory_tracker-inl.h"
+#include "node_mutex.h"
+#include "uv.h"
+#include "v8.h"
+
+#ifdef __POSIX__
+#include <pthread.h>
+#endif
+
+namespace node {
+
+enum class SignalPropagation {
+  kContinuePropagation,
+  kStopPropagation,
+};
+
+class Watchdog {
+ public:
+  explicit Watchdog(v8::Isolate* isolate,
+                    uint64_t ms,
+                    bool* timed_out = nullptr);
+  ~Watchdog();
+  v8::Isolate* isolate() { return isolate_; }
+
+ private:
+  static void Run(void* arg);
+  static void Timer(uv_timer_t* timer);
+
+  v8::Isolate* isolate_;
+  uv_thread_t thread_;
+  uv_loop_t loop_;
+  uv_async_t async_;
+  uv_timer_t timer_;
+  bool* timed_out_;
+};
+
+class SigintWatchdogBase {
+ public:
+  virtual ~SigintWatchdogBase() = default;
+  virtual SignalPropagation HandleSigint() = 0;
+};
+
+class SigintWatchdog : public SigintWatchdogBase {
+ public:
+  explicit SigintWatchdog(v8::Isolate* isolate,
+                          bool* received_signal = nullptr);
+  ~SigintWatchdog();
+  v8::Isolate* isolate() { return isolate_; }
+  SignalPropagation HandleSigint() override;
+
+ private:
+  v8::Isolate* isolate_;
+  bool* received_signal_;
+};
+
+class TraceSigintWatchdog : public HandleWrap, public SigintWatchdogBase {
+ public:
+  static void Init(Environment* env, v8::Local<v8::Object> target);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SignalPropagation HandleSigint() override;
+
+  inline void MemoryInfo(node::MemoryTracker* tracker) const override {
+    tracker->TrackInlineField("handle_", handle_);
+  }
+  SET_MEMORY_INFO_NAME(TraceSigintWatchdog)
+  SET_SELF_SIZE(TraceSigintWatchdog)
+
+ private:
+  enum class SignalFlags { None, FromIdle, FromInterrupt };
+
+  TraceSigintWatchdog(Environment* env, v8::Local<v8::Object> object);
+  void HandleInterrupt();
+
+  bool interrupting = false;
+  uv_async_t handle_;
+  SignalFlags signal_flag_ = SignalFlags::None;
+};
+
+class SigintWatchdogHelper {
+ public:
+  static SigintWatchdogHelper* GetInstance() { return &instance; }
+  static Mutex& GetInstanceActionMutex() { return instance_action_mutex_; }
+  void Register(SigintWatchdogBase* watchdog);
+  void Unregister(SigintWatchdogBase* watchdog);
+  bool HasPendingSignal();
+
+  int Start();
+  bool Stop();
+
+ private:
+  SigintWatchdogHelper();
+  ~SigintWatchdogHelper();
+
+  static bool InformWatchdogsAboutSignal();
+  static SigintWatchdogHelper instance;
+  static Mutex instance_action_mutex_;
+
+  int start_stop_count_;
+
+  Mutex mutex_;
+  Mutex list_mutex_;
+  std::vector<SigintWatchdogBase*> watchdogs_;
+  bool has_pending_signal_;
+
+#ifdef __POSIX__
+  pthread_t thread_;
+  uv_sem_t sem_;
+  bool has_running_thread_;
+  bool stopping_;
+
+  static void* RunSigintWatchdog(void* arg);
+  static void HandleSignal(int signum, siginfo_t* info, void* ucontext);
+#else
+  bool watchdog_disabled_;
+  static BOOL WINAPI WinCtrlCHandlerRoutine(DWORD dwCtrlType);
+#endif
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_WATCHDOG_H_

package/src/headers/24/node_webstorage.h

@@ -0,0 +1,60 @@
+#ifndef SRC_NODE_WEBSTORAGE_H_
+#define SRC_NODE_WEBSTORAGE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "node_mem.h"
+#include "sqlite3.h"
+#include "util.h"
+
+namespace node {
+namespace webstorage {
+
+struct conn_deleter {
+  void operator()(sqlite3* conn) const noexcept {
+    CHECK_EQ(sqlite3_close(conn), SQLITE_OK);
+  }
+};
+using conn_unique_ptr = std::unique_ptr<sqlite3, conn_deleter>;
+
+struct stmt_deleter {
+  void operator()(sqlite3_stmt* stmt) const noexcept { sqlite3_finalize(stmt); }
+};
+using stmt_unique_ptr = std::unique_ptr<sqlite3_stmt, stmt_deleter>;
+
+static constexpr std::string_view kInMemoryPath = ":memory:";
+
+class Storage : public BaseObject {
+ public:
+  Storage(Environment* env,
+          v8::Local<v8::Object> object,
+          std::string_view location);
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  v8::Maybe<void> Clear();
+  v8::MaybeLocal<v8::Array> Enumerate();
+  v8::MaybeLocal<v8::Value> Length();
+  v8::MaybeLocal<v8::Value> Load(v8::Local<v8::Name> key);
+  v8::MaybeLocal<v8::Value> LoadKey(const int index);
+  v8::Maybe<void> Remove(v8::Local<v8::Name> key);
+  v8::Maybe<void> Store(v8::Local<v8::Name> key, v8::Local<v8::Value> value);
+
+  SET_MEMORY_INFO_NAME(Storage)
+  SET_SELF_SIZE(Storage)
+
+ private:
+  v8::Maybe<void> Open();
+
+  ~Storage() override;
+  std::string location_;
+  conn_unique_ptr db_;
+  v8::Global<v8::Map> symbols_;
+};
+
+}  // namespace webstorage
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_WEBSTORAGE_H_

package/src/headers/24/node_worker.h

@@ -0,0 +1,159 @@
+#ifndef SRC_NODE_WORKER_H_
+#define SRC_NODE_WORKER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <optional>
+#include <unordered_map>
+#include "node_exit_code.h"
+#include "node_messaging.h"
+#include "uv.h"
+
+namespace node {
+
+struct SnapshotData;
+namespace worker {
+
+class WorkerThreadData;
+
+enum ResourceLimits {
+  kMaxYoungGenerationSizeMb,
+  kMaxOldGenerationSizeMb,
+  kCodeRangeSizeMb,
+  kStackSizeMb,
+  kTotalResourceLimitCount
+};
+
+// A worker thread, as represented in its parent thread.
+class Worker : public AsyncWrap {
+ public:
+  Worker(Environment* env,
+         v8::Local<v8::Object> wrap,
+         const std::string& url,
+         const std::string& name,
+         std::shared_ptr<PerIsolateOptions> per_isolate_opts,
+         std::vector<std::string>&& exec_argv,
+         std::shared_ptr<KVStore> env_vars,
+         const SnapshotData* snapshot_data,
+         const bool is_internal);
+  ~Worker() override;
+
+  // Run the worker. This is only called from the worker thread.
+  void Run();
+
+  // Forcibly exit the thread with a specified exit code. This may be called
+  // from any thread. `error_code` and `error_message` can be used to create
+  // a custom `'error'` event before emitting `'exit'`.
+  void Exit(ExitCode code,
+            const char* error_code = nullptr,
+            const char* error_message = nullptr);
+
+  // Wait for the worker thread to stop (in a blocking manner).
+  void JoinThread();
+
+  template <typename Fn>
+  inline bool RequestInterrupt(Fn&& cb);
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(Worker)
+  SET_SELF_SIZE(Worker)
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
+
+  bool is_stopped() const;
+  const SnapshotData* snapshot_data() const { return snapshot_data_; }
+  bool is_internal() const { return is_internal_; }
+  std::string_view name() const { return name_; }
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CloneParentEnvVars(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetEnvVars(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StartThread(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void StopThread(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetResourceLimits(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  v8::Local<v8::Float64Array> GetResourceLimits(v8::Isolate* isolate) const;
+  static void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoopIdleTime(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LoopStartTime(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetHeapStatistics(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CpuUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  bool CreateEnvMessagePort(Environment* env);
+  static size_t NearHeapLimit(void* data, size_t current_heap_limit,
+                              size_t initial_heap_limit);
+
+  std::shared_ptr<PerIsolateOptions> per_isolate_opts_;
+  std::vector<std::string> exec_argv_;
+  std::vector<std::string> argv_;
+
+  MultiIsolatePlatform* platform_;
+  v8::Isolate* isolate_ = nullptr;
+  std::optional<uv_thread_t> tid_;  // Set while the thread is running
+
+  std::unique_ptr<InspectorParentHandle> inspector_parent_handle_;
+
+  // This mutex protects access to all variables listed below it.
+  mutable Mutex mutex_;
+
+  const char* custom_error_ = nullptr;
+  std::string custom_error_str_;
+  ExitCode exit_code_ = ExitCode::kNoFailure;
+  ThreadId thread_id_;
+  uintptr_t stack_base_ = 0;
+  // Optional name used for debugging in inspector and trace events.
+  std::string name_;
+
+  // Custom resource constraints:
+  double resource_limits_[kTotalResourceLimitCount];
+  void UpdateResourceConstraints(v8::ResourceConstraints* constraints);
+
+  // Full size of the thread's stack.
+  size_t stack_size_ = 4 * 1024 * 1024;
+  // Stack buffer size that is not available to the JS engine.
+  static constexpr size_t kStackBufferSize = 192 * 1024;
+
+  std::unique_ptr<MessagePortData> child_port_data_;
+  std::shared_ptr<KVStore> env_vars_;
+  EmbedderPreloadCallback embedder_preload_;
+
+  // A raw flag that is used by creator and worker threads to
+  // sync up on pre-mature termination of worker  - while in the
+  // warmup phase.  Once the worker is fully warmed up, use the
+  // async handle of the worker's Environment for the same purpose.
+  bool stopped_ = true;
+
+  bool has_ref_ = true;
+  uint64_t environment_flags_ = EnvironmentFlags::kNoFlags;
+
+  // The real Environment of the worker object. It has a lesser
+  // lifespan than the worker object itself - comes to life
+  // when the worker thread creates a new Environment, and gets
+  // destroyed alongwith the worker thread.
+  Environment* env_ = nullptr;
+
+  const SnapshotData* snapshot_data_ = nullptr;
+  const bool is_internal_;
+  friend class WorkerThreadData;
+};
+
+template <typename Fn>
+bool Worker::RequestInterrupt(Fn&& cb) {
+  Mutex::ScopedLock lock(mutex_);
+  if (env_ == nullptr) return false;
+  env_->RequestInterrupt(std::move(cb));
+  return true;
+}
+
+}  // namespace worker
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+
+#endif  // SRC_NODE_WORKER_H_