@auto_js/napi 0.0.1

package/support/callback.cc

@@ -0,0 +1,266 @@
+module;
+#include <optional>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+export module napi_js:callback;
+export import :callback_storage;
+import :api;
+import :bound_value;
+import :environment_fwd;
+import :error_scope;
+import :object;
+import :value_handle;
+import util;
+
+namespace js::napi {
+namespace {
+
+// Unwrap `this` into the correct tagged external. Returns `std::nullopt` if there was a type error,
+// and there is a napi exception pending. `nullptr` will not be returned.
+template <class Type>
+// NOLINTNEXTLINE(bugprone-exception-escape)
+constexpr auto unwrap_member_this = [](auto_environment auto& env, napi_value this_arg) noexcept -> std::optional<tagged_external<Type>> {
+	return napi::invoke_maybe(napi_coerce_to_object, napi_env{env}, this_arg)
+		.and_then([ &env ](napi_value coerced_this_arg) -> std::optional<tagged_external<Type>> {
+			auto as_object = bound_value{env, value<object_tag>::from(coerced_this_arg)};
+			// Technically `try_cast` can throw but it should only be in catastrophic cases.
+			Type* unwrapped = as_object.try_cast(type<Type>);
+			if (unwrapped == nullptr) {
+				// nb: The failure here is "no tag" which means we need to set the napi exception
+				napi::invoke0(napi_throw_type_error, napi_env{env}, nullptr, "Invalid object type");
+				return std::nullopt;
+			} else {
+				return tagged_external{*unwrapped};
+			}
+		});
+};
+
+} // namespace
+
+// Function type for internal host object construction
+using internal_constructor = util::function_ref<auto(napi_value)->napi_value>;
+
+// Make callback for plain free function
+export template <auto_environment Environment>
+constexpr auto make_free_function(auto function) {
+	constexpr auto make_with_try_catch =
+		[]<class Env, class... Args, bool Nx, class Result>(
+			std::type_identity<auto(Env, Args...) noexcept(Nx)->Result> /*signature*/,
+			auto callback
+		) -> auto {
+		using callback_type = decltype(callback);
+		return util::bind{
+			[](callback_type& callback, Environment& env, const callback_info& info) noexcept(Nx) -> napi_value {
+				return invoke_internal_error_scope(env, [ & ]() -> napi_value {
+					auto run = util::regular_return{[ & ]() -> decltype(auto) {
+						return std::apply(
+							callback,
+							std::tuple_cat(
+								std::forward_as_tuple(env),
+								js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
+							)
+						);
+					}};
+					return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+				});
+			},
+			std::move(callback),
+		};
+	};
+	constexpr auto make_noexcept =
+		[]<class Env, class Result>(
+			std::type_identity<auto(Env) noexcept -> Result> /*signature*/,
+			auto callback
+		) -> auto {
+		static_assert(false, "untested");
+		using callback_type = decltype(callback);
+		return util::bind{
+			[](callback_type& callback, Environment& env, const callback_info& /*info*/) noexcept -> napi_value {
+				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+					return callback(env);
+				}};
+				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+			},
+			std::move(callback),
+		};
+	};
+
+	auto callback = js::functional::thunk_free_function<Environment&>(std::move(function));
+	constexpr auto make = util::overloaded{make_with_try_catch, make_noexcept};
+	return make(std::type_identity<util::function_signature_t<decltype(callback)>>{}, std::move(callback));
+}
+
+// Make callback for constructor invocations
+export template <auto_environment Environment, class Type>
+constexpr auto make_constructor_function(auto constructor) {
+	// First, a lambda is created which will actually invoke the supplied constructor function.
+	constexpr auto make_invoke_runtime_constructor = util::overloaded{
+		[](std::nullptr_t /*constructor*/) -> auto {
+			return [](Environment& env, const callback_info& /*info*/) -> napi_value {
+				napi::invoke0(napi_throw_type_error, napi_env{env}, nullptr, "Illegal constructor");
+				return {};
+			};
+		},
+		[](auto constructor) -> auto {
+			// These are the last steps, common to both branches
+			constexpr auto wrap = [](auto instance, Environment& env, const callback_info& info) -> napi_value {
+				// 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 {
+					napi::invoke0(napi_wrap, napi_env{env}, info.this_arg(), instance, finalize, hint, nullptr);
+					return info.this_arg();
+				});
+			};
+			using wrap_type = decltype(wrap);
+
+			constexpr auto make_with_try_catch =
+				[]<class Env, class... Args, bool Nx, class Result>(
+					std::type_identity<auto(Env, Args...) noexcept(Nx)->Result> /*signature*/,
+					auto callback
+				) -> auto {
+				static_assert(false, "untested");
+				using callback_type = decltype(callback);
+				return util::bind{
+					[](callback_type& callback, wrap_type& wrap, Environment& env, const callback_info& info) noexcept(Nx) -> napi_value {
+						return invoke_internal_error_scope(env, [ & ]() -> napi_value {
+							auto instance = std::apply(
+								callback,
+								std::tuple_cat(
+									std::forward_as_tuple(env, value<object_tag>::from(info.this_arg())),
+									js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
+								)
+							);
+							return wrap(std::move(instance));
+						});
+					},
+					std::move(callback),
+					wrap,
+				};
+			};
+			constexpr auto make_noexcept =
+				[]<class Env, class Result>(
+					std::type_identity<auto(Env) noexcept -> Result> /*signature*/,
+					auto callback
+				) -> auto {
+				static_assert(false, "untested");
+				using callback_type = decltype(callback);
+				return util::bind{
+					[](callback_type& callback, Environment& env, const callback_info& info) noexcept -> napi_value {
+						return wrap(callback(env, value<object_tag>::from(info.this_arg())));
+					},
+					std::move(callback),
+				};
+			};
+
+			auto callback = js::functional::thunk_free_function<Environment&>(std::move(constructor));
+			using signature_type = util::function_signature_t<decltype(callback)>;
+			static_assert(util::signature_result<signature_type>{} != type<void>);
+			constexpr auto make = util::overloaded{make_with_try_catch, make_noexcept};
+			return make(std::type_identity<signature_type>{}, std::move(callback));
+		},
+	};
+	auto runtime_constructor = make_invoke_runtime_constructor(std::move(constructor));
+	using runtime_constructor_type = decltype(runtime_constructor);
+
+	// This part is really silly. We want the ability to create runtime host values through direct C++
+	// invocation not available to JavaScript. This is done with a tagged external value to a
+	// `util::function_ref`.
+	return util::bind{
+		[](runtime_constructor_type& constructor, Environment& env, const callback_info& info) -> napi_value {
+			auto arguments = info.arguments();
+			if (!arguments.empty()) {
+				auto maybe_constructor = [ & ]() -> std::optional<internal_constructor*> {
+					try {
+						// Check truthiness since null or undefined causes `napi_coerce_to_object` to throw
+						auto* arg0 = util::at(arguments, 0);
+						if (napi::invoke(napi_coerce_to_bool, napi_env{env}, arg0)) {
+							auto* as_object = napi::invoke(napi_coerce_to_object, napi_env{env}, arg0);
+							auto has_tag = napi::invoke(napi_check_object_type_tag, napi_env{env}, as_object, &type_tag_for<internal_constructor>);
+							if (has_tag) {
+								void* addr = napi::invoke(napi_get_value_external, napi_env{env}, as_object);
+								return static_cast<internal_constructor*>(addr);
+							}
+						}
+						return nullptr;
+					} catch (const napi::pending_error& /*error*/) {
+						return std::nullopt;
+					}
+				}();
+				if (!maybe_constructor) {
+					return nullptr;
+				}
+				if (*maybe_constructor != nullptr) {
+					const auto& constructor = **maybe_constructor;
+					return invoke_internal_error_scope(env, [ & ]() -> napi_value {
+						return constructor(info.this_arg());
+					});
+				}
+			}
+			// Invoke normal constructor
+			return constructor(env, info);
+		},
+		std::move(runtime_constructor),
+	};
+};
+
+// Make callback for method invocations
+export template <auto_environment Environment, class Type, class Method>
+constexpr auto make_member_function(Method method) {
+	constexpr auto make_with_try_catch =
+		[]<class That, class Env, class... Args, bool Nx, class Result>(
+			std::type_identity<auto(That, Env, Args...) noexcept(Nx)->Result> /*signature*/,
+			auto callback
+		) -> auto {
+		using callback_type = decltype(callback);
+		return util::bind{
+			[](callback_type& callback, Environment& env, const callback_info& info) noexcept(Nx) -> napi_value {
+				auto maybe_that = unwrap_member_this<Type>(env, info.this_arg());
+				if (!maybe_that) {
+					return nullptr;
+				}
+				return invoke_internal_error_scope(env, [ & ]() -> napi_value {
+					auto run = util::regular_return{[ & ]() -> decltype(auto) {
+						return std::apply(
+							callback,
+							std::tuple_cat(
+								std::forward_as_tuple(**maybe_that, env),
+								js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
+							)
+						);
+					}};
+					return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+				});
+			},
+			std::move(callback),
+		};
+	};
+	constexpr auto make_noexcept =
+		[]<class That, class Env, class Result>(
+			std::type_identity<auto(That, Env) noexcept -> Result> /*signature*/,
+			auto callback
+		) -> auto {
+		static_assert(false, "untested");
+		using callback_type = decltype(callback);
+		return util::bind{
+			[](callback_type& callback, Environment& env, const callback_info& info) noexcept -> napi_value {
+				auto maybe_that = unwrap_member_this<Type>(env, info.this_arg());
+				if (!maybe_that) {
+					return nullptr;
+				}
+				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+					return callback(**maybe_that, env);
+				}};
+				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+			},
+			std::move(callback),
+		};
+	};
+
+	auto callback = js::functional::thunk_member_function<Environment&>(std::move(method));
+	constexpr auto make = util::overloaded{make_with_try_catch, make_noexcept};
+	return make(std::type_identity<util::function_signature_t<decltype(callback)>>{}, std::move(callback));
+};
+
+} // namespace js::napi

