@auto_js/napi 0.0.6 → 0.0.8

package/CMakeLists.txt

@@ -14,9 +14,11 @@ target_link_libraries(${napi_js} PUBLIC nodejs)
 
 target_sources(${napi_js}
 	PRIVATE
+		api/napi_scheduler.cc
 		api/uv_dlib.cc
 		api/uv_scheduler.cc
 		support/environment.cc
+		support/host.cc
 		support/initialize.cc
 		transfer/accept.cc
 		value/array_buffer.cc
@@ -31,6 +33,8 @@ target_sources(${napi_js}
 		api/finalizer.cc
 		api/handle_scope.cc
 		api/invoke.cc
+		api/napi_scheduler.h.cc
+		api/threadsafe_function.cc
 		api/uv_dlib.h.cc
 		api/uv_handle.cc
 		api/uv_scheduler.h.cc
@@ -42,10 +46,10 @@ target_sources(${napi_js}
 		support/callback_storage.cc
 		support/callback.cc
 		support/class_template_storage.cc
-		support/container.cc
 		support/environment_fwd.cc
 		support/environment.h.cc
 		support/error_scope.cc
+		support/host.h.cc
 		support/initialize.h.cc
 		support/promise.cc
 		support/string_table.cc
@@ -64,3 +68,15 @@ target_sources(${napi_js}
 		value/record.h.cc
 		value/value.cc
 )
+
+# Enable "delay load" for win32 otherwise the dll will attempt to load node.exe from PATH as a
+# shared library and then start invoking functions from it.
+if(WIN32)
+	set(napi_js_delay_load ${napi_js}_delay_load)
+	add_library(${napi_js_delay_load} STATIC)
+	set_target_properties(${napi_js_delay_load} PROPERTIES CXX_VISIBILITY_PRESET default)
+	target_sources(${napi_js_delay_load} PUBLIC support/win32_delay_load_hook.cc)
+	target_link_libraries(${napi_js_delay_load} PUBLIC delayimp.lib)
+	target_link_libraries(${napi_js} PUBLIC ${napi_js_delay_load})
+	target_link_options(${napi_js_delay_load} PUBLIC "-Wl,/DELAYLOAD:node.exe")
+endif()

package/_module.cc

@@ -5,7 +5,6 @@ export import :bound_value;
 export import :callback;
 export import :class_definitions;
 export import :class_template_storage;
-export import :container;
 export import :environment;
 export import :error_scope;
 export import :function_definitions;

package/api/api.cc

@@ -1,11 +1,13 @@
 export module napi_js:api;
-// Internal nodejs API utilities which have no dependencies on anything else in `napi_js`
-export import nodejs;
 export import auto_js;
-export import :api.uv_scheduler;
-export import :api.uv_handle;
-export import :api.uv_dlib;
-export import :api.invoke;
-export import :api.handle_scope;
-export import :api.finalizer;
+export import nodejs;
+// Internal nodejs API utilities which have no dependencies on anything else in `napi_js`
 export import :api.callback_info;
+export import :api.finalizer;
+export import :api.handle_scope;
+export import :api.invoke;
+export import :api.napi_scheduler;
+export import :api.threadsafe_function;
+export import :api.uv_dlib;
+export import :api.uv_handle;
+export import :api.uv_scheduler;

package/api/finalizer.cc

@@ -5,36 +5,58 @@ import util;
 
 namespace js::napi {
 
-// Finalizer for basic unique_ptr
-export template <class Type, class Deleter>
-auto apply_finalizer(std::unique_ptr<Type, Deleter> unique, std::invocable<Type*, napi_finalize, void*> auto accept) -> decltype(auto)
-	requires std::is_empty_v<Deleter> {
-	// Finalizer uses a default-constructed deleter
-	const napi_finalize finalize = [](napi_env /*env*/, void* data, void* /*hint*/) -> void {
-		Deleter deleter{};
-		deleter(static_cast<Type*>(data));
-	};
-	auto result = util::regular_return{[ & ]() -> decltype(auto) {
-		return accept(unique.get(), finalize, nullptr);
-	}}();
-	unique.release();
-	return *std::move(result);
+// Generic finalizer for basic `std::unique_ptr<T>`
+template <class Env, class Type, class Deleter>
+auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Deleter> unique) {
+	if constexpr (std::is_empty_v<Deleter>) {
+		// Finalizer uses a default-constructed deleter
+		auto finalize = [](Env /*env*/, void* data, void* /*hint*/) -> void {
+			Deleter deleter{};
+			deleter(static_cast<Type*>(data));
+		};
+		return std::tuple{finalize, nullptr, std::move(unique)};
+	} else {
+		static_assert(std::is_trivially_destructible_v<Deleter>);
+		static_assert(sizeof(Deleter) == sizeof(void*));
+		// Hint is the deleter object
+		auto finalize = [](Env /*env*/, void* data, void* hint) -> void {
+			std::bit_cast<Deleter>(hint)(static_cast<Type*>(data));
+		};
+		return std::tuple{finalize, std::bit_cast<void*>(unique.get_deleter()), std::move(unique)};
+	}
 }
 
-// Finalizer for shared_ptr
-export template <class Type>
-auto apply_finalizer(std::shared_ptr<Type> shared, std::invocable<Type*, napi_finalize, void*> auto accept) -> decltype(auto) {
+// Generic finalizer for `std::shared_ptr<T>`
+template <class Env, class Type>
+auto make_finalizer(std::type_identity<Env> /*type*/, std::shared_ptr<Type> shared) {
 	// `shared_ptr<T>*` is passed as the finalizer hint
 	using shared_ptr_type = std::shared_ptr<Type>;
 	auto* ptr = shared.get();
 	auto ptr_ptr = std::make_unique<shared_ptr_type>(std::move(shared));
-	const napi_finalize finalize = [](napi_env /*env*/, void* /*data*/, void* hint) -> void {
+	auto finalize = [](Env /*env*/, void* /*data*/, void* hint) -> void {
 		delete static_cast<shared_ptr_type*>(hint);
 	};
-	auto result = util::regular_return{[ & ]() -> decltype(auto) {
-		return accept(ptr, finalize, ptr_ptr.get());
+	return std::tuple{finalize, ptr_ptr.get(), std::move(ptr_ptr)};
+}
+
+// Apply a finalizer to the given smart pointer type
+template <class Pointer, class Apply>
+auto apply_finalizer(Pointer smart_ptr, Apply apply) -> decltype(auto) {
+	using element_type = Pointer::element_type;
+	constexpr auto napi_env_type = []() consteval -> auto {
+		if constexpr (std::invocable<Apply, element_type*, node_api_basic_finalize, void*>) {
+			return type<node_api_basic_env>;
+		} else {
+			static_assert(std::invocable<Apply, element_type*, napi_finalize, void*>);
+			return type<napi_env>;
+		}
+	}();
+	auto* pointer = smart_ptr.get();
+	auto [ finalize, hint, releasable ] = make_finalizer(napi_env_type, std::move(smart_ptr));
+	auto result = util::regular_return{[ & ] -> decltype(auto) {
+		return apply(pointer, finalize, hint);
 	}}();
-	ptr_ptr.release();
+	releasable.release();
 	return *std::move(result);
 }
 

package/api/napi_scheduler.cc

@@ -0,0 +1,39 @@
+module napi_js;
+import std;
+
+namespace js::napi {
+
+// napi_scheduler
+napi_scheduler::napi_scheduler(napi_env env) :
+		fn_{env, nullptr} {
+	// It starts ref'd, so we need to unref it
+	fn_.unref(env);
+}
+
+napi_scheduler::operator bool() const noexcept {
+	return bool{fn_};
+}
+
+auto napi_scheduler::close(threadsafe_function_type::close_callback close) noexcept -> void {
+	fn_.close(close);
+}
+
+auto napi_scheduler::decrement_ref(node_api_basic_env env) const -> void {
+	auto& storage = *fn_;
+	if (--storage.refs == 0) {
+		fn_.unref(env);
+	}
+}
+
+auto napi_scheduler::increment_ref(node_api_basic_env env) const -> void {
+	auto& storage = *fn_;
+	if (++storage.refs == 1) {
+		fn_.ref(env);
+	}
+}
+
+auto napi_scheduler::storage::operator()(napi_env env, napi_value value, task_type& task) noexcept -> void {
+	task(env, value);
+}
+
+} // namespace js::napi

package/api/napi_scheduler.h.cc

@@ -0,0 +1,59 @@
+export module napi_js:api.napi_scheduler;
+import :api.threadsafe_function;
+import nodejs;
+import std;
+import util;
+
+namespace js::napi {
+
+// Shareable napi scheduler via napi_threadsafe_function
+export class napi_scheduler {
+	private:
+		struct storage;
+		using task_type = util::move_only_function<auto(napi_env, napi_value) noexcept -> void>;
+		using threadsafe_function_type = threadsafe_function_of<storage, task_type>;
+
+	public:
+		napi_scheduler() = default;
+		explicit napi_scheduler(napi_env env);
+		auto operator()(auto task, auto&&... args) const noexcept -> bool;
+		explicit operator bool() const noexcept;
+		auto close(threadsafe_function_type::close_callback close) noexcept -> void;
+		auto decrement_ref(node_api_basic_env env) const -> void;
+		auto increment_ref(node_api_basic_env env) const -> void;
+
+	private:
+		struct storage {
+				storage() = default;
+				auto operator()(napi_env env, napi_value value, task_type& task) noexcept -> void;
+				int refs{};
+		};
+
+		threadsafe_function_of<storage, task_type> fn_;
+};
+
+// An environment with an uv loop and scheduler
+export class napi_schedulable {
+	public:
+		explicit napi_schedulable(napi_env env) : scheduler_{env} {}
+		[[nodiscard]] auto scheduler(this auto& self) -> auto& { return self.scheduler_; }
+
+	private:
+		napi_scheduler scheduler_;
+};
+
+// ---
+
+auto napi_scheduler::operator()(auto task, auto&&... args) const noexcept -> bool {
+	return fn_(
+		[ task = std::move(task),
+			... args = std::forward<decltype(args)>(args) ](
+			napi_env env,
+			napi_value value
+		) mutable -> void {
+			task(env, value, std::move(args)...);
+		}
+	);
+}
+
+} // namespace js::napi

package/api/threadsafe_function.cc

@@ -0,0 +1,156 @@
+export module napi_js:api.threadsafe_function;
+import :api.invoke;
+import nodejs;
+import std;
+import util;
+
+namespace js::napi {
+
+// Maintain a "threadsafe function" via napi. `Context` must be invocable with
+// `(napi_env, napi_value, Message&)`.
+export template <class Context, class Message>
+class threadsafe_function_of : util::non_copyable {
+	public:
+		using close_callback = util::function_ref<auto()->void>;
+
+		threadsafe_function_of() = default;
+		explicit threadsafe_function_of(auto& env, napi_value value, auto&&... args);
+		threadsafe_function_of(const threadsafe_function_of&);
+		threadsafe_function_of(threadsafe_function_of&&) noexcept;
+		~threadsafe_function_of();
+		auto operator=(const threadsafe_function_of&) -> threadsafe_function_of& = delete;
+		auto operator=(threadsafe_function_of&&) -> threadsafe_function_of& = delete;
+
+		auto close(close_callback callback) noexcept -> void;
+		auto ref(node_api_basic_env env) const -> void;
+		auto unref(node_api_basic_env env) const -> void;
+		auto operator()(Message message) const noexcept -> bool;
+		auto operator*() const noexcept -> Context& { return get(); }
+		explicit operator bool() const noexcept { return tsfn_ != nullptr; }
+
+	private:
+		struct storage : Context {
+			public:
+				friend threadsafe_function_of;
+				using Context::Context;
+
+			private:
+				close_callback close_hook_{[] -> void {}};
+		};
+		auto get() const noexcept -> storage&;
+
+		constexpr static auto trivial_message =
+			std::is_trivially_destructible_v<Message> && sizeof(Message) <= sizeof(void*);
+		mutable napi_threadsafe_function tsfn_{};
+};
+
+// ---
+
+template <class Context, class Message>
+threadsafe_function_of<Context, Message>::threadsafe_function_of(auto& env, napi_value value, auto&&... args) :
+		tsfn_{[ & ]() -> auto {
+			constexpr auto name = util::make_consteval_string_view(util::cw<"threadsafe_function_of">);
+			auto resource_name = napi::invoke(napi_create_string_latin1, env, name.data(), name.size());
+			auto context = std::make_unique<storage>(std::forward<decltype(args)>(args)...);
+			// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+			auto callback = napi_threadsafe_function_call_js{[](napi_env env, napi_value value, void* context_ptr, void* data) -> void {
+				auto& context = *static_cast<storage*>(context_ptr);
+				if constexpr (trivial_message) {
+					if (env != nullptr) {
+						auto message = Message{};
+						std::memcpy(&message, &data, sizeof(Message));
+						context(env, value, message);
+					}
+				} else {
+					auto message = std::unique_ptr<Message>{static_cast<Message*>(data)};
+					if (env != nullptr) {
+						context(env, value, *message);
+					}
+				}
+			}};
+			auto finalize = napi_finalize{[](napi_env /*env*/, void* /*data*/, void* hint) -> void {
+				auto* storage_ptr = static_cast<storage*>(hint);
+				storage_ptr->close_hook_();
+				delete storage_ptr;
+			}};
+			auto* tsfn = napi::invoke(napi_create_threadsafe_function, env, value, nullptr, resource_name, 0, 1, nullptr, finalize, context.get(), callback);
+			context.release();
+			return tsfn;
+		}()} {
+}
+
+template <class Context, class Message>
+threadsafe_function_of<Context, Message>::threadsafe_function_of(const threadsafe_function_of& that) :
+		tsfn_{that.tsfn_} {
+	if (that) {
+		napi::invoke0_noexcept(napi_acquire_threadsafe_function, tsfn_);
+	}
+}
+
+template <class Context, class Message>
+threadsafe_function_of<Context, Message>::threadsafe_function_of(threadsafe_function_of&& that) noexcept :
+		tsfn_{std::exchange(that.tsfn_, nullptr)} {}
+
+template <class Context, class Message>
+threadsafe_function_of<Context, Message>::~threadsafe_function_of() {
+	if (*this) {
+		napi::invoke0_noexcept(napi_release_threadsafe_function, tsfn_, napi_tsfn_release);
+	}
+}
+
+template <class Context, class Message>
+auto threadsafe_function_of<Context, Message>::close(close_callback callback) noexcept -> void {
+	get().close_hook_ = callback;
+	napi::invoke0_noexcept(napi_release_threadsafe_function, std::exchange(tsfn_, nullptr), napi_tsfn_abort);
+}
+
+template <class Context, class Message>
+auto threadsafe_function_of<Context, Message>::ref(node_api_basic_env env) const -> void {
+	napi::invoke0(napi_ref_threadsafe_function, env, tsfn_);
+}
+
+template <class Context, class Message>
+auto threadsafe_function_of<Context, Message>::unref(node_api_basic_env env) const -> void {
+	napi::invoke0(napi_unref_threadsafe_function, env, tsfn_);
+}
+
+template <class Context, class Message>
+auto threadsafe_function_of<Context, Message>::operator()(Message message) const noexcept -> bool {
+	auto check = [ & ](napi_status status) {
+		switch (status) {
+			case napi_ok:
+				return true;
+			case napi_queue_full:
+				return false;
+			case napi_closing:
+				// nb: This is undocumented, but if you got this return it means the internal ref count was
+				// decremented.
+				this->tsfn_ = nullptr;
+				return false;
+			case napi_invalid_arg:
+				std::terminate();
+			default:
+				std::unreachable();
+		}
+	};
+	if constexpr (trivial_message) {
+		void* data{};
+		std::memcpy(&data, &message, sizeof(Message));
+		return check(napi_call_threadsafe_function(tsfn_, data, napi_tsfn_nonblocking));
+	} else {
+		auto message_ptr = std::make_unique<Message>(std::move(message));
+		auto result = check(napi_call_threadsafe_function(tsfn_, message_ptr.get(), napi_tsfn_nonblocking));
+		if (result) {
+			message_ptr.release();
+		}
+		return result;
+	}
+}
+
+template <class Context, class Message>
+auto threadsafe_function_of<Context, Message>::get() const noexcept -> storage& {
+	auto* context = napi::invoke_noexcept(napi_get_threadsafe_function_context, tsfn_);
+	return *reinterpret_cast<storage*>(context);
+}
+
+} // namespace js::napi

package/api/uv_dlib.cc

@@ -1,13 +1,14 @@
 module napi_js;
 import :api.uv_dlib;
+import :support.host;
 import util;
 
 namespace js::napi {
 
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 uv_dlib::uv_dlib(const std::string& filename) {
-	if (uv_dlopen(filename.c_str(), &lib_) != 0) {
-		throw js::runtime_error{util::transcode_string<char16_t>(std::string_view{uv_dlerror(&lib_)})};
+	if (host_uv_dlopen(filename.c_str(), &lib_) != 0) {
+		throw js::runtime_error{util::transcode_string<char16_t>(std::string_view{host_uv_dlerror(&lib_)})};
 	}
 }
 
@@ -20,7 +21,7 @@ auto uv_dlib::operator=(uv_dlib&& right) noexcept -> uv_dlib& {
 
 uv_dlib::~uv_dlib() {
 	if (lib_.handle != nullptr) {
-		uv_dlclose(&lib_);
+		host_uv_dlclose(&lib_);
 	}
 }
 

package/handle/bound_value.cc

@@ -8,6 +8,7 @@ namespace js::napi {
 template <class Tag>
 class bound_value_next : public bound_value<typename Tag::tag_type> {
 	public:
+		using tag_type = Tag;
 		using bound_value<typename Tag::tag_type>::bound_value;
 		bound_value_next() = default;
 		bound_value_next(napi_env env, value_of<Tag> value) :

package/handle/reference.cc

@@ -14,7 +14,7 @@ class reference_handle : util::non_copyable {
 				env_{env},
 				ref_{napi::invoke(napi_create_reference, env, value, 1)} {}
 
-		[[nodiscard]] auto env() const -> napi_env {
+		[[nodiscard]] auto env() const -> node_api_basic_env {
 			return env_;
 		}
 
@@ -64,7 +64,7 @@ class reference_handle : util::non_copyable {
 		explicit operator bool() const { return ref_ != nullptr; }
 
 	private:
-		napi_env env_{};
+		node_api_basic_env env_{};
 		napi_ref ref_{};
 };
 

package/handle/remote.cc

@@ -9,7 +9,7 @@ namespace js::napi {
 template <class Type>
 concept remote_handle_environment =
 	std::is_base_of_v<environment, Type> &&
-	std::is_base_of_v<uv_schedulable, Type>;
+	std::is_base_of_v<napi_schedulable, Type>;
 
 // Thread safe persistent value reference
 export template <class Tag>
@@ -23,7 +23,8 @@ class remote : protected reference_handle {
 	public:
 		using unique_remote = std::unique_ptr<remote, util::function_constant<expire>>;
 
-		remote(private_constructor /*private*/, const environment& env, value_of<Tag> value, uv_scheduler scheduler) :
+		remote() = default;
+		remote(private_constructor /*private*/, const environment& env, value_of<Tag> value, napi_scheduler scheduler) :
 				reference_handle{napi_env{env}, napi_value{value}},
 				scheduler_{std::move(scheduler)} {}
 
@@ -33,7 +34,7 @@ class remote : protected reference_handle {
 		static auto make_unique(remote_handle_environment auto& env, value_of<Tag> value) -> unique_remote;
 
 	private:
-		uv_scheduler scheduler_;
+		napi_scheduler scheduler_;
 };
 
 // Convenience helpers
@@ -59,8 +60,7 @@ template <class Tag>
 auto remote<Tag>::expire(remote* ptr) -> void {
 	std::unique_ptr<remote> self{ptr};
 	ptr->scheduler_(
-		[](auto self) -> void {
-			const auto scope = handle_scope{self->env()};
+		[](napi_env /*env*/, napi_value /*nothing*/, auto self) -> void {
 			self.reset();
 		},
 		std::move(self)

package/handle/types.cc

@@ -63,6 +63,16 @@ struct value_specialization<boolean_tag> : value_defaults<boolean_tag> {
 		using bound_type = class bound_value_for_boolean;
 };
 
+template <>
+struct value_specialization<false_tag> : value_defaults<false_tag> {
+		using bound_type = class bound_value_for_false;
+};
+
+template <>
+struct value_specialization<true_tag> : value_defaults<true_tag> {
+		using bound_type = class bound_value_for_true;
+};
+
 template <>
 struct value_specialization<number_tag> : value_defaults<number_tag> {
 		using bound_type = class bound_value_for_number;

package/handle/value.cc

@@ -26,6 +26,11 @@ class value_next : public value_of<typename Tag::tag_type> {
 		static auto from(napi_value value_) -> value_of<Tag> { return std::bit_cast<value_of<Tag>>(value_); }
 };
 
+// Deduction guide for `value_of{bound_value}`
+template <class Type>
+	requires requires { typename Type::tag_type; }
+value_of(Type value) -> value_of<typename Type::tag_type>;
+
 // Tagged napi_value
 export template <class Tag>
 class value_of : public value_specialization<Tag>::value_type {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "author": "https://github.com/laverdet/",
   "description": "Automatic JavaScript to N-API bindings",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/napi",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/js": "^0.0.6",
-    "@auto_js/napi_exports": "^0.0.6",
-    "@auto_js/v8_exports": "^0.0.4"
+    "@auto_js/js": "^0.0.8",
+    "@auto_js/napi_exports": "^0.0.8",
+    "@auto_js/v8_exports": "^0.0.6"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -96,7 +96,7 @@ constexpr auto make_constructor_function(auto constructor) {
 				// Tag the result
 				napi::invoke0(napi_type_tag_object, napi_env{env}, info.this_arg(), &type_tag_for<Type>);
 				// Wrap w/ finalizer
-				return apply_finalizer(std::move(instance), [ & ](Type* instance, napi_finalize finalize, void* hint) -> napi_value {
+				return apply_finalizer(std::move(instance), [ & ](Type* instance, node_api_basic_finalize finalize, void* hint) -> napi_value {
 					napi::invoke0(napi_wrap, napi_env{env}, info.this_arg(), instance, finalize, hint, nullptr);
 					return info.this_arg();
 				});

package/support/environment.cc

@@ -1,45 +1,26 @@
 module napi_js;
 import :api;
-import :utility;
+import :support.host;
 import util;
 
 namespace js::napi {
 
-environment::environment(napi_env env, bool uses_direct_handles) :
-		env_{env},
-		address_equal_{uses_direct_handles},
-		uses_direct_handles_{uses_direct_handles} {
-	scheduler().open(napi::invoke(napi_get_uv_event_loop, env));
-	// nb: `uv_async_t` is closed with an async hook, and not as the finalizer of
-	// `napi_set_instance_data`. `uv_close` is async and since nothing is keeping this shared library
-	// alive, the finalizer code can be unloaded.
-	auto finalizer = [](napi_async_cleanup_hook_handle handle, void* data) -> void {
-		auto& env = *static_cast<environment*>(data);
+environment::environment(napi_env env) :
+		napi_schedulable{env},
+		env_{env} {
+	// Initialize napi_js platform hooks
+	initialize_host_environment(env);
+
+	// nb: Closing the schedule needs to be the first thing we do, and deleting it needs to be the
+	// last thing we do. Otherwise we get deadlocks or use-after-free problems.
+	auto release_scheduler = [](napi_async_cleanup_hook_handle handle, void* data) -> void {
 		auto finalizer = util::fn<[](napi_async_cleanup_hook_handle handle) -> void {
 			napi::invoke0_noexcept(napi_remove_async_cleanup_hook, handle);
 		}>;
+		auto& env = *static_cast<environment*>(data);
 		env.scheduler().close(util::function_ref{finalizer, handle});
 	};
-	napi::invoke0_noexcept(napi_add_async_cleanup_hook, env, finalizer, this, &cleanup_hook_handle_);
+	napi::invoke0_noexcept(napi_add_async_cleanup_hook, env, release_scheduler, this, &cleanup_hook_handle_);
 }
 
-environment::environment(napi_env env) :
-		environment{
-			env,
-			[ & ]() -> bool {
-				const auto direct_equal = direct_address_equal{};
-				const auto indirect_equal = indirect_address_equal{};
-				auto* array = napi::invoke(napi_create_array_with_length, env, 1);
-				napi::invoke0(napi_set_element, env, array, 0, array);
-				auto* result = napi::invoke(napi_get_element, env, array, 0);
-				if (direct_equal(array, result)) {
-					return true;
-				} else if (indirect_equal(array, result)) {
-					return false;
-				} else {
-					throw std::runtime_error{"Exotic napi handle behavior detected"};
-				}
-			}()
-		} {}
-
 } // namespace js::napi

package/support/environment.h.cc

@@ -9,17 +9,12 @@ namespace js::napi {
 
 // A reference to an environment is used as the lock witness. Generally, you should not have an
 // `environment&` unless you're in the napi thread and locked.
-export class environment : util::non_moveable, public uv_schedulable {
-	private:
-		environment(napi_env env, bool uses_direct_handles);
-
+export class environment : util::non_moveable, public napi_schedulable {
 	public:
 		explicit environment(napi_env env);
 
 		// NOLINTNEXTLINE(google-explicit-constructor)
 		[[nodiscard]] operator napi_env() const { return env_; }
-		[[nodiscard]] auto address_equal() const -> const auto& { return address_equal_; }
-		[[nodiscard]] auto uses_direct_handles() const -> bool { return uses_direct_handles_; }
 
 		template <class Type>
 		static auto make_and_set_environment(napi_env env, auto&&... args) -> Type&
@@ -39,8 +34,6 @@ export class environment : util::non_moveable, public uv_schedulable {
 	private:
 		napi_env env_;
 		napi_async_cleanup_hook_handle cleanup_hook_handle_{};
-		napi::address_equal address_equal_;
-		bool uses_direct_handles_;
 };
 
 } // namespace js::napi