@encharm/cws 4.4.1 → 4.5.2

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/{18 → 24}/node_watchdog.h

@@ -110,6 +110,7 @@ class TraceSigintWatchdog : public HandleWrap, public SigintWatchdogBase {
 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();
@@ -123,6 +124,7 @@ class SigintWatchdogHelper {
 
   static bool InformWatchdogsAboutSignal();
   static SigintWatchdogHelper instance;
+  static Mutex instance_action_mutex_;
 
   int start_stop_count_;
 

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/{16 → 24}/node_worker.h

@@ -3,11 +3,15 @@
 
 #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;
@@ -26,9 +30,12 @@ class Worker : public AsyncWrap {
   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);
+         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.
@@ -37,7 +44,7 @@ class Worker : public AsyncWrap {
   // 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(int code,
+  void Exit(ExitCode code,
             const char* error_code = nullptr,
             const char* error_message = nullptr);
 
@@ -47,12 +54,15 @@ class Worker : public AsyncWrap {
   template <typename Fn>
   inline bool RequestInterrupt(Fn&& cb);
 
-  void MemoryInfo(MemoryTracker* tracker) const override;
+  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(
@@ -60,6 +70,7 @@ class Worker : public AsyncWrap {
   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(
@@ -68,6 +79,9 @@ class Worker : public AsyncWrap {
   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);
@@ -80,19 +94,20 @@ class Worker : public AsyncWrap {
 
   MultiIsolatePlatform* platform_;
   v8::Isolate* isolate_ = nullptr;
-  uv_thread_t tid_;
+  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_;
 
-  bool thread_joined_ = true;
   const char* custom_error_ = nullptr;
   std::string custom_error_str_;
-  int exit_code_ = 0;
+  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];
@@ -105,10 +120,7 @@ class Worker : public AsyncWrap {
 
   std::unique_ptr<MessagePortData> child_port_data_;
   std::shared_ptr<KVStore> env_vars_;
-
-  // This is always kept alive because the JS object associated with the Worker
-  // instance refers to it via its [kPort] property.
-  MessagePort* parent_port_ = nullptr;
+  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
@@ -125,6 +137,8 @@ class Worker : public AsyncWrap {
   // destroyed alongwith the worker thread.
   Environment* env_ = nullptr;
 
+  const SnapshotData* snapshot_data_ = nullptr;
+  const bool is_internal_;
   friend class WorkerThreadData;
 };
 

package/src/headers/24/packet.h

@@ -0,0 +1,155 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <base_object.h>
+#include <env.h>
+#include <ngtcp2/ngtcp2.h>
+#include <node_external_reference.h>
+#include <node_sockaddr.h>
+#include <req_wrap.h>
+#include <uv.h>
+#include <v8.h>
+#include <string>
+#include "bindingdata.h"
+#include "cid.h"
+#include "data.h"
+#include "defs.h"
+#include "tokens.h"
+
+namespace node::quic {
+
+struct PathDescriptor {
+  uint32_t version;
+  const CID& dcid;
+  const CID& scid;
+  const SocketAddress& local_address;
+  const SocketAddress& remote_address;
+  std::string ToString() const;
+};
+
+// A Packet encapsulates serialized outbound QUIC data.
+// Packets must never be larger than the path MTU. The
+// default QUIC packet maximum length is 1200 bytes,
+// which we assume by default. The packet storage will
+// be stack allocated up to this size.
+//
+// Packets are maintained in a freelist held by the
+// BindingData instance. When using Create() to create
+// a Packet, we'll check to see if there is a free
+// packet in the freelist and use it instead of starting
+// fresh with a new packet. The freelist can store at
+// most kMaxFreeList packets
+//
+// Packets are always encrypted so their content should
+// be considered opaque to us. We leave it entirely up
+// to ngtcp2 how to encode QUIC frames into the packet.
+class Packet final : public ReqWrap<uv_udp_send_t> {
+ private:
+  struct Data;
+
+ public:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  class Listener {
+   public:
+    virtual void PacketDone(int status) = 0;
+  };
+
+  // Do not use the Packet constructors directly to create
+  // them. These are public only to support MakeBaseObject.
+  // Use the Create, or Create variants to create or
+  // acquire packet instances.
+
+  Packet(Environment* env,
+         Listener* listener,
+         v8::Local<v8::Object> object,
+         const SocketAddress& destination,
+         size_t length,
+         const char* diagnostic_label = "<unknown>");
+
+  Packet(Environment* env,
+         Listener* listener,
+         v8::Local<v8::Object> object,
+         const SocketAddress& destination,
+         std::shared_ptr<Data> data);
+
+  DISALLOW_COPY_AND_MOVE(Packet)
+
+  const SocketAddress& destination() const;
+  size_t length() const;
+  operator uv_buf_t() const;
+  operator ngtcp2_vec() const;
+
+  // Modify the size of the packet after ngtcp2 has written
+  // to it. len must be <= length(). We call this after we've
+  // asked ngtcp2 to encode frames into the packet and ngtcp2
+  // tells us how many of the packets bytes were used.
+  void Truncate(size_t len);
+
+  static BaseObjectPtr<Packet> Create(
+      Environment* env,
+      Listener* listener,
+      const SocketAddress& destination,
+      size_t length = kDefaultMaxPacketLength,
+      const char* diagnostic_label = "<unknown>");
+
+  BaseObjectPtr<Packet> Clone() const;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(Packet)
+  SET_SELF_SIZE(Packet)
+
+  std::string ToString() const;
+
+  static BaseObjectPtr<Packet> CreateRetryPacket(
+      Environment* env,
+      Listener* listener,
+      const PathDescriptor& path_descriptor,
+      const TokenSecret& token_secret);
+
+  static BaseObjectPtr<Packet> CreateConnectionClosePacket(
+      Environment* env,
+      Listener* listener,
+      const SocketAddress& destination,
+      ngtcp2_conn* conn,
+      const QuicError& error);
+
+  static BaseObjectPtr<Packet> CreateImmediateConnectionClosePacket(
+      Environment* env,
+      Listener* listener,
+      const PathDescriptor& path_descriptor,
+      const QuicError& reason);
+
+  static BaseObjectPtr<Packet> CreateStatelessResetPacket(
+      Environment* env,
+      Listener* listener,
+      const PathDescriptor& path_descriptor,
+      const TokenSecret& token_secret,
+      size_t source_len);
+
+  static BaseObjectPtr<Packet> CreateVersionNegotiationPacket(
+      Environment* env,
+      Listener* listener,
+      const PathDescriptor& path_descriptor);
+
+  // Called when the packet is done being sent.
+  void Done(int status);
+
+ private:
+  static BaseObjectPtr<Packet> FromFreeList(Environment* env,
+                                            std::shared_ptr<Data> data,
+                                            Listener* listener,
+                                            const SocketAddress& destination);
+
+  Listener* listener_;
+  SocketAddress destination_;
+  std::shared_ptr<Data> data_;
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/path.h

@@ -0,0 +1,33 @@
+#ifndef SRC_PATH_H_
+#define SRC_PATH_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include <vector>
+#include "node_options-inl.h"
+#include "util-inl.h"
+
+namespace node {
+
+constexpr bool IsPathSeparator(const char c) noexcept;
+
+std::string NormalizeString(const std::string_view path,
+                            bool allowAboveRoot,
+                            const std::string_view separator);
+
+std::string PathResolve(Environment* env,
+                        const std::vector<std::string_view>& paths);
+
+#ifdef _WIN32
+constexpr bool IsWindowsDeviceRoot(const char c) noexcept;
+#endif  // _WIN32
+
+void ToNamespacedPath(Environment* env, BufferValue* path);
+void FromNamespacedPath(std::string* path);
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_PATH_H_

package/src/headers/24/permission/addon_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_ADDON_PERMISSION_H_
+#define SRC_PERMISSION_ADDON_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <string>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class AddonPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param = "") const override;
+
+ private:
+  bool deny_all_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_ADDON_PERMISSION_H_

package/src/headers/24/permission/child_process_permission.h

@@ -0,0 +1,31 @@
+#ifndef SRC_PERMISSION_CHILD_PROCESS_PERMISSION_H_
+#define SRC_PERMISSION_CHILD_PROCESS_PERMISSION_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <vector>
+#include "permission/permission_base.h"
+
+namespace node {
+
+namespace permission {
+
+class ChildProcessPermission final : public PermissionBase {
+ public:
+  void Apply(Environment* env,
+             const std::vector<std::string>& allow,
+             PermissionScope scope) override;
+  bool is_granted(Environment* env,
+                  PermissionScope perm,
+                  const std::string_view& param = "") const override;
+
+ private:
+  bool deny_all_;
+};
+
+}  // namespace permission
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_PERMISSION_CHILD_PROCESS_PERMISSION_H_