package/support/callback_storage.cc

@@ -0,0 +1,64 @@
+module;
+#include <memory>
+#include <type_traits>
+#include <utility>
+export module napi_js:callback_storage;
+import :api;
+import :environment_fwd;
+
+namespace js::napi {
+
+namespace {
+// Since napi runs each environment in its own thread we can store the environment data pointer
+// here. We could also go through `napi_get_instance_data` but there is no assurance that the
+// pointer type is the same. We assume the environment pointer will outlive the callback.
+template <auto_environment Environment>
+thread_local Environment* env_local = nullptr;
+} // namespace
+
+// Converts any invocable into a `napi_callback` and data pointer for use in napi API calls. The
+// result is a `std::tuple` with `{ callback_ptr, data_ptr, finalizer }`. Finalizer is either a
+// `nullptr` or a `std::unique_ptr<T>` which should be disposed of in a finalizer.
+template <auto_environment Environment>
+auto make_callback_storage(Environment& env, std::invocable<Environment&, const callback_info&> auto function) {
+	using function_type = decltype(function);
+	if constexpr (std::is_trivially_copyable_v<function_type>) {
+		if constexpr (std::is_empty_v<function_type>) {
+			// Constant expression function, expressed entirely in the type. `data` is the environment.
+			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
+				const auto args = callback_info{nenv, info};
+				auto invoke = function_type{};
+				auto& env = *static_cast<Environment*>(args.data());
+				return invoke(env, args);
+			}};
+			return std::tuple{callback, &env};
+		} else if constexpr (sizeof(function_type) <= sizeof(void*)) {
+			// Trivial function type containing less than or equal to a pointer size. `data` is the
+			// function and environment is stored in a thread local.
+			env_local<Environment> = &env;
+			auto* data = reinterpret_cast<void*&>(function);
+			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
+				const auto args = callback_info{nenv, info};
+				auto* data = args.data();
+				auto& invoke = reinterpret_cast<function_type&>(data);
+				auto& env = *env_local<Environment>;
+				return invoke(env, args);
+			}};
+			return std::tuple{callback, data};
+		} else {
+			static_assert(false, "Large trivial function?");
+		}
+	} else {
+		// Otherwise the function requires bound state w/ a destructor
+		using pair_type = std::pair<Environment*, function_type>;
+		auto external_data = std::make_unique<pair_type>(&env, std::move(function));
+		const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
+			const auto args = callback_info{nenv, info};
+			auto& state = *static_cast<pair_type*>(args.data());
+			return state.second(*state.first, args);
+		}};
+		return std::tuple{callback, std::move(external_data)};
+	}
+}
+
+} // namespace js::napi

package/support/class_template_storage.cc

@@ -0,0 +1,62 @@
+module;
+#include <string> // IWYU pragma: keep
+#include <type_traits>
+export module napi_js:class_template_storage;
+import :reference;
+import auto_js;
+import util;
+using namespace std::string_literals;
+
+#if _LIBCPP_VERSION || _MSVC_STL_UPDATE
+// clang 22.1.0 w/ -stdlib=libc++ (and also MS STL)
+// /workspace/packages/auto_js/napi/support/class_template_storage.cc:28:45: error: invalid operands
+// to binary expression ('basic_string<char>' and 'const std::basic_string_view<char>')
+// 28 |                         static_assert(index, "Class template '"s + name_sv + "' is missing in storage"s);
+export {
+	using std::operator+;
+}
+#endif
+
+namespace js::napi {
+
+// Given a pack of strings it returns a static reference to a `util::sealed_map` of napi object
+// references.
+template <const auto& Strings>
+constexpr auto class_template_references_of = []() -> auto {
+	const auto [... strings ] = Strings;
+	return util::sealed_map{std::type_identity<napi::reference<class_tag>>{}, strings...};
+}();
+
+// Environment storage for class template references
+export template <const auto& Strings>
+class class_template_references {
+	public:
+		template <class Type>
+		auto class_template(this auto& self, std::type_identity<Type> /*type*/, const auto& class_template) -> napi::value<class_tag_of<Type>> {
+			constexpr auto name_sv = util::consteval_string_view{class_template.constructor.name};
+			constexpr auto index = class_template_references_of<Strings>.lookup(name_sv);
+			if constexpr (!index) {
+				// nb: This fails while linking against STL for some reason. So the `constexpr` if works
+				// around the issue.
+				// D:\a\isolated-vm\isolated-vm\packages\auto_js\napi\support\class_template_storage.cc:38:45:
+				//    error: invalid operands to binary expression ('string' (aka 'basic_string<char,
+				//    char_traits<char>, allocator<char>>') and 'const std::basic_string_view<char>')
+				//    38 |                         static_assert(index, "Class template '"s + name_sv + "' is missing in storage"s);
+				static_assert(index, "Class template '"s + name_sv + "' is missing in storage"s);
+			}
+			auto& reference = self.class_template_references_.at(index).second;
+			using value_type = js::napi::value<class_tag_of<Type>>;
+			if (reference) {
+				return value_type::from(reference.get(self));
+			} else {
+				auto template_value = value_type::make(self, class_template);
+				reference.reset(self, template_value);
+				return template_value;
+			}
+		}
+
+	private:
+		util::copy_of<class_template_references_of<Strings>> class_template_references_;
+};
+
+} // namespace js::napi

