@auto_js/napi 0.0.10 → 0.0.12

package/value/array_buffer.cc

@@ -5,6 +5,10 @@ import v8;
 namespace js::napi {
 
 // `value_for_data_block`
+auto value_for_data_block::detach() const -> void {
+	napi::invoke0(napi_detach_arraybuffer, env(), napi_value{*this});
+}
+
 value_for_data_block::operator std::span<std::byte>() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	void* bytes;
@@ -27,12 +31,12 @@ value_for_shared_array_buffer::operator js::shared_array_buffer() const {
 }
 
 // `local_for_typed_array`
-auto local_for_typed_array::make(const environment& env, napi_typedarray_type type_tag, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag> {
-	return local_of<typed_array_tag>::from(napi::invoke(napi_create_typedarray, napi_env{env}, type_tag, length, napi_value{buffer}, byte_offset));
+auto local_for_typed_array::make(environment_lock_witness lock, napi_typedarray_type type_tag, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag> {
+	return local_of<typed_array_tag>::from(napi::invoke(napi_create_typedarray, napi_env{lock}, type_tag, length, napi_value{buffer}, byte_offset));
 }
 
 // `value_for_typed_array`
-auto value_for_typed_array::make_bound(const environment& env, local_of<typed_array_tag> typed_array) -> any_value_typed_array {
+auto value_for_typed_array::make_bound(environment_lock_witness lock, local_of<typed_array_tag> typed_array) -> any_value_typed_array {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	napi_typedarray_type type_tag;
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -41,9 +45,9 @@ auto value_for_typed_array::make_bound(const environment& env, local_of<typed_ar
 	std::size_t length;
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	std::size_t byte_offset;
-	napi::invoke0(napi_get_typedarray_info, env, napi_value{typed_array}, &type_tag, &length, nullptr, &array_buffer, &byte_offset);
+	napi::invoke0(napi_get_typedarray_info, napi_env{lock}, napi_value{typed_array}, &type_tag, &length, nullptr, &array_buffer, &byte_offset);
 	const auto make = [ & ]<class Tag>(Tag /*tag*/) -> any_value_typed_array {
-		return value_of<Tag>{env, local_of<Tag>::from(typed_array), std::tuple{local_of<data_block_tag>::from(array_buffer), byte_offset, length}};
+		return value_of<Tag>{lock, local_of<Tag>::from(typed_array), std::tuple{local_of<data_block_tag>::from(array_buffer), byte_offset, length}};
 	};
 	switch (type_tag) {
 		case napi_bigint64_array: return make(typed_array_tag_of<std::int64_t>{});
@@ -63,26 +67,26 @@ auto value_for_typed_array::make_bound(const environment& env, local_of<typed_ar
 }
 
 // `local_for_data_view`
-auto local_for_data_view::make(const environment& env, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
-	if (napi::invoke(napi_is_arraybuffer, napi_env{env}, buffer)) {
-		return make(env, local_of<array_buffer_tag>::from(buffer), byte_offset, length);
+auto local_for_data_view::make(environment_lock_witness lock, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
+	if (napi::invoke(napi_is_arraybuffer, napi_env{lock}, buffer)) {
+		return make(lock, local_of<array_buffer_tag>::from(buffer), byte_offset, length);
 	} else {
-		return make(env, local_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
+		return make(lock, local_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
 	}
 }
 
-auto local_for_data_view::make(const environment& env, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
-	return local_of<data_view_tag>::from(napi::invoke(napi_create_dataview, napi_env{env}, length, napi_value{buffer}, byte_offset));
+auto local_for_data_view::make(environment_lock_witness lock, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
+	return local_of<data_view_tag>::from(napi::invoke(napi_create_dataview, napi_env{lock}, length, napi_value{buffer}, byte_offset));
 }
 
-auto local_for_data_view::make(const environment& /*env*/, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
+auto local_for_data_view::make(environment_lock_witness /*lock*/, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag> {
 	return make_sab_data_view(buffer, byte_offset, length);
 }
 
 // `value_for_data_view`
-value_for_data_view::value_for_data_view(napi_env env, local_of<data_view_tag> data_view) :
+value_for_data_view::value_for_data_view(environment_lock_witness lock, local_of<data_view_tag> data_view) :
 		value_next{
-			env,
+			lock,
 			data_view,
 			[ & ] -> auto {
 				// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -91,7 +95,7 @@ value_for_data_view::value_for_data_view(napi_env env, local_of<data_view_tag> d
 				std::size_t length;
 				// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 				std::size_t byte_offset;
-				napi::invoke0(napi_get_dataview_info, env, napi_value{data_view}, &length, nullptr, &array_buffer, &byte_offset);
+				napi::invoke0(napi_get_dataview_info, napi_env{lock}, napi_value{data_view}, &length, nullptr, &array_buffer, &byte_offset);
 				return std::tuple{local_of<data_block_tag>::from(array_buffer), byte_offset, length};
 			}(),
 		} {}

package/value/array_buffer.h.cc

@@ -1,5 +1,6 @@
 export module napi_js:array_buffer;
 import :object;
+import :support.host;
 import std;
 import v8;
 
@@ -11,6 +12,7 @@ class value_for_data_block : public value_next<data_block_tag> {
 		using value_next<data_block_tag>::value_next;
 		[[nodiscard]] constexpr auto byte_length() const -> std::size_t { return std::span<std::byte>{*this}.size(); }
 		[[nodiscard]] constexpr auto data() const -> const std::byte* { return std::span<std::byte>{*this}.data(); }
+		auto detach() const -> void;
 		explicit operator std::span<std::byte>() const;
 };
 
@@ -32,11 +34,11 @@ class value_for_shared_array_buffer : public value_next<shared_array_buffer_tag>
 class value_for_array_buffer_view : public value_next<array_buffer_view_tag> {
 	protected:
 		value_for_array_buffer_view(
-			napi_env env,
+			environment_lock_witness lock,
 			local_of<array_buffer_view_tag> typed_array,
 			std::tuple<local_of<data_block_tag>, std::size_t, std::size_t> array_buffer_info
 		) :
-				value_next<array_buffer_view_tag>{env, typed_array},
+				value_next<array_buffer_view_tag>{lock, typed_array},
 				array_buffer_{std::get<0>(array_buffer_info)},
 				byte_offset_{std::get<1>(array_buffer_info)},
 				length_{std::get<2>(array_buffer_info)} {}
@@ -55,8 +57,8 @@ class value_for_array_buffer_view : public value_next<array_buffer_view_tag> {
 // `TypedArray`
 class local_for_typed_array : public local_next<typed_array_tag> {
 	protected:
-		static auto make(const environment& env, napi_typedarray_type type, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag>;
-		static auto make(const environment& env, napi_typedarray_type type, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag>;
+		static auto make(environment_lock_witness lock, napi_typedarray_type type, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag>;
+		static auto make(environment_lock_witness lock, napi_typedarray_type type, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag>;
 };
 
 class value_for_typed_array : public value_next<typed_array_tag> {
@@ -76,7 +78,7 @@ class value_for_typed_array : public value_next<typed_array_tag> {
 			value_of<typed_array_tag_of<std::uint64_t>>,
 			value_of<typed_array_tag_of<std::uint8_t>>>;
 
-		static auto make_bound(const environment& env, local_of<typed_array_tag> typed_array) -> any_value_typed_array;
+		static auto make_bound(environment_lock_witness lock, local_of<typed_array_tag> typed_array) -> any_value_typed_array;
 };
 
 template <class Type>
@@ -84,15 +86,15 @@ class local_for_typed_array_of : public local_next<typed_array_tag_of<Type>> {
 	public:
 		using local_next<typed_array_tag_of<Type>>::local_next;
 
-		static auto make(const environment& env, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
-			if (napi::invoke(napi_is_arraybuffer, napi_env{env}, buffer)) {
-				return make(env, local_of<array_buffer_tag>::from(buffer), byte_offset, length);
+		static auto make(environment_lock_witness lock, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
+			if (napi::invoke(napi_is_arraybuffer, napi_env{lock}, buffer)) {
+				return make(lock, local_of<array_buffer_tag>::from(buffer), byte_offset, length);
 			} else {
-				return make(env, local_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
+				return make(lock, local_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
 			}
 		}
 
-		static auto make(const environment& env, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
+		static auto make(environment_lock_witness lock, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
 			constexpr auto type_tag = util::overloaded{
 				[](std::type_identity<double>) -> napi_typedarray_type { return napi_float64_array; },
 				[](std::type_identity<float>) -> napi_typedarray_type { return napi_float32_array; },
@@ -107,11 +109,11 @@ class local_for_typed_array_of : public local_next<typed_array_tag_of<Type>> {
 				[](std::type_identity<std::uint64_t>) -> napi_typedarray_type { return napi_biguint64_array; },
 				[](std::type_identity<std::uint8_t>) -> napi_typedarray_type { return napi_uint8_array; },
 			}(type<Type>);
-			return local_of<typed_array_tag_of<Type>>::from(local_for_typed_array::make(env, type_tag, buffer, byte_offset, length));
+			return local_of<typed_array_tag_of<Type>>::from(local_for_typed_array::make(lock, type_tag, buffer, byte_offset, length));
 		}
 
 		// napi doesn't provide a way to make a typed array view on a shared array buffer
-		static auto make(const environment& /*env*/, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
+		static auto make(environment_lock_witness /*lock*/, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
 			return make_sab_typed_array_of<Type>(buffer, byte_offset, length);
 		}
 };
@@ -127,14 +129,14 @@ class local_for_data_view : public local_next<data_view_tag> {
 	public:
 		using local_next<data_view_tag>::local_next;
 
-		static auto make(const environment& env, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
-		static auto make(const environment& env, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
-		static auto make(const environment& env, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
+		static auto make(environment_lock_witness lock, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
+		static auto make(environment_lock_witness lock, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
+		static auto make(environment_lock_witness lock, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
 };
 
 class value_for_data_view : public value_next<data_view_tag> {
 	public:
-		value_for_data_view(napi_env env, local_of<data_view_tag> data_view);
+		value_for_data_view(environment_lock_witness lock, local_of<data_view_tag> data_view);
 };
 
 } // namespace js::napi

package/value/class.cc

@@ -8,7 +8,7 @@ namespace js::napi {
 
 template <class Type>
 template <class... Args>
-auto local_for_class_of<Type>::construct(auto& env, Args&&... args) const -> local_of<object_tag>
+auto local_for_class_of<Type>::construct(const auto& lock, Args&&... args) const -> local_of<object_tag>
 	requires std::constructible_from<Type, Args...> {
 	// NOLINTNEXTLINE(readability-simplify-boolean-expr)
 	if (false) {
@@ -16,33 +16,33 @@ auto local_for_class_of<Type>::construct(auto& env, Args&&... args) const -> loc
 		std::ignore = std::tuple<std::remove_cvref_t<Args>...>{std::forward<Args>(args)...};
 	}
 	// NOLINTNEXTLINE(bugprone-use-after-move)
-	return runtime_construct(env, std::forward_as_tuple(std::forward<Args>(args)...), std::tuple{});
+	return runtime_construct(lock, std::forward_as_tuple(std::forward<Args>(args)...), std::tuple{});
 }
 
 template <class Type>
 template <class... HostArgs, class... RuntimeArgs>
 auto local_for_class_of<Type>::runtime_construct(
-	auto& env,
+	const auto& lock,
 	std::tuple<HostArgs...> host_args,
 	std::tuple<RuntimeArgs...> runtime_args
 ) const -> local_of<object_tag>
 	requires std::constructible_from<Type, HostArgs...> {
 	constexpr auto [... indices ] = util::sequence<sizeof...(HostArgs)>;
 	auto instance = std::make_unique<Type>(std::get<indices>(std::move(host_args))...);
-	return transfer_construct(env, std::move(instance), std::move(runtime_args));
+	return transfer_construct(lock, std::move(instance), std::move(runtime_args));
 }
 
 template <class Type>
 template <class... Args>
-auto local_for_class_of<Type>::transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> local_of<object_tag> {
+auto local_for_class_of<Type>::transfer_construct(const auto& lock, auto instance, std::tuple<Args...> runtime_args) const -> local_of<object_tag> {
 	using element_type = decltype(instance)::element_type;
 	auto construct = [ & ](napi_value this_arg) -> napi_value {
 		// Tag `this_arg`
-		napi::invoke0(napi_type_tag_object, napi_env{env}, this_arg, &type_tag_for<element_type>);
+		napi::invoke0(napi_type_tag_object, napi_env{lock}, this_arg, &type_tag_for<element_type>);
 
 		// Wrap w/ finalizer
 		return apply_finalizer(std::move(instance), [ & ](element_type* instance, node_api_basic_finalize finalize, void* hint) -> napi_value {
-			napi::invoke0(napi_wrap, napi_env{env}, this_arg, instance, finalize, hint, nullptr);
+			napi::invoke0(napi_wrap, napi_env{lock}, this_arg, instance, finalize, hint, nullptr);
 			return this_arg;
 		});
 	};
@@ -50,27 +50,27 @@ auto local_for_class_of<Type>::transfer_construct(auto& env, auto instance, std:
 	// Now an external (of `internal_constructor`) gets passed to JavaScript for a moment and
 	// hopefully it jumps into `construct`
 	auto construct_ref = internal_constructor{construct};
-	auto* construct_external = napi_value{local_of<external_tag>::make(env, &construct_ref)};
-	auto [... runtime_arg_values ] = js::transfer_in_strict<std::array<napi_value, sizeof...(Args)>>(std::move(runtime_args), env);
+	auto* construct_external = napi_value{local_of<external_tag>::make(lock, &construct_ref)};
+	auto [... runtime_arg_values ] = js::transfer_in_strict<std::array<napi_value, sizeof...(Args)>>(std::move(runtime_args), lock);
 	auto arg_vector = std::array{construct_external, runtime_arg_values...};
-	auto* this_arg = napi::invoke(napi_new_instance, napi_env{env}, napi_value{*this}, arg_vector.size(), arg_vector.data());
+	auto* this_arg = napi::invoke(napi_new_instance, napi_env{lock}, napi_value{*this}, arg_vector.size(), arg_vector.data());
 	return local_of<object_tag>::from(this_arg);
 }
 
 template <class Type>
 template <class Environment>
-auto local_for_class_of<Type>::make(Environment& env, const auto& class_template) -> local_of<class_tag_of<Type>> {
+auto local_for_class_of<Type>::make(const environment_lock_witness_of<Environment>& lock, const auto& class_template) -> local_of<class_tag_of<Type>> {
 	// Make constructor callback
 	auto [ construct_ptr, constructor_data ] =
-		make_callback_storage(env, make_constructor_function<Environment, Type>(class_template.constructor.function));
+		make_callback_storage(lock, make_constructor_function<Environment, Type>(class_template.constructor.function));
 	static_assert(std::remove_cvref_t<decltype(class_template.constructor)>::disposition == property_disposition::function);
 	static_assert(!requires { typename decltype(constructor_data)::element_type; });
 
 	// Member function property descriptor
 	const auto make_member_function_descriptor = [ & ]<class Property>(const Property& property) -> napi_property_descriptor
-		requires(Property::scope == class_property_scope::prototype) {
+		requires(Property::scope == class_property_scope::prototype && Property::disposition == property_disposition::function) {
 			constexpr auto u8_name = util::make_consteval_string_view(util::transcode_string<char>(property.name));
-			auto [ callback, data ] = make_callback_storage(env, make_member_function<Environment, Type>(property.function));
+			auto [ callback, data ] = make_callback_storage(lock, make_member_function<Environment, Type>(property.function));
 			static_assert(!requires { typename decltype(data)::element_type; });
 			return {
 				.utf8name = u8_name.data(),
@@ -87,11 +87,31 @@ auto local_for_class_of<Type>::make(Environment& env, const auto& class_template
 			};
 		};
 
+	// Member getter property descriptor
+	const auto make_member_getter_descriptor = [ & ]<class Property>(const Property& property) -> napi_property_descriptor
+		requires(Property::scope == class_property_scope::prototype && Property::disposition == property_disposition::accessor) {
+			constexpr auto u8_name = util::make_consteval_string_view(util::transcode_string<char>(property.name));
+			auto [ callback, data ] = make_callback_storage(lock, make_member_function<Environment, Type>(property.function));
+			static_assert(!requires { typename decltype(data)::element_type; });
+			return {
+				.utf8name = u8_name.data(),
+				.name{},
+
+				.method{},
+				.getter = callback,
+				.setter{},
+				.value{},
+
+				.attributes = napi_configurable,
+				.data = data,
+			};
+		};
+
 	// Static function property descriptor
 	const auto make_static_function_descriptor = [ & ]<class Property>(const Property& property) -> napi_property_descriptor
 		requires(Property::scope == class_property_scope::constructor) {
 			constexpr auto u8_name = util::make_consteval_string_view(util::transcode_string<char>(property.name));
-			auto [ callback, data ] = make_callback_storage(env, make_free_function<Environment>(property.function));
+			auto [ callback, data ] = make_callback_storage(lock, make_free_function<Environment>(property.function));
 			static_assert(!requires { typename decltype(data)::element_type; });
 			return {
 				.utf8name = u8_name.data(),
@@ -111,6 +131,7 @@ auto local_for_class_of<Type>::make(Environment& env, const auto& class_template
 	// Make class property descriptors
 	const auto make_property_descriptor = util::overloaded{
 		make_member_function_descriptor,
+		make_member_getter_descriptor,
 		make_static_function_descriptor,
 	};
 	const auto [... properties ] = class_template.properties;
@@ -123,7 +144,7 @@ auto local_for_class_of<Type>::make(Environment& env, const auto& class_template
 	constexpr auto u8_name = util::make_consteval_string_view(util::transcode_string<char>(class_template.constructor.name));
 	auto result = napi::invoke(
 		napi_define_class,
-		napi_env{env},
+		napi_env{lock},
 		u8_name.data(),
 		u8_name.length(),
 		construct_ptr,

package/value/class.h.cc

@@ -1,4 +1,5 @@
 export module napi_js:class_;
+import :lock;
 import :object;
 import std;
 
@@ -9,19 +10,19 @@ class local_for_class_of : public local_next<class_tag_of<Type>> {
 	public:
 		// Construct a new C++ instance & JavaScript value
 		template <class... Args>
-		auto construct(auto& env, Args&&... args) const -> local_of<object_tag>
+		auto construct(const auto& lock, Args&&... args) const -> local_of<object_tag>
 			requires std::constructible_from<Type, Args...>;
 
 		template <class... HostArgs, class... RuntimeArgs>
-		auto runtime_construct(auto& env, std::tuple<HostArgs...> host_args, std::tuple<RuntimeArgs...> runtime_args) const -> local_of<object_tag>
+		auto runtime_construct(const auto& lock, std::tuple<HostArgs...> host_args, std::tuple<RuntimeArgs...> runtime_args) const -> local_of<object_tag>
 			requires std::constructible_from<Type, HostArgs...>;
 
 		// Create a JavaScript value from an already-created instance smart pointer
 		template <class... Args>
-		auto transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> local_of<object_tag>;
+		auto transfer_construct(const auto& lock, auto instance, std::tuple<Args...> runtime_args) const -> local_of<object_tag>;
 
 		template <class Environment>
-		static auto make(Environment& env, const auto& class_template) -> local_of<class_tag_of<Type>>;
+		static auto make(const environment_lock_witness_of<Environment>& lock, const auto& class_template) -> local_of<class_tag_of<Type>>;
 };
 
 } // namespace js::napi

package/value/external.cc

@@ -7,11 +7,11 @@ namespace js::napi {
 class local_for_external : public local_next<external_tag> {
 	public:
 		// untagged
-		static auto make(auto& env, void* pointer) -> local_of<external_tag>;
+		static auto make(environment_lock_witness lock, void* pointer) -> local_of<external_tag>;
 
 		// tagged
 		template <class Type>
-		static auto make(auto& env, Type* pointer) -> local_of<external_tag>;
+		static auto make(environment_lock_witness lock, Type* pointer) -> local_of<external_tag>;
 };
 
 class value_for_external : public value_next<external_tag> {
@@ -24,15 +24,15 @@ class value_for_external : public value_next<external_tag> {
 
 // ---
 
-auto local_for_external::make(auto& env, void* pointer) -> local_of<external_tag> {
-	auto* external = napi::invoke(napi_create_external, napi_env{env}, pointer, nullptr, nullptr);
+auto local_for_external::make(environment_lock_witness lock, void* pointer) -> local_of<external_tag> {
+	auto* external = napi::invoke(napi_create_external, napi_env{lock}, pointer, nullptr, nullptr);
 	return local_of<external_tag>::from(external);
 }
 
 template <class Type>
-auto local_for_external::make(auto& env, Type* pointer) -> local_of<external_tag> {
-	auto external = make(env, static_cast<void*>(pointer));
-	napi::invoke0(napi_type_tag_object, napi_env{env}, external, &type_tag_for<Type>);
+auto local_for_external::make(environment_lock_witness lock, Type* pointer) -> local_of<external_tag> {
+	auto external = make(lock, static_cast<void*>(pointer));
+	napi::invoke0(napi_type_tag_object, napi_env{lock}, external, &type_tag_for<Type>);
 	return external;
 };
 

package/value/function.cc

@@ -5,35 +5,35 @@ import std;
 namespace js::napi {
 
 template <class Result>
-auto local_for_function::apply(auto_environment auto& env, auto&& args) -> Result {
-	auto argv = js::transfer_in_strict<std::vector<napi_value>>(std::forward<decltype(args)>(args), env);
-	return invoke<Result>(env, std::span{argv});
+auto local_for_function::apply(const auto& lock, auto&& args) -> Result {
+	auto argv = js::transfer_in_strict<std::vector<napi_value>>(std::forward<decltype(args)>(args), lock);
+	return invoke<Result>(lock, std::span{argv});
 }
 
 template <class Result>
-auto local_for_function::call(auto_environment auto& env, auto&&... args) -> Result {
-	auto argv = js::transfer_in_strict<std::array<napi_value, sizeof...(args)>>(std::forward_as_tuple(args...), env);
-	return invoke<Result>(env, std::span{argv});
+auto local_for_function::call(const auto& lock, auto&&... args) -> Result {
+	auto argv = js::transfer_in_strict<std::array<napi_value, sizeof...(args)>>(std::forward_as_tuple(args...), lock);
+	return invoke<Result>(lock, std::span{argv});
 }
 
 template <class Result>
-auto local_for_function::invoke(auto_environment auto& env, std::span<napi_value> args) -> Result {
-	auto undefined = js::transfer_in_strict<napi_value>(std::monostate{}, env);
-	auto* result = napi::invoke(napi_call_function, napi_env{env}, undefined, napi_value{*this}, args.size(), args.data());
-	return js::transfer_out<Result>(result, env);
+auto local_for_function::invoke(const auto& lock, std::span<napi_value> args) -> Result {
+	auto undefined = js::transfer_in_strict<napi_value>(std::monostate{}, lock);
+	auto* result = napi::invoke(napi_call_function, napi_env{lock}, undefined, napi_value{*this}, args.size(), args.data());
+	return js::transfer_out<Result>(result, lock);
 }
 
-template <auto_environment Environment>
-auto local_for_function::make(Environment& env, auto function) -> local_of<function_tag> {
-	auto [ callback, data ] = make_callback_storage(env, make_free_function<Environment>(std::move(function).callback));
+template <class Environment>
+auto local_for_function::make(const environment_lock_witness_of<Environment>& lock, auto function) -> local_of<function_tag> {
+	auto [ callback, data ] = make_callback_storage(lock, make_free_function<Environment>(std::move(function).callback));
 	auto make = [ & ](void* data) -> local_of<function_tag> {
-		return local_of<function_tag>::from(napi::invoke(napi_create_function, napi_env{env}, function.name.data(), function.name.length(), callback, data));
+		return local_of<function_tag>::from(napi::invoke(napi_create_function, napi_env{lock}, function.name.data(), function.name.length(), callback, data));
 	};
 	if constexpr (requires { typename decltype(data)::element_type; }) {
 		// Function requires finalizer
 		auto function = make(data.get());
 		return apply_finalizer(std::move(data), [ & ](auto* data, napi_finalize finalize, void* hint) -> local_of<function_tag> {
-			napi::invoke0(napi_add_finalizer, napi_env{env}, function, data, finalize, hint, nullptr);
+			napi::invoke0(napi_add_finalizer, napi_env{lock}, function, data, finalize, hint, nullptr);
 			return function;
 		});
 	} else {

package/value/function.h.cc

@@ -1,4 +1,5 @@
 export module napi_js:function;
+import :lock;
 import :primitive;
 import std;
 
@@ -7,17 +8,17 @@ namespace js::napi {
 class local_for_function : public local_next<function_tag> {
 	public:
 		template <class Result = std::monostate>
-		auto apply(auto_environment auto& env, auto&& args) -> Result;
+		auto apply(const auto& lock, auto&& args) -> Result;
 
 		template <class Result = std::monostate>
-		auto call(auto_environment auto& env, auto&&... args) -> Result;
+		auto call(const auto& lock, auto&&... args) -> Result;
 
-		template <auto_environment Environment>
-		static auto make(Environment& env, auto function) -> local_of<function_tag>;
+		template <class Environment>
+		static auto make(const environment_lock_witness_of<Environment>& lock, auto function) -> local_of<function_tag>;
 
 	private:
 		template <class Result>
-		auto invoke(auto_environment auto& env, std::span<napi_value> args) -> Result;
+		auto invoke(const auto& lock, std::span<napi_value> args) -> Result;
 };
 
 } // namespace js::napi

package/value/object.cc

@@ -3,8 +3,8 @@ module napi_js;
 namespace js::napi {
 
 // object
-auto value_for_object::get(napi_value key) const -> local_of<value_tag> {
-	return local_of<value_tag>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
+auto value_for_object::get(napi_value key) const -> local_of<> {
+	return local_of<>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
 }
 
 auto value_for_object::has(napi_value key) const -> bool {

package/value/object.h.cc

@@ -7,7 +7,7 @@ namespace js::napi {
 // object
 class local_for_object : public local_next<object_tag> {
 	public:
-		auto assign(auto_environment auto& env, auto source) const -> void;
+		auto assign(const auto& lock, auto source) const -> void;
 };
 
 class value_for_object : public value_next<object_tag> {
@@ -17,7 +17,7 @@ class value_for_object : public value_next<object_tag> {
 		template <class Type>
 		[[nodiscard]] auto try_cast(std::type_identity<Type> /*type*/) const -> Type*;
 
-		[[nodiscard]] auto get(napi_value key) const -> local_of<value_tag>;
+		[[nodiscard]] auto get(napi_value key) const -> local_of<>;
 		[[nodiscard]] auto has(napi_value key) const -> bool;
 
 		auto set(napi_value key, napi_value value) -> void;

package/value/record.cc

@@ -3,6 +3,7 @@ import std;
 
 namespace js::napi {
 
+// value_for_record
 auto value_for_record::into_range() const -> range_type {
 	return keys() | std::views::transform(iterator_transform{*this});
 }
@@ -21,7 +22,7 @@ auto value_for_record::keys() const -> const keys_type& {
 			static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols),
 			napi_key_keep_numbers
 		);
-		keys_ = keys_type{env(), js::napi::local_of<vector_tag>::from(property_names)};
+		keys_ = keys_type{lock(), js::napi::local_of<vector_tag>::from(property_names), false};
 	}
 	return keys_;
 }
@@ -29,8 +30,13 @@ auto value_for_record::keys() const -> const keys_type& {
 value_for_record::iterator_transform::iterator_transform(const value_for_record& subject) :
 		subject_{&subject} {}
 
-auto value_for_record::iterator_transform::operator()(local_of<value_tag> key) const -> value_type {
+auto value_for_record::iterator_transform::operator()(local_of<> key) const -> value_type {
 	return std::pair{key_type::from(key), subject_->get(key)};
 }
 
+// value_for_list
+auto value_for_list::values() const -> value_of<vector_tag> {
+	return value_of<vector_tag>{lock(), local_of<vector_tag>::from(*this)};
+}
+
 } // namespace js::napi

package/value/record.h.cc

@@ -10,14 +10,14 @@ class value_for_record : public value_next<record_tag> {
 		using value_next<record_tag>::value_next;
 		using keys_type = value_of<vector_tag>;
 		using key_type = local_of<primitive_tag>;
-		using mapped_type = local_of<value_tag>;
+		using mapped_type = local_of<>;
 		using value_type = std::pair<key_type, mapped_type>;
 
 	private:
 		class iterator_transform {
 			public:
 				explicit iterator_transform(const value_for_record& subject_);
-				auto operator()(local_of<value_tag> key) const -> value_type;
+				auto operator()(local_of<> key) const -> value_type;
 
 			private:
 				const value_for_record* subject_;
@@ -36,4 +36,10 @@ class value_for_record : public value_next<record_tag> {
 		mutable keys_type keys_;
 };
 
+class value_for_list : public value_next<list_tag> {
+	public:
+		using value_next<list_tag>::value_next;
+		auto values() const -> value_of<vector_tag>;
+};
+
 } // namespace js::napi