@auto_js/napi 0.0.11 → 0.0.12

package/support/class_template_storage.cc

@@ -1,4 +1,5 @@
 export module napi_js:class_template_storage;
+import :lock;
 import :reference;
 import auto_js;
 import std;
@@ -19,8 +20,8 @@ constexpr auto class_template_references_of = [] consteval -> auto {
 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) -> local_of<class_tag_of<Type>> {
+		template <class Environment, class Type>
+		auto class_template(this Environment& self, std::type_identity<Type> /*type*/, const environment_lock_witness_of<Environment>& lock, const auto& class_template) -> local_of<class_tag_of<Type>> {
 			constexpr auto name_sv = util::make_consteval_string_view(class_template.constructor.name);
 			constexpr auto index = class_template_references_of<Strings>.lookup(name_sv);
 			if constexpr (!index) {
@@ -35,10 +36,10 @@ class class_template_references {
 			auto& reference = self.class_template_references_.at(index).second;
 			using value_type = js::napi::local_of<class_tag_of<Type>>;
 			if (reference) {
-				return value_type::from(reference.get(self));
+				return value_type::from(reference.get(lock));
 			} else {
-				auto template_value = value_type::make(self, class_template);
-				reference.reset(self, template_value);
+				auto template_value = value_type::make(lock, class_template);
+				reference.reset(lock, template_value);
 				return template_value;
 			}
 		}

package/support/environment.cc

@@ -10,6 +10,7 @@ environment::environment(napi_env env) :
 		env_{env} {
 	// Initialize napi_js platform hooks
 	initialize_host_environment(env);
+	isolate_ = host_current_isolate();
 
 	// 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.

package/support/environment.h.cc

@@ -1,14 +1,14 @@
 export module napi_js:environment;
 export import :environment_fwd;
 import :api;
-import :utility;
 import std;
 import util;
+import v8;
 
 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.
+// Per-instance environment state. The lifetime of instances of this class is managed by the
+// runtime.
 export class environment : util::non_moveable, public napi_schedulable {
 	public:
 		explicit environment(napi_env env);
@@ -16,6 +16,10 @@ export class environment : util::non_moveable, public napi_schedulable {
 		// NOLINTNEXTLINE(google-explicit-constructor)
 		[[nodiscard]] operator napi_env() const { return env_; }
 
+		// In the fast (nodejs) case this is the isolate which backs the environment. Otherwise it is
+		// `nullptr`.
+		[[nodiscard]] auto isolate() const -> v8::Isolate* { return isolate_; }
+
 		template <class Type>
 		static auto make_and_set_environment(napi_env env, auto&&... args) -> Type&
 			requires std::constructible_from<Type, napi_env, decltype(args)...> {
@@ -33,6 +37,7 @@ export class environment : util::non_moveable, public napi_schedulable {
 
 	private:
 		napi_env env_;
+		v8::Isolate* isolate_{};
 		napi_async_cleanup_hook_handle cleanup_hook_handle_{};
 };
 

package/support/environment_fwd.cc

@@ -3,12 +3,14 @@ import std;
 
 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.
+// Per-instance environment state.
 export class environment;
 
 // Environment constraint
 export template <class Type>
 concept auto_environment = std::derived_from<Type, environment>;
 
+// Environment lock witness, defined in `:lock`
+export class environment_lock_witness;
+
 } // namespace js::napi

package/support/error_scope.cc

@@ -1,18 +1,24 @@
 export module napi_js:error_scope;
 import :accept;
+import :lock;
 
 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 {
+// Catch `napi::pending_error` (thrown by `napi::invoke`), `napi::pending_v8_error` (thrown by
+// `napi::unmaybe`), or `js::error`, converting to thrown runtime error.
+export template <class Environment>
+[[nodiscard]] auto invoke_internal_error_scope(const environment_lock_witness_of<Environment>& lock, auto implementation) -> napi_value {
+	auto try_catch = environment_try_catch{lock};
 	try {
 		return implementation();
 	} catch (const napi::pending_error& /*error*/) {
 		return napi_value{};
+	} catch (const napi::pending_v8_error& /*error*/) {
+		std::ignore = napi::invoke0_maybe(napi_throw, napi_env{lock}, try_catch.take_exception());
+		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);
+		auto* exception = js::transfer_in_strict<napi_value>(error, lock);
+		napi::invoke0(napi_throw, napi_env{lock}, exception);
 		return napi_value{};
 	}
 };

package/support/host.cc

@@ -43,6 +43,30 @@ auto napi_fast_is_undefined(napi_env env, napi_value value) -> bool {
 	return value == napi::invoke(napi_get_undefined, env);
 }
 
+// Isolate access
+auto v8_current_isolate() -> v8::Isolate* {
+	return v8::Isolate::GetCurrent();
+}
+
+constexpr auto unknown_current_isolate = [] -> v8::Isolate* { return nullptr; };
+
+// Element access
+auto v8_has_element(environment_lock_witness lock, napi_value array, std::uint32_t index) -> bool {
+	return napi::unmaybe(std::bit_cast<v8::Local<v8::Object>>(array)->Has(lock.context(), index));
+}
+
+auto v8_get_element(environment_lock_witness lock, napi_value array, std::uint32_t index) -> napi_value {
+	return std::bit_cast<napi_value>(napi::unmaybe(std::bit_cast<v8::Local<v8::Object>>(array)->Get(lock.context(), index)));
+}
+
+auto napi_fast_has_element(environment_lock_witness lock, napi_value array, std::uint32_t index) -> bool {
+	return napi::invoke(napi_has_element, napi_env{lock}, array, index);
+}
+
+auto napi_fast_get_element(environment_lock_witness lock, napi_value array, std::uint32_t index) -> napi_value {
+	return napi::invoke(napi_get_element, napi_env{lock}, array, index);
+}
+
 // Extended fast functions
 // nb: Bun exports these v8 functions, but they crash with the `std::bit_cast<v8::Local<T>>` trick.
 auto fast_is_array(napi_value value) -> bool {
@@ -121,6 +145,13 @@ auto bun_maybe_is_shared_array_buffer(napi_env env, local_of<object_tag> value)
 
 constexpr auto unknown_maybe_is = [](auto...) -> std::optional<bool> { return std::nullopt; };
 
+// 'ArrayBuffer' functions
+auto v8_array_buffer_get_backing_store(local_of<array_buffer_tag> buffer) -> std::shared_ptr<data_block::array_type> {
+	auto backing_store = std::bit_cast<v8::Local<v8::ArrayBuffer>>(buffer)->GetBackingStore();
+	auto* data = reinterpret_cast<std::byte*>(backing_store->Data());
+	return std::shared_ptr<data_block::array_type>{std::move(backing_store), data};
+};
+
 // 'SharedArrayBuffer' functions
 auto v8_make_shared_array_buffer(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> local_of<shared_array_buffer_tag> {
 	auto backing_store = [ & ] -> auto {
@@ -150,11 +181,10 @@ auto v8_shared_array_buffer_get_byte_length(local_of<shared_array_buffer_tag> bu
 	return std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer})->ByteLength();
 };
 
-auto v8_shared_array_buffer_get_backing_store(local_of<shared_array_buffer_tag> buffer) -> std::shared_ptr<std::byte[]> {
+auto v8_shared_array_buffer_get_backing_store(local_of<shared_array_buffer_tag> buffer) -> std::shared_ptr<data_block::array_type> {
 	auto backing_store = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(buffer)->GetBackingStore();
 	auto* data = reinterpret_cast<std::byte*>(backing_store->Data());
-	// NOLINTNEXTLINE(modernize-avoid-c-arrays)
-	return std::shared_ptr<std::byte[]>{std::move(backing_store), data};
+	return std::shared_ptr<data_block::array_type>{std::move(backing_store), data};
 };
 
 // 'ArrayBufferView' constructors
@@ -272,6 +302,9 @@ auto initialize_host_environment(napi_env env) -> void {
 			auto is_nodejs = !is_bun && !is_deno;
 			if (is_nodejs) {
 				has_extended_fast_is_functions = true;
+				host_current_isolate = v8_current_isolate;
+				fast_get_element = v8_get_element;
+				fast_has_element = v8_has_element;
 				fast_is_false = v8_is_false;
 				fast_is_null = v8_is_null;
 				fast_is_true = v8_is_true;
@@ -279,6 +312,7 @@ auto initialize_host_environment(napi_env env) -> void {
 				host_uv_dlclose = node_uv_dlclose;
 				host_uv_dlerror = node_uv_dlerror;
 				host_uv_dlopen = node_uv_dlopen;
+				make_sab_data_view = v8_make_sab_data_view;
 				make_sab_typed_array_of<double> = v8_make_sab_typed_array_of<double>;
 				make_sab_typed_array_of<float> = v8_make_sab_typed_array_of<float>;
 				make_sab_typed_array_of<js::float16_t> = v8_make_sab_typed_array_of<js::float16_t>;
@@ -291,6 +325,7 @@ auto initialize_host_environment(napi_env env) -> void {
 				make_sab_typed_array_of<std::uint32_t> = v8_make_sab_typed_array_of<std::uint32_t>;
 				make_sab_typed_array_of<std::uint64_t> = v8_make_sab_typed_array_of<std::uint64_t>;
 				make_sab_typed_array_of<std::uint8_t> = v8_make_sab_typed_array_of<std::uint8_t>;
+				array_buffer_get_backing_store = v8_array_buffer_get_backing_store;
 				make_shared_array_buffer = v8_make_shared_array_buffer;
 				maybe_is_number_int32 = v8_is_number_int32;
 				maybe_is_shared_array_buffer = node_api_maybe_is_shared_array_buffer;
@@ -299,6 +334,9 @@ auto initialize_host_environment(napi_env env) -> void {
 				shared_array_buffer_get_byte_length = v8_shared_array_buffer_get_byte_length;
 			} else {
 				has_extended_fast_is_functions = false;
+				host_current_isolate = unknown_current_isolate;
+				fast_get_element = napi_fast_get_element;
+				fast_has_element = napi_fast_has_element;
 				fast_is_false = napi_fast_is_false;
 				fast_is_null = napi_fast_is_null;
 				fast_is_true = napi_fast_is_true;
@@ -319,12 +357,12 @@ auto initialize_host_environment(napi_env env) -> void {
 				make_sab_typed_array_of<std::uint32_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint32_t>>>;
 				make_sab_typed_array_of<std::uint64_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint64_t>>>;
 				make_sab_typed_array_of<std::uint8_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint8_t>>>;
+				array_buffer_get_backing_store = nullptr;
 				make_shared_array_buffer = unknown_sab_throw<local_of<shared_array_buffer_tag>>;
 				maybe_is_number_int32 = unknown_maybe_is;
 				maybe_is_shared_array_buffer = unknown_maybe_is;
 				maybe_is_string_latin1 = unknown_maybe_is;
-				// NOLINTNEXTLINE(modernize-avoid-c-arrays)
-				shared_array_buffer_get_backing_store = unknown_sab_throw<std::shared_ptr<std::byte[]>>;
+				shared_array_buffer_get_backing_store = unknown_sab_throw<std::shared_ptr<data_block::array_type>>;
 				shared_array_buffer_get_byte_length = unknown_sab_throw<std::size_t>;
 			}
 

package/support/host.h.cc

@@ -1,6 +1,8 @@
 export module napi_js:support.host;
+import :environment_fwd;
 import :handle.local_of;
 import std;
+import v8;
 
 namespace js::napi {
 
@@ -13,6 +15,13 @@ auto (*fast_is_null)(napi_env env, napi_value value) -> bool;
 auto (*fast_is_true)(napi_env env, napi_value value) -> bool;
 auto (*fast_is_undefined)(napi_env env, napi_value value) -> bool;
 
+// Isolate access. In the fast case (nodejs) this returns the isolate of the current thread.
+auto (*host_current_isolate)() -> v8::Isolate* = nullptr;
+
+// Element access
+auto (*fast_has_element)(environment_lock_witness lock, napi_value array, std::uint32_t index) -> bool = nullptr;
+auto (*fast_get_element)(environment_lock_witness lock, napi_value array, std::uint32_t index) -> napi_value = nullptr;
+
 // Extended fast functions
 auto has_extended_fast_is_functions = false;
 auto fast_is_array(napi_value value) -> bool;
@@ -32,11 +41,13 @@ auto (*maybe_is_number_int32)(local_of<number_tag> value) -> std::optional<bool>
 auto (*maybe_is_string_latin1)(local_of<string_tag> value) -> std::optional<bool> = nullptr;
 auto (*maybe_is_shared_array_buffer)(napi_env env, local_of<object_tag> value) -> std::optional<bool> = nullptr;
 
+// 'ArrayBuffer' functions
+auto (*array_buffer_get_backing_store)(local_of<array_buffer_tag> buffer) -> std::shared_ptr<data_block::array_type> = nullptr;
+
 // 'SharedArrayBuffer' functions
 auto (*make_shared_array_buffer)(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> local_of<shared_array_buffer_tag> = nullptr;
 auto (*shared_array_buffer_get_byte_length)(local_of<shared_array_buffer_tag> buffer) -> std::size_t = nullptr;
-// NOLINTNEXTLINE(modernize-avoid-c-arrays)
-auto (*shared_array_buffer_get_backing_store)(local_of<shared_array_buffer_tag> buffer) -> std::shared_ptr<std::byte[]> = nullptr;
+auto (*shared_array_buffer_get_backing_store)(local_of<shared_array_buffer_tag> buffer) -> std::shared_ptr<data_block::array_type> = nullptr;
 
 // 'ArrayBufferView' constructors
 auto (*make_sab_data_view)(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> = nullptr;

package/support/initialize.h.cc

@@ -1,4 +1,5 @@
 export module napi_js:initialize;
+import :lock;
 import :value;
 import nodejs;
 import std;
@@ -33,9 +34,10 @@ class napi_js_module final : private detail::initialize_require {
 			// construct environment, set napi instance data w/ finalizer
 			constexpr auto [... indices ] = util::sequence<sizeof...(Args)>;
 			auto& client_environment = environment::make_and_set_environment<Environment>(env, std::get<indices>(std::move(args_))...);
+			auto lock = environment_lock_witness_of<Environment>{environment_lock_witness::make_witness(client_environment), client_environment};
 			// assign export descriptor to napi-constructor namespace object
 			auto exports_local = local_of<dictionary_tag>::from(exports);
-			exports_local->assign(client_environment, std::move(make_exports_)(client_environment));
+			exports_local->assign(lock, std::move(make_exports_)(lock));
 		}
 
 		Make make_exports_;

package/support/lock.cc

@@ -0,0 +1,40 @@
+module;
+#include <cassert>
+module napi_js;
+import std;
+import v8;
+
+namespace js::napi {
+
+// `environment_lock_witness`
+auto environment_lock_witness::make_witness(napi::environment& env) -> environment_lock_witness {
+	auto* isolate = env.isolate();
+	if (isolate == nullptr) {
+		return environment_lock_witness{env, nullptr, {}};
+	} else {
+		return environment_lock_witness{env, isolate, isolate->GetCurrentContext()};
+	}
+}
+
+// `environment_try_catch`
+environment_try_catch::environment_try_catch(environment_lock_witness lock) {
+	if (auto* isolate = lock.isolate(); isolate != nullptr) {
+		try_catch_.emplace(isolate);
+	}
+}
+
+environment_try_catch::~environment_try_catch() {
+	assert(!try_catch_ || !try_catch_->HasCaught());
+}
+
+auto environment_try_catch::take_exception() -> napi_value {
+	if (try_catch_ && try_catch_->HasCaught()) {
+		auto exception = try_catch_->Exception();
+		try_catch_->Reset();
+		return std::bit_cast<napi_value>(exception);
+	} else {
+		throw std::logic_error{"no pending v8 exception"};
+	}
+}
+
+} // namespace js::napi

package/support/lock.h.cc

@@ -0,0 +1,64 @@
+export module napi_js:lock;
+import :environment;
+import nodejs;
+import std;
+import util;
+import v8;
+
+namespace js::napi {
+
+// Environment lock witness. Similar to `iv8::isolate_lock_witness`, this provides some assurance
+// that the environment is locked in this thread. In the "fast" (nodejs) case it also carries the
+// isolate and the current context.
+export class environment_lock_witness {
+	protected:
+		environment_lock_witness(napi_env env, v8::Isolate* isolate, v8::Local<v8::Context> context) :
+				env_{env},
+				isolate_{isolate},
+				context_{context} {}
+
+	public:
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		operator napi_env() const { return env_; }
+		[[nodiscard]] auto isolate() const -> v8::Isolate* { return isolate_; }
+		[[nodiscard]] auto context() const -> v8::Local<v8::Context> { return context_; }
+		[[nodiscard]] static auto make_witness(napi_env env, v8::Isolate* isolate, v8::Local<v8::Context> context) -> environment_lock_witness {
+			return environment_lock_witness{env, isolate, context};
+		}
+		[[nodiscard]] static auto make_witness(napi::environment& env) -> environment_lock_witness;
+
+	private:
+		napi_env env_;
+		v8::Isolate* isolate_;
+		v8::Local<v8::Context> context_;
+};
+
+// Environment lock witness with backing environment reference
+export template <class Environment>
+class environment_lock_witness_of
+		: public util::pointer_facade,
+			public environment_lock_witness {
+	public:
+		environment_lock_witness_of(environment_lock_witness witness, Environment& env) :
+				environment_lock_witness{witness},
+				env_{env} {}
+
+		[[nodiscard]] auto operator*() const -> Environment& { return env_; }
+
+	private:
+		std::reference_wrapper<Environment> env_;
+};
+
+// In the fast case this installs a `v8::TryCatch` which catches exceptions thrown by direct v8
+// operations.
+export class environment_try_catch : util::non_moveable {
+	public:
+		explicit environment_try_catch(environment_lock_witness lock);
+		~environment_try_catch();
+		[[nodiscard]] auto take_exception() -> napi_value;
+
+	private:
+		std::optional<v8::TryCatch> try_catch_;
+};
+
+} // namespace js::napi

package/support/promise.cc

@@ -1,4 +1,5 @@
 export module napi_js:promise;
+import :lock;
 import :value;
 import std;
 
@@ -8,12 +9,14 @@ namespace js::napi {
 template <class Environment, class Dispatch>
 class resolver {
 	public:
-		resolver(Environment& env, napi_deferred deferred, Dispatch dispatch = {}) :
-				env_{env},
+		using lock_type = environment_lock_witness_of<Environment>;
+
+		resolver(const lock_type& lock, napi_deferred deferred, Dispatch dispatch = {}) :
+				env_{lock},
 				deferred_{deferred},
-				scheduler_{env.scheduler()},
+				scheduler_{lock->scheduler()},
 				dispatch_{dispatch} {
-			scheduler_.increment_ref(napi_env{env});
+			scheduler_.increment_ref(napi_env{lock});
 		}
 		resolver(const resolver&) = delete;
 		resolver(resolver&&) = default;
@@ -28,12 +31,12 @@ class resolver {
 
 		// Fulfill using callback supplied to constructor
 		auto operator()(auto&&... args) -> void
-			requires std::invocable<Dispatch&, Environment&, decltype(args)...> {
-			using result_type = std::invoke_result_t<Dispatch&, Environment&, decltype(args)...>;
+			requires std::invocable<Dispatch&, const lock_type&, decltype(args)...> {
+			using result_type = std::invoke_result_t<Dispatch&, const lock_type&, decltype(args)...>;
 			using expected_type = std::expected<result_type, js::error_value>;
 			schedule(
-				[](Environment& environment, auto dispatch, auto&&... args) -> expected_type {
-					return expected_type{std::in_place, std::move(dispatch)(environment, std::forward<decltype(args)>(args)...)};
+				[](const lock_type& lock, auto dispatch, auto&&... args) -> expected_type {
+					return expected_type{std::in_place, std::move(dispatch)(lock, std::forward<decltype(args)>(args)...)};
 				},
 				std::move(dispatch_),
 				std::forward<decltype(args)>(args)...
@@ -46,7 +49,7 @@ class resolver {
 		auto resolve(Type value) noexcept(std::is_nothrow_move_constructible_v<Type>) -> void {
 			using expected_type = std::expected<decltype(value), js::error_value>;
 			schedule(
-				[](Environment& /*env*/, auto value) -> expected_type {
+				[](const lock_type& /*lock*/, auto value) -> expected_type {
 					return expected_type{std::in_place, std::move(value)};
 				},
 				std::move(value)
@@ -57,7 +60,7 @@ class resolver {
 		auto reject(js::error_value error) noexcept -> void {
 			using expected_type = std::expected<std::monostate, js::error_value>;
 			schedule(
-				[](Environment& /*env*/, js::error_value error) -> expected_type {
+				[](const lock_type& /*lock*/, js::error_value error) -> expected_type {
 					return expected_type{std::unexpect, std::move(error)};
 				},
 				std::move(error)
@@ -72,20 +75,24 @@ class resolver {
 				[](napi_env env, napi_value /*nothing*/, napi_deferred deferred, auto operation, auto&&... args) noexcept {
 					auto& environment = napi::environment::unsafe_get_environment_as<Environment>(env);
 					environment.scheduler().decrement_ref(env);
+					auto lock = lock_type{environment_lock_witness::make_witness(environment), environment};
+					auto try_catch = environment_try_catch{lock};
 					try {
-						auto expected = operation(environment, std::forward<decltype(args)>(args)...);
+						auto expected = operation(lock, std::forward<decltype(args)>(args)...);
 						if (expected) {
-							auto value = js::transfer_in_strict<napi_value>(*std::move(expected), environment);
+							auto value = js::transfer_in_strict<napi_value>(*std::move(expected), lock);
 							napi::invoke0(napi_resolve_deferred, env, deferred, value);
 						} else {
-							auto error = js::transfer_in_strict<napi_value>(std::move(expected).error(), environment);
+							auto error = js::transfer_in_strict<napi_value>(std::move(expected).error(), lock);
 							napi::invoke0(napi_reject_deferred, env, deferred, error);
 						}
 					} catch (const napi::pending_error& /*error*/) {
 						auto* exception = napi::invoke(napi_get_and_clear_last_exception, env);
 						napi::invoke0_noexcept(napi_reject_deferred, env, deferred, exception);
+					} catch (const napi::pending_v8_error& /*error*/) {
+						napi::invoke0_noexcept(napi_reject_deferred, env, deferred, try_catch.take_exception());
 					} catch (const js::error& error) {
-						auto exception = js::transfer_in_strict<napi_value>(error, environment);
+						auto exception = js::transfer_in_strict<napi_value>(error, lock);
 						napi::invoke0_noexcept(napi_reject_deferred, env, deferred, exception);
 					}
 				},
@@ -102,19 +109,22 @@ class resolver {
 };
 
 template <class Environment>
-resolver(Environment&, napi_deferred) -> resolver<Environment, std::monostate>;
+resolver(const environment_lock_witness_of<Environment>&, napi_deferred) -> resolver<Environment, std::monostate>;
+
+template <class Environment, class Dispatch>
+resolver(const environment_lock_witness_of<Environment>&, napi_deferred, Dispatch) -> resolver<Environment, Dispatch>;
 
 export template <class Environment>
-auto make_promise(Environment& env, auto... dispatch) {
+auto make_promise(const environment_lock_witness_of<Environment>& lock, auto... dispatch) {
 	// Make nodejs promise & future
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	napi_deferred deferred;
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	napi_value promise;
-	napi::invoke0(napi_create_promise, napi_env{env}, &deferred, &promise);
+	napi::invoke0(napi_create_promise, napi_env{lock}, &deferred, &promise);
 
 	// Make resolve helper
-	auto resolve = resolver{env, deferred, std::move(dispatch)...};
+	auto resolve = resolver{lock, deferred, std::move(dispatch)...};
 
 	// `[ promise, resolver ]`
 	return std::tuple{local_of<promise_tag>::from(promise), std::move(resolve)};

package/transfer/accept.cc

@@ -84,7 +84,7 @@ auto accept_basic_napi_value::operator()(date_tag /*tag*/, visit_holder /*visit*
 // error
 auto accept_basic_napi_value::operator()(error_tag /*tag*/, visit_holder visit, const js::error_value& subject) const
 	-> js::referenceable_value<local_of<error_tag>> {
-	auto* message = napi_value{js::transfer_in<local_of<string_tag>>(subject.message(), environment())};
+	auto* message = napi_value{js::transfer_in<local_of<string_tag>>(subject.message(), lock())};
 	auto* error = [ & ] -> napi_value {
 		switch (subject.name()) {
 			default:

package/transfer/accept.h.cc

@@ -1,4 +1,5 @@
 export module napi_js:accept;
+import :lock;
 import :utility;
 import :value;
 import std;
@@ -23,7 +24,7 @@ struct reaccept_napi_value {
 // Napi acceptor which does not need specialized environment type
 struct accept_basic_napi_value {
 	public:
-		explicit accept_basic_napi_value(auto* /*transfer*/, auto& env) : env_{env} {}
+		explicit accept_basic_napi_value(auto* /*transfer*/, environment_lock_witness lock) : lock_{lock} {}
 
 		// Declare reference provider
 		using accept_reference_type = reaccept_napi_value;
@@ -140,35 +141,36 @@ struct accept_basic_napi_value {
 			// TODO: We accept the nested `buffer` property as a `data_block` which means `make` needs to
 			// invoke `is_arraybuffer` on it again even though we knew what it was a moment ago.
 			auto buffer = local_of<data_block_tag>::from(visit(std::forward<decltype(subject)>(subject).buffer(), self));
-			return js::referenceable_value{local_of<Tag>::make(self.environment(), buffer, byte_offset, length)};
+			return js::referenceable_value{local_of<Tag>::make(self.lock(), buffer, byte_offset, length)};
 		}
 
 		// extras
-		[[nodiscard]] auto environment() const -> environment& { return env_; }
-		explicit operator napi_env() const { return napi_env{env_.get()}; }
+		[[nodiscard]] auto lock() const -> environment_lock_witness { return lock_; }
+		explicit operator napi_env() const { return napi_env{lock_}; }
 
 	private:
-		std::reference_wrapper<napi::environment> env_;
+		environment_lock_witness lock_;
 };
 
 // Generic napi acceptor which accepts all value types.
-template <class Environment>
+template <class Lock>
 struct accept_napi_value;
 
 template <class Meta>
 using accept_napi_value_with = accept_napi_value<typename Meta::accept_context_type>;
 
-template <class Environment>
+template <class Lock>
 struct accept_napi_value : accept_basic_napi_value {
 	public:
-		explicit accept_napi_value(auto* transfer, auto& env) :
-				accept_basic_napi_value{transfer, env} {}
+		explicit accept_napi_value(auto* transfer, const Lock& lock) :
+				accept_basic_napi_value{transfer, lock},
+				lock_{lock} {}
 		using accept_basic_napi_value::operator();
 
 		// function
 		template <class Callback>
 		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, js::free_function<Callback> subject) const -> local_of<function_tag> {
-			return local_of<function_tag>::make(environment(), std::forward<decltype(subject)>(subject));
+			return local_of<function_tag>::make(lock(), std::forward<decltype(subject)>(subject));
 		}
 
 		// vectors
@@ -298,11 +300,12 @@ struct accept_napi_value : accept_basic_napi_value {
 		}
 
 		// extras
-		[[nodiscard]] auto environment() const -> Environment& {
-			return static_cast<Environment&>(accept_basic_napi_value::environment());
-		}
+		[[nodiscard]] auto lock() const -> const Lock& { return lock_; }
 
 		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+
+	private:
+		Lock lock_;
 };
 
 // Forward `value_of<T>`
@@ -329,8 +332,8 @@ struct object_assign_delegate {
 		local_of<object_tag> object_;
 };
 
-auto local_for_object::assign(auto_environment auto& env, auto source) const -> void {
-	js::transfer_in<object_assign_delegate>(std::move(source), env, object_assign_delegate{local_of{*this}});
+auto local_for_object::assign(const auto& lock, auto source) const -> void {
+	js::transfer_in<object_assign_delegate>(std::move(source), lock, object_assign_delegate{local_of{*this}});
 }
 
 } // namespace js::napi
@@ -349,7 +352,7 @@ struct accept<Meta, napi_value> : napi::accept_napi_value_with<Meta> {
 
 // Tagged `local_of<T>` acceptor
 template <>
-struct accept_property_subject<napi::local_of<value_tag>> : std::type_identity<napi_value> {};
+struct accept_property_subject<napi::local_of<>> : std::type_identity<napi_value> {};
 
 template <class Meta, class Tag>
 struct accept<Meta, napi::local_of<Tag>> : napi::accept_napi_value_with<Meta> {
@@ -387,8 +390,8 @@ struct accept_property_value<Meta, Key, Type, napi_value> {
 template <class Meta>
 struct accept<Meta, napi::object_assign_delegate> {
 	public:
-		accept(auto* transfer, auto& env, napi::object_assign_delegate object) :
-				accept_{transfer, env},
+		accept(auto* transfer, const auto& lock, napi::object_assign_delegate object) :
+				accept_{transfer, lock},
 				object_{object} {}
 
 		template <std::size_t Size>