package/support/container.cc

@@ -0,0 +1,78 @@
+module;
+#include <bit>
+#include <unordered_map>
+export module napi_js:container;
+import :environment;
+import :utility;
+import nodejs;
+import util;
+
+namespace js::napi {
+
+// Map container for napi values
+template <class Type>
+struct virtual_value_map {
+	public:
+		using container_type = std::unordered_map<napi_value, Type>;
+		using iterator = container_type::iterator;
+		using mapped_type = container_type::mapped_type;
+
+		virtual auto end() const -> iterator = 0;
+		virtual auto find(napi_value key) const -> iterator = 0;
+		virtual auto try_emplace(napi_value key, Type value) -> std::pair<iterator, bool> = 0;
+};
+
+template <class Map>
+struct concrete_value_map final : virtual_value_map<typename Map::mapped_type> {
+	public:
+		using container_type = Map;
+		// nb: The iterator type between `std::unordered_map<int, int, left>` and
+		// `std::unordered_map<int, int, right>` are not technically compatible.
+		using iterator = virtual_value_map<typename Map::mapped_type>::iterator;
+		using mapped_type = container_type::mapped_type;
+
+		virtual auto end() const -> iterator {
+			return std::bit_cast<iterator>(map_.end());
+		}
+
+		virtual auto find(napi_value key) const -> iterator {
+			return std::bit_cast<iterator>(map_.find(key));
+		}
+
+		virtual auto try_emplace(napi_value key, mapped_type value) -> std::pair<iterator, bool> {
+			auto [ it, inserted ] = map_.try_emplace(key, std::move(value));
+			return std::pair{std::bit_cast<iterator>(it), inserted};
+		}
+
+	private:
+		container_type map_;
+};
+
+export template <class Type>
+class value_map {
+	private:
+		using direct_map_type = concrete_value_map<std::unordered_map<napi_value, Type, direct_address_hash, direct_address_equal>>;
+		using indirect_map_type = concrete_value_map<std::unordered_map<napi_value, Type, indirect_address_hash, indirect_address_equal>>;
+		using virtual_map_type = util::covariant_value<virtual_value_map<Type>, direct_map_type, indirect_map_type>;
+
+	public:
+		using container_type = virtual_value_map<Type>;
+		using iterator = container_type::iterator;
+		using mapped_type = container_type::mapped_type;
+
+		explicit value_map(const environment& env) :
+				map_{
+					env.uses_direct_handles()
+						? virtual_map_type{direct_map_type{}}
+						: virtual_map_type{indirect_map_type{}}
+				} {}
+
+		auto end() const -> iterator { return map_->end(); }
+		auto find(napi_value key) const -> iterator { return map_->find(key); }
+		auto try_emplace(napi_value key, mapped_type value) -> std::pair<iterator, bool> { return map_->try_emplace(key, std::move(value)); }
+
+	private:
+		virtual_map_type map_;
+};
+
+} // namespace js::napi

