@auto_js/napi 0.0.11 → 0.0.12

package/CMakeLists.txt

@@ -20,6 +20,7 @@ target_sources(${napi_js}
 		support/environment.cc
 		support/host.cc
 		support/initialize.cc
+		support/lock.cc
 		transfer/accept.cc
 		value/array_buffer.cc
 		value/array.cc
@@ -35,6 +36,7 @@ target_sources(${napi_js}
 		api/invoke.cc
 		api/napi_scheduler.h.cc
 		api/threadsafe_function.cc
+		api/unmaybe.cc
 		api/uv_dlib.h.cc
 		api/uv_handle.cc
 		api/uv_scheduler.h.cc
@@ -51,10 +53,12 @@ target_sources(${napi_js}
 		support/error_scope.cc
 		support/host.h.cc
 		support/initialize.h.cc
+		support/lock.h.cc
 		support/promise.cc
 		support/string_table.cc
 		support/utility.cc
 		transfer/accept.h.cc
+		transfer/transfer_list.cc
 		transfer/visit.cc
 		value/array_buffer.h.cc
 		value/array.h.cc

package/_module.cc

@@ -11,11 +11,13 @@ export import :handle.local_of;
 export import :handle.types;
 export import :handle.value_of;
 export import :initialize;
+export import :lock;
 export import :promise;
 export import :reference;
 export import :remote;
 export import :string_table;
 export import :support.host;
+export import :transfer_list;
 export import :utility;
 export import :value;
 export import :visit;

package/api/api.cc

@@ -8,6 +8,7 @@ export import :api.handle_scope;
 export import :api.invoke;
 export import :api.napi_scheduler;
 export import :api.threadsafe_function;
+export import :api.unmaybe;
 export import :api.uv_dlib;
 export import :api.uv_handle;
 export import :api.uv_scheduler;

package/api/callback_info.cc

@@ -35,6 +35,6 @@ export struct callback_info : util::non_copyable {
 
 // Common declaration for `napi_type_tag` by type
 export template <class Type>
-constexpr auto type_tag_for = napi_type_tag{.lower = util::type_hash<Type>, .upper = 0};
+constexpr auto type_tag_for = napi_type_tag{.lower = util::type_hash64<Type>, .upper = 0};
 
 } // namespace js::napi

package/api/napi_scheduler.cc

@@ -32,8 +32,29 @@ auto napi_scheduler::increment_ref(node_api_basic_env env) const -> void {
 	}
 }
 
+auto napi_scheduler::make_ref(node_api_basic_env env) const -> ref {
+	return ref{env, *this};
+}
+
 auto napi_scheduler::storage::operator()(napi_env env, napi_value value, task_type& task) noexcept -> void {
 	task(env, value);
 }
 
+// napi_scheduler::ref
+napi_scheduler::ref::ref(node_api_basic_env env, napi_scheduler scheduler) :
+		scheduler_{std::move(scheduler)} {
+	scheduler_.increment_ref(env);
+}
+
+napi_scheduler::ref::~ref() {
+	if (scheduler_) {
+		scheduler_(
+			[](napi_env env, napi_value /*nothing*/, const napi_scheduler& scheduler) noexcept -> void {
+				scheduler.decrement_ref(env);
+			},
+			scheduler_
+		);
+	}
+}
+
 } // namespace js::napi

package/api/napi_scheduler.h.cc

@@ -14,6 +14,8 @@ export class napi_scheduler {
 		using threadsafe_function_type = threadsafe_function_of<storage, task_type>;
 
 	public:
+		class ref;
+
 		napi_scheduler() = default;
 		explicit napi_scheduler(napi_env env);
 		auto operator()(auto task, auto&&... args) const noexcept -> bool;
@@ -21,6 +23,7 @@ export class napi_scheduler {
 		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;
+		auto make_ref(node_api_basic_env env) const -> ref;
 
 	private:
 		struct storage {
@@ -32,6 +35,19 @@ export class napi_scheduler {
 		threadsafe_function_of<storage, task_type> fn_;
 };
 
+// Reference to a scheduler which keeps the napi event loop alive. Can be passed between threads,
+// the decrement_ref operation is scheduled.
+class napi_scheduler::ref {
+	public:
+		ref(node_api_basic_env env, napi_scheduler scheduler);
+		ref(ref&&) noexcept = default;
+		~ref();
+		auto operator*() const -> const napi_scheduler& { return scheduler_; }
+
+	private:
+		napi_scheduler scheduler_;
+};
+
 // An environment with an uv loop and scheduler
 export class napi_schedulable {
 	public:

package/api/threadsafe_function.cc

@@ -22,8 +22,8 @@ class threadsafe_function_of : util::non_copyable {
 		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 ref(node_api_basic_env env) const noexcept -> void;
+		auto unref(node_api_basic_env env) const noexcept -> void;
 		auto operator()(Message message) const noexcept -> bool;
 		auto operator*() const noexcept -> Context& { return get(); }
 		explicit operator bool() const noexcept { return tsfn_ != nullptr; }
@@ -103,13 +103,13 @@ auto threadsafe_function_of<Context, Message>::close(close_callback callback) no
 }
 
 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_);
+auto threadsafe_function_of<Context, Message>::ref(node_api_basic_env env) const noexcept -> void {
+	napi::invoke0_noexcept(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_);
+auto threadsafe_function_of<Context, Message>::unref(node_api_basic_env env) const noexcept -> void {
+	napi::invoke0_noexcept(napi_unref_threadsafe_function, env, tsfn_);
 }
 
 template <class Context, class Message>

package/api/unmaybe.cc

@@ -0,0 +1,36 @@
+export module napi_js:api.unmaybe;
+import std;
+import v8;
+
+namespace js::napi {
+
+// Thrown from `unmaybe` to indicate that a direct v8 operation failed and there is an exception
+// waiting in the `v8::TryCatch` of the enclosing `environment_try_catch`.
+export class pending_v8_error : public std::exception {
+	public:
+		[[nodiscard]] auto what() const noexcept -> const char* final { return "[pending v8 error]"; }
+};
+
+// Unwrap a `MaybeLocal`, or throw `napi::pending_v8_error` on failure
+export template <class Type>
+auto unmaybe(v8::MaybeLocal<Type> maybe_value) -> v8::Local<Type> {
+	v8::Local<Type> value;
+	if (maybe_value.ToLocal(&value)) {
+		return value;
+	} else {
+		throw napi::pending_v8_error{};
+	}
+}
+
+// Unwrap a `Maybe`, or throw `napi::pending_v8_error` on failure
+export template <class Type>
+auto unmaybe(v8::Maybe<Type> maybe) -> Type {
+	Type value;
+	if (maybe.To(&value)) {
+		return value;
+	} else {
+		throw napi::pending_v8_error{};
+	}
+}
+
+} // namespace js::napi

package/handle/remote.cc

@@ -1,5 +1,6 @@
 export module napi_js:remote;
 import :environment;
+import :lock;
 import :reference;
 import std;
 import util;
@@ -24,14 +25,16 @@ class remote : protected reference_handle {
 		using unique_remote = std::unique_ptr<remote, util::function_constant<expire>>;
 
 		remote() = default;
-		remote(private_constructor /*private*/, const environment& env, local_of<Tag> value, napi_scheduler scheduler) :
-				reference_handle{napi_env{env}, napi_value{value}},
+		remote(private_constructor /*private*/, environment_lock_witness lock, local_of<Tag> value, napi_scheduler scheduler) :
+				reference_handle{napi_env{lock}, napi_value{value}},
 				scheduler_{std::move(scheduler)} {}
 
-		auto deref(const environment& env) const -> local_of<Tag>;
+		auto deref(environment_lock_witness lock) const -> local_of<Tag>;
 
-		static auto make_shared(remote_handle_environment auto& env, local_of<Tag> value) -> std::shared_ptr<remote>;
-		static auto make_unique(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote;
+		template <remote_handle_environment Environment>
+		static auto make_shared(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> std::shared_ptr<remote>;
+		template <remote_handle_environment Environment>
+		static auto make_unique(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> unique_remote;
 
 	private:
 		napi_scheduler scheduler_;
@@ -44,14 +47,14 @@ using shared_remote = std::shared_ptr<remote<Type>>;
 export template <class Type>
 using unique_remote = remote<Type>::unique_remote;
 
-export template <class Tag>
-auto make_shared_remote(remote_handle_environment auto& env, local_of<Tag> value) -> shared_remote<Tag> {
-	return remote<Tag>::make_shared(env, value);
+export template <remote_handle_environment Environment, class Tag>
+auto make_shared_remote(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> shared_remote<Tag> {
+	return remote<Tag>::make_shared(lock, value);
 }
 
-export template <class Tag>
-auto make_unique_remote(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote<Tag> {
-	return remote<Tag>::make_unique(env, value);
+export template <remote_handle_environment Environment, class Tag>
+auto make_unique_remote(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> unique_remote<Tag> {
+	return remote<Tag>::make_unique(lock, value);
 }
 
 // ---
@@ -68,18 +71,20 @@ auto remote<Tag>::expire(remote* ptr) -> void {
 }
 
 template <class Tag>
-auto remote<Tag>::deref(const environment& env) const -> local_of<Tag> {
-	return local_of<Tag>::from(get_value(napi_env{env}));
+auto remote<Tag>::deref(environment_lock_witness lock) const -> local_of<Tag> {
+	return local_of<Tag>::from(get_value(napi_env{lock}));
 }
 
 template <class Tag>
-auto remote<Tag>::make_shared(remote_handle_environment auto& env, local_of<Tag> value) -> std::shared_ptr<remote> {
-	return std::shared_ptr<remote>{new remote{private_constructor{}, env, value, env.scheduler()}, expire};
+template <remote_handle_environment Environment>
+auto remote<Tag>::make_shared(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> std::shared_ptr<remote> {
+	return std::shared_ptr<remote>{new remote{private_constructor{}, lock, value, lock->scheduler()}, expire};
 }
 
 template <class Tag>
-auto remote<Tag>::make_unique(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote {
-	return unique_remote{new remote{private_constructor{}, env, value, env.scheduler()}};
+template <remote_handle_environment Environment>
+auto remote<Tag>::make_unique(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> unique_remote {
+	return unique_remote{new remote{private_constructor{}, lock, value, lock->scheduler()}};
 }
 
 } // namespace js::napi

package/handle/value.cc

@@ -1,7 +1,9 @@
 export module napi_js:handle.value_of;
 import :handle.types;
+import :lock;
 import nodejs;
 import std;
+import v8;
 
 namespace js::napi {
 
@@ -33,7 +35,7 @@ class value_next : public value_of<typename Tag::tag_type> {
 };
 
 // Member & method implementation for value semantics objects. It holds the type-erased environment
-// and is used for common operations like casting & iteration.
+// lock witness and is used for common operations like casting & iteration.
 template <class Tag>
 class value_of : public value_specialization<Tag>::type {
 	public:
@@ -46,14 +48,19 @@ template <>
 class value_of<void> : public runtime_handle {
 	protected:
 		value_of() = default;
-		value_of(napi_env env, napi_value value) :
+		value_of(environment_lock_witness lock, napi_value value) :
 				runtime_handle{value},
-				env_{env} {}
+				env_{lock},
+				isolate_{lock.isolate()},
+				context_{lock.context()} {}
 
 		[[nodiscard]] auto env() const -> napi_env { return env_; }
+		[[nodiscard]] auto lock() const -> environment_lock_witness { return environment_lock_witness::make_witness(env_, isolate_, context_); }
 
 	private:
 		napi_env env_{};
+		v8::Isolate* isolate_{};
+		v8::Local<v8::Context> context_;
 };
 
 // Deduction guide
@@ -108,6 +115,10 @@ template <>
 struct value_specialization<record_tag>
 		: std::type_identity<class value_for_record> {};
 
+template <>
+struct value_specialization<list_tag>
+		: std::type_identity<class value_for_list> {};
+
 template <>
 struct value_specialization<data_block_tag>
 		: std::type_identity<class value_for_data_block> {};

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "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.11",
-    "@auto_js/napi_exports": "^0.0.10",
-    "@auto_js/v8_exports": "^0.0.8"
+    "@auto_js/js": "^0.0.12",
+    "@auto_js/napi_exports": "^0.0.11",
+    "@auto_js/v8_exports": "^0.0.9"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -1,6 +1,7 @@
 export module napi_js:callback;
 export import :callback_storage;
 import :error_scope;
+import :lock;
 import std;
 import util;
 
@@ -10,15 +11,15 @@ namespace js::napi {
 // 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 = value_of{env, local_of<object_tag>::from(coerced_this_arg)};
+constexpr auto unwrap_member_this = [](environment_lock_witness lock, napi_value this_arg) noexcept -> std::optional<tagged_external<Type>> {
+	return napi::invoke_maybe(napi_coerce_to_object, napi_env{lock}, this_arg)
+		.and_then([ & ](napi_value coerced_this_arg) -> std::optional<tagged_external<Type>> {
+			auto as_object = value_of{lock, local_of<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");
+				napi::invoke0(napi_throw_type_error, napi_env{lock}, nullptr, "Invalid object type");
 				return std::nullopt;
 			} else {
 				return tagged_external{*unwrapped};
@@ -32,6 +33,7 @@ using internal_constructor = util::function_ref<auto(napi_value)->napi_value>;
 // Make callback for plain free function
 template <auto_environment Environment>
 constexpr auto make_free_function(auto function) {
+	using lock_type = environment_lock_witness_of<Environment>;
 	constexpr auto make_with_try_catch =
 		[]<class Env, class... Args, bool Nx, class Result>(
 			std::type_identity<auto(Env, Args...) noexcept(Nx)->Result> /*signature*/,
@@ -39,18 +41,18 @@ constexpr auto make_free_function(auto function) {
 		) -> 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 {
+			[](callback_type& callback, const lock_type& lock, const callback_info& info) noexcept(Nx) -> napi_value {
+				return invoke_internal_error_scope(lock, [ & ] -> 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<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
+								std::forward_as_tuple(lock),
+								js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), lock)
 							)
 						);
 					}};
-					return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+					return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), lock);
 				});
 			},
 			std::move(callback),
@@ -64,17 +66,17 @@ constexpr auto make_free_function(auto function) {
 		static_assert(false, "untested");
 		using callback_type = decltype(callback);
 		return util::bind{
-			[](callback_type& callback, Environment& env, const callback_info& /*info*/) noexcept -> napi_value {
+			[](callback_type& callback, const lock_type& lock, const callback_info& /*info*/) noexcept -> napi_value {
 				auto run = util::regular_return{[ & ] -> decltype(auto) {
-					return callback(env);
+					return callback(lock);
 				}};
-				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), lock);
 			},
 			std::move(callback),
 		};
 	};
 
-	auto callback = js::functional::thunk_free_function<Environment&>(std::move(function));
+	auto callback = js::functional::thunk_free_function<const lock_type&>(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));
 }
@@ -82,22 +84,23 @@ constexpr auto make_free_function(auto function) {
 // Make callback for constructor invocations
 template <auto_environment Environment, class Type>
 constexpr auto make_constructor_function(auto constructor) {
+	using lock_type = environment_lock_witness_of<Environment>;
 	// 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 [](const lock_type& lock, const callback_info& /*info*/) -> napi_value {
+				napi::invoke0(napi_throw_type_error, napi_env{lock}, 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 {
+			constexpr auto wrap = [](auto instance, const lock_type& lock, 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>);
+				napi::invoke0(napi_type_tag_object, napi_env{lock}, info.this_arg(), &type_tag_for<Type>);
 				// Wrap w/ finalizer
 				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);
+					napi::invoke0(napi_wrap, napi_env{lock}, info.this_arg(), instance, finalize, hint, nullptr);
 					return info.this_arg();
 				});
 			};
@@ -111,16 +114,16 @@ constexpr auto make_constructor_function(auto constructor) {
 				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 {
+					[](callback_type& callback, wrap_type& wrap, const lock_type& lock, const callback_info& info) noexcept(Nx) -> napi_value {
+						return invoke_internal_error_scope(lock, [ & ] -> napi_value {
 							auto instance = std::apply(
 								callback,
 								std::tuple_cat(
-									std::forward_as_tuple(env, local_of<object_tag>::from(info.this_arg())),
-									js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
+									std::forward_as_tuple(lock, local_of<object_tag>::from(info.this_arg())),
+									js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), lock)
 								)
 							);
-							return wrap(std::move(instance));
+							return wrap(std::move(instance), lock, info);
 						});
 					},
 					std::move(callback),
@@ -135,14 +138,14 @@ constexpr auto make_constructor_function(auto constructor) {
 				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, local_of<object_tag>::from(info.this_arg())));
+					[](callback_type& callback, const lock_type& lock, const callback_info& info) noexcept -> napi_value {
+						return wrap(callback(lock, local_of<object_tag>::from(info.this_arg())));
 					},
 					std::move(callback),
 				};
 			};
 
-			auto callback = js::functional::thunk_free_function<Environment&>(std::move(constructor));
+			auto callback = js::functional::thunk_free_function<const lock_type&>(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};
@@ -156,18 +159,18 @@ constexpr auto make_constructor_function(auto constructor) {
 	// 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 {
+		[](runtime_constructor_type& constructor, const lock_type& lock, 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 (napi::invoke(napi_coerce_to_bool, napi_env{lock}, arg0)) {
+							auto* as_object = napi::invoke(napi_coerce_to_object, napi_env{lock}, arg0);
+							auto has_tag = napi::invoke(napi_check_object_type_tag, napi_env{lock}, as_object, &type_tag_for<internal_constructor>);
 							if (has_tag) {
-								void* addr = napi::invoke(napi_get_value_external, napi_env{env}, as_object);
+								void* addr = napi::invoke(napi_get_value_external, napi_env{lock}, as_object);
 								return static_cast<internal_constructor*>(addr);
 							}
 						}
@@ -181,13 +184,13 @@ constexpr auto make_constructor_function(auto constructor) {
 				}
 				if (*maybe_constructor != nullptr) {
 					const auto& constructor = **maybe_constructor;
-					return invoke_internal_error_scope(env, [ & ] -> napi_value {
+					return invoke_internal_error_scope(lock, [ & ] -> napi_value {
 						return constructor(info.this_arg());
 					});
 				}
 			}
 			// Invoke normal constructor
-			return constructor(env, info);
+			return constructor(lock, info);
 		},
 		std::move(runtime_constructor),
 	};
@@ -196,6 +199,7 @@ constexpr auto make_constructor_function(auto constructor) {
 // Make callback for method invocations
 template <auto_environment Environment, class Type, class Method>
 constexpr auto make_member_function(Method method) {
+	using lock_type = environment_lock_witness_of<Environment>;
 	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*/,
@@ -203,22 +207,22 @@ constexpr auto make_member_function(Method method) {
 		) -> 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 {
+			[](callback_type& callback, const lock_type& lock, const callback_info& info) noexcept(Nx) -> napi_value {
+				return invoke_internal_error_scope(lock, [ & ] -> napi_value {
+					auto maybe_that = unwrap_member_this<Type>(lock, info.this_arg());
+					if (!maybe_that) {
+						return nullptr;
+					}
 					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<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
+								std::forward_as_tuple(**maybe_that, lock),
+								js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), lock)
 							)
 						);
 					}};
-					return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+					return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), lock);
 				});
 			},
 			std::move(callback),
@@ -232,21 +236,21 @@ constexpr auto make_member_function(Method method) {
 		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());
+			[](callback_type& callback, const lock_type& lock, const callback_info& info) noexcept -> napi_value {
+				auto maybe_that = unwrap_member_this<Type>(lock, info.this_arg());
 				if (!maybe_that) {
 					return nullptr;
 				}
 				auto run = util::regular_return{[ & ] -> decltype(auto) {
-					return callback(**maybe_that, env);
+					return callback(**maybe_that, lock);
 				}};
-				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
+				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), lock);
 			},
 			std::move(callback),
 		};
 	};
 
-	auto callback = js::functional::thunk_member_function<Environment&>(std::move(method));
+	auto callback = js::functional::thunk_member_function<const lock_type&>(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));
 };

package/support/callback_storage.cc

@@ -1,6 +1,7 @@
 export module napi_js:callback_storage;
 import :api;
 import :environment_fwd;
+import :lock;
 import std;
 
 namespace js::napi {
@@ -15,8 +16,10 @@ thread_local Environment* callback_env_local = nullptr;
 // 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) {
+auto make_callback_storage(const environment_lock_witness_of<Environment>& lock, std::invocable<const environment_lock_witness_of<Environment>&, const callback_info&> auto function) {
 	using function_type = decltype(function);
+	using lock_type = environment_lock_witness_of<Environment>;
+	auto& env = *lock;
 	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.
@@ -25,7 +28,8 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 				if (args) {
 					auto invoke = function_type{};
 					auto& env = *static_cast<Environment*>(args.data());
-					return invoke(env, args);
+					auto lock = lock_type{environment_lock_witness::make_witness(env), env};
+					return invoke(lock, args);
 				} else {
 					return {};
 				}
@@ -42,7 +46,8 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 					auto* data = args.data();
 					auto invoke = util::bit_truncation_cast<function_type>(data);
 					auto& env = *callback_env_local<Environment>;
-					return invoke(env, args);
+					auto lock = lock_type{environment_lock_witness::make_witness(env), env};
+					return invoke(lock, args);
 				} else {
 					return {};
 				}
@@ -59,7 +64,9 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 			const auto args = callback_info{nenv, info};
 			if (args) {
 				auto& state = *static_cast<pair_type*>(args.data());
-				return state.second(*state.first, args);
+				auto& env = *state.first;
+				auto lock = lock_type{environment_lock_witness::make_witness(env), env};
+				return state.second(lock, args);
 			} else {
 				return {};
 			}