package/support/environment.cc

@@ -0,0 +1,33 @@
+module;
+#include <stdexcept>
+module napi_js;
+import :api;
+import :utility;
+import util;
+
+namespace js::napi {
+
+environment::environment(napi_env env) :
+		env_{env},
+		uses_direct_handles_{[ & ]() -> 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"};
+			}
+		}()} {
+	scheduler().open(napi::invoke(napi_get_uv_event_loop, env));
+}
+
+environment::~environment() {
+	scheduler().close();
+}
+
+} // namespace js::napi

package/support/environment.h.cc

@@ -0,0 +1,56 @@
+module;
+#include <functional>
+#include <memory>
+export module napi_js:environment;
+export import :environment_fwd;
+import :api;
+import util;
+
+namespace js::napi {
+
+// Internal holder for an environment pointer. Used as a common base class for `visit` & `accept`.
+// This could maybe become something similar to `realm_scope` if the need for it is more common.
+export template <auto_environment Type>
+class environment_scope {
+	public:
+		explicit environment_scope(Type& env) : env_{env} {}
+
+		explicit operator napi_env() const { return napi_env{env_.get()}; }
+		[[nodiscard]] auto environment() const -> Type& { return env_; }
+
+	private:
+		std::reference_wrapper<Type> env_;
+};
+
+// 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 {
+	public:
+		explicit environment(napi_env env);
+		~environment();
+
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		[[nodiscard]] operator napi_env() const { return env_; }
+		[[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&
+			requires std::constructible_from<Type, napi_env, decltype(args)...> {
+			auto instance = std::make_unique<Type>(env, std::forward<decltype(args)>(args)...);
+			return *apply_finalizer(std::move(instance), [ & ](Type* instance, napi_finalize finalize, void* hint) -> Type* {
+				napi::invoke0(napi_set_instance_data, env, instance, finalize, hint);
+				return instance;
+			});
+		}
+
+		template <class Type>
+		static auto unsafe_get_environment_as(napi_env env) -> Type& {
+			return *static_cast<Type*>(napi::invoke(napi_get_instance_data, env));
+		}
+
+	private:
+		napi_env env_;
+		bool uses_direct_handles_;
+};
+
+} // namespace js::napi

package/support/environment_fwd.cc

@@ -0,0 +1,15 @@
+module;
+#include <concepts>
+export module napi_js:environment_fwd;
+
+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;
+
+// Environment constraint
+export template <class Type>
+concept auto_environment = std::derived_from<Type, environment>;
+
+} // namespace js::napi

package/support/error_scope.cc

@@ -0,0 +1,22 @@
+export module napi_js:error_scope;
+import :accept;
+import :api;
+import :environment;
+
+namespace js::napi {
+
+// Catch `napi::pending_error` (thrown by `napi::invoke`) or `js::error`, converting to thrown
+// runtime error.
+[[nodiscard]] auto invoke_internal_error_scope(environment& env, auto implementation) -> napi_value {
+	try {
+		return implementation();
+	} catch (const napi::pending_error& /*error*/) {
+		return napi_value{};
+	} catch (const js::error& error) {
+		auto* exception = js::transfer_in_strict<napi_value>(error, env);
+		napi::invoke0(napi_throw, napi_env{env}, exception);
+		return napi_value{};
+	}
+};
+
+} // namespace js::napi

package/support/initialize.cc

@@ -0,0 +1,25 @@
+module;
+#include <cassert>
+module napi_js;
+import :initialize;
+
+namespace js::napi::detail {
+
+initialize_require* module_to_initialize = nullptr;
+
+initialize_require::initialize_require(int /*nothing*/, initialize_require& instance) {
+	assert(module_to_initialize == nullptr);
+	module_to_initialize = &instance;
+}
+
+initialize_require::~initialize_require() {
+	assert(module_to_initialize == this);
+	module_to_initialize = nullptr;
+}
+
+auto initialize_require::initialize(napi_env env, napi_value exports) -> void {
+	assert(module_to_initialize != nullptr);
+	(*module_to_initialize)(env, exports);
+}
+
+} // namespace js::napi::detail

package/support/initialize.h.cc

@@ -0,0 +1,48 @@
+module;
+#include <cassert>
+#include <tuple>
+export module napi_js:initialize;
+import :environment;
+import :value;
+import nodejs;
+import util;
+
+namespace js::napi {
+
+namespace detail {
+
+export class initialize_require : util::non_copyable {
+	protected:
+		~initialize_require();
+
+	public:
+		explicit initialize_require(int /*nothing*/, initialize_require& instance);
+		virtual auto operator()(napi_env env, napi_value exports) -> void = 0;
+		static auto initialize(napi_env env, napi_value exports) -> void;
+};
+
+} // namespace detail
+
+export template <class Environment, class Make, class... Args>
+class napi_js_module final : private detail::initialize_require {
+	public:
+		explicit napi_js_module(std::type_identity<Environment> /*env*/, Make make_exports, Args... args) :
+				detail::initialize_require{0, *this},
+				make_exports_{std::move(make_exports)},
+				args_{std::move(args)...} {}
+
+	private:
+		auto operator()(napi_env env, napi_value exports) -> void override {
+			// construct environment, set napi instance data w/ finalizer
+			const auto [... indices ] = util::sequence<sizeof...(Args)>;
+			auto& client_environment = environment::make_and_set_environment<Environment>(env, std::get<indices>(std::move(args_))...);
+			// assign export descriptor to napi-constructor namespace object
+			auto exports_local = napi::value<dictionary_tag>::from(exports);
+			exports_local.assign(client_environment, std::move(make_exports_)(client_environment));
+		}
+
+		Make make_exports_;
+		std::tuple<Args...> args_;
+};
+
+} // namespace js::napi