@auto_js/napi 0.0.8 → 0.0.9

package/support/callback_storage.cc

@@ -35,12 +35,12 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 			// Trivial function type containing less than or equal to a pointer size. `data` is the
 			// function and environment is stored in a thread local.
 			callback_env_local<Environment> = &env;
-			auto* data = reinterpret_cast<void*&>(function);
+			auto* data = util::bit_padding_cast<void*>(function);
 			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
 				const auto args = callback_info{nenv, info};
 				if (args) {
 					auto* data = args.data();
-					auto& invoke = reinterpret_cast<function_type&>(data);
+					auto invoke = util::bit_truncation_cast<function_type>(data);
 					auto& env = *callback_env_local<Environment>;
 					return invoke(env, args);
 				} else {

package/support/class_template_storage.cc

@@ -20,7 +20,7 @@ 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) -> value_of<class_tag_of<Type>> {
+		auto class_template(this auto& self, std::type_identity<Type> /*type*/, 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) {
@@ -33,7 +33,7 @@ class class_template_references {
 				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_of<class_tag_of<Type>>;
+			using value_type = js::napi::local_of<class_tag_of<Type>>;
 			if (reference) {
 				return value_type::from(reference.get(self));
 			} else {

package/support/host.cc

@@ -70,15 +70,15 @@ auto fast_is_string(napi_value value) -> bool {
 }
 
 // Bug fixes
-auto napi_is_object_array_buffer(napi_env env, value_of<object_tag> value) -> bool {
+auto napi_is_object_array_buffer(napi_env env, local_of<object_tag> value) -> bool {
 	return napi::invoke(napi_is_arraybuffer, env, value);
 }
 
-auto napi_is_data_block_array_buffer(napi_env env, value_of<data_block_tag> value) -> bool {
+auto napi_is_data_block_array_buffer(napi_env env, local_of<data_block_tag> value) -> bool {
 	return napi_is_object_array_buffer(env, value);
 }
 
-auto bun_is_data_block_array_buffer(napi_env env, value_of<data_block_tag> value) -> bool {
+auto bun_is_data_block_array_buffer(napi_env env, local_of<data_block_tag> value) -> bool {
 	// https://github.com/oven-sh/bun/issues/32624
 	auto* string = napi::invoke(napi_coerce_to_string, env, value);
 	auto length = napi::invoke(napi_get_value_string_latin1, env, string, nullptr, 0);
@@ -86,30 +86,34 @@ auto bun_is_data_block_array_buffer(napi_env env, value_of<data_block_tag> value
 	return length == 20;
 }
 
-auto bun_is_object_array_buffer(napi_env env, value_of<object_tag> value) -> bool {
+auto bun_is_object_array_buffer(napi_env env, local_of<object_tag> value) -> bool {
 	if (napi::invoke(napi_is_arraybuffer, env, value)) {
-		return bun_is_data_block_array_buffer(env, value_of<data_block_tag>::from(value));
+		return bun_is_data_block_array_buffer(env, local_of<data_block_tag>::from(value));
 	} else {
 		return false;
 	}
 }
 
 // Optional value inspectors.
-auto v8_is_number_int32(value_of<number_tag> value) -> std::optional<bool> {
+auto v8_is_number_int32(local_of<number_tag> value) -> std::optional<bool> {
 	return std::bit_cast<v8::Local<v8::Number>>(value)->IsInt32();
 };
 
-auto v8_is_string_one_byte(value_of<string_tag> value) -> std::optional<bool> {
+auto v8_is_string_one_byte(local_of<string_tag> value) -> std::optional<bool> {
 	return std::bit_cast<v8::Local<v8::String>>(value)->IsOneByte();
 }
 
-auto node_api_maybe_is_shared_array_buffer(napi_env env, value_of<object_tag> value) -> std::optional<bool> {
-	return napi::invoke(node_api_is_sharedarraybuffer, env, value);
+auto node_api_maybe_is_shared_array_buffer(napi_env env, local_of<object_tag> value) -> std::optional<bool> {
+	if constexpr (node_api_has_sharedarraybuffer) {
+		return napi::invoke(node_api_is_sharedarraybuffer, env, value);
+	} else {
+		return std::nullopt;
+	}
 }
 
-auto bun_maybe_is_shared_array_buffer(napi_env env, value_of<object_tag> value) -> std::optional<bool> {
+auto bun_maybe_is_shared_array_buffer(napi_env env, local_of<object_tag> value) -> std::optional<bool> {
 	if (napi::invoke(napi_is_arraybuffer, env, value)) {
-		return !bun_is_data_block_array_buffer(env, value_of<data_block_tag>::from(value));
+		return !bun_is_data_block_array_buffer(env, local_of<data_block_tag>::from(value));
 	} else {
 		return std::nullopt;
 	}
@@ -118,7 +122,7 @@ auto bun_maybe_is_shared_array_buffer(napi_env env, value_of<object_tag> value)
 constexpr auto unknown_maybe_is = [](auto...) -> std::optional<bool> { return std::nullopt; };
 
 // 'SharedArrayBuffer' functions
-auto v8_make_shared_array_buffer(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> value_of<shared_array_buffer_tag> {
+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 {
 		// v8 does not call the deleter `byte_length` is zero. So the heap-allocated shared_ptr trick
 		// does not work in that case.
@@ -139,14 +143,14 @@ auto v8_make_shared_array_buffer(js::shared_array_buffer::shared_pointer_type da
 		}
 	}();
 	auto shared_array_buffer = v8::SharedArrayBuffer::New(v8::Isolate::GetCurrent(), std::move(backing_store));
-	return value_of<shared_array_buffer_tag>::from(std::bit_cast<napi_value>(shared_array_buffer));
+	return local_of<shared_array_buffer_tag>::from(std::bit_cast<napi_value>(shared_array_buffer));
 };
 
-auto v8_shared_array_buffer_get_byte_length(value_of<shared_array_buffer_tag> buffer) -> std::size_t {
+auto v8_shared_array_buffer_get_byte_length(local_of<shared_array_buffer_tag> buffer) -> std::size_t {
 	return std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer})->ByteLength();
 };
 
-auto v8_shared_array_buffer_get_backing_store(value_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<std::byte[]> {
 	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)
@@ -155,15 +159,15 @@ auto v8_shared_array_buffer_get_backing_store(value_of<shared_array_buffer_tag>
 
 // 'ArrayBufferView' constructors
 // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-auto v8_make_sab_data_view(value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> {
+auto v8_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> {
 	auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
 	auto view_local = v8::DataView::New(buffer_local, byte_offset, length);
-	return value_of<data_view_tag>::from(std::bit_cast<napi_value>(view_local));
+	return local_of<data_view_tag>::from(std::bit_cast<napi_value>(view_local));
 };
 
 template <class Type>
 // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-auto v8_make_sab_typed_array_of(value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+auto v8_make_sab_typed_array_of(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
 	using constructor_type = type_t<util::overloaded{
 		[](std::type_identity<double>) -> std::type_identity<v8::Float64Array> { return {}; },
 		[](std::type_identity<float>) -> std::type_identity<v8::Float32Array> { return {}; },
@@ -180,7 +184,7 @@ auto v8_make_sab_typed_array_of(value_of<shared_array_buffer_tag> buffer, std::s
 	}(type<Type>)>;
 	auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
 	auto view_local = constructor_type::New(buffer_local, byte_offset, length);
-	return value_of<typed_array_tag_of<Type>>::from(std::bit_cast<napi_value>(view_local));
+	return local_of<typed_array_tag_of<Type>>::from(std::bit_cast<napi_value>(view_local));
 };
 
 template <class Type>
@@ -302,20 +306,20 @@ auto initialize_host_environment(napi_env env) -> void {
 				host_uv_dlclose = unknown_uv_dlclose;
 				host_uv_dlerror = unknown_uv_dlerror;
 				host_uv_dlopen = unknown_uv_dlopen;
-				make_sab_data_view = unknown_sab_throw<value_of<data_view_tag>>;
-				make_sab_typed_array_of<double> = unknown_sab_throw<value_of<typed_array_tag_of<double>>>;
-				make_sab_typed_array_of<float> = unknown_sab_throw<value_of<typed_array_tag_of<float>>>;
-				make_sab_typed_array_of<js::float16_t> = unknown_sab_throw<value_of<typed_array_tag_of<js::float16_t>>>;
-				make_sab_typed_array_of<js::uint8_clamped_t> = unknown_sab_throw<value_of<typed_array_tag_of<js::uint8_clamped_t>>>;
-				make_sab_typed_array_of<std::int16_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int16_t>>>;
-				make_sab_typed_array_of<std::int32_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int32_t>>>;
-				make_sab_typed_array_of<std::int64_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int64_t>>>;
-				make_sab_typed_array_of<std::int8_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int8_t>>>;
-				make_sab_typed_array_of<std::uint16_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint16_t>>>;
-				make_sab_typed_array_of<std::uint32_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint32_t>>>;
-				make_sab_typed_array_of<std::uint64_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint64_t>>>;
-				make_sab_typed_array_of<std::uint8_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint8_t>>>;
-				make_shared_array_buffer = unknown_sab_throw<value_of<shared_array_buffer_tag>>;
+				make_sab_data_view = unknown_sab_throw<local_of<data_view_tag>>;
+				make_sab_typed_array_of<double> = unknown_sab_throw<local_of<typed_array_tag_of<double>>>;
+				make_sab_typed_array_of<float> = unknown_sab_throw<local_of<typed_array_tag_of<float>>>;
+				make_sab_typed_array_of<js::float16_t> = unknown_sab_throw<local_of<typed_array_tag_of<js::float16_t>>>;
+				make_sab_typed_array_of<js::uint8_clamped_t> = unknown_sab_throw<local_of<typed_array_tag_of<js::uint8_clamped_t>>>;
+				make_sab_typed_array_of<std::int16_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int16_t>>>;
+				make_sab_typed_array_of<std::int32_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int32_t>>>;
+				make_sab_typed_array_of<std::int64_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int64_t>>>;
+				make_sab_typed_array_of<std::int8_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int8_t>>>;
+				make_sab_typed_array_of<std::uint16_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint16_t>>>;
+				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>>>;
+				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;

package/support/host.h.cc

@@ -1,5 +1,5 @@
 export module napi_js:support.host;
-import :value_handle;
+import :handle.local_of;
 import std;
 
 namespace js::napi {
@@ -23,27 +23,27 @@ auto fast_is_object(napi_value value) -> bool;
 auto fast_is_string(napi_value value) -> bool;
 
 // Bug fixes
-auto (*is_object_array_buffer)(napi_env env, value_of<object_tag> value) -> bool = nullptr;
-auto (*is_data_block_array_buffer)(napi_env env, value_of<data_block_tag> value) -> bool = nullptr;
+auto (*is_object_array_buffer)(napi_env env, local_of<object_tag> value) -> bool = nullptr;
+auto (*is_data_block_array_buffer)(napi_env env, local_of<data_block_tag> value) -> bool = nullptr;
 
 // Optional value inspectors. int32 & latin1 will select optimized representations, and
 // shared_array_buffer is required for support of that value type.
-auto (*maybe_is_number_int32)(value_of<number_tag> value) -> std::optional<bool> = nullptr;
-auto (*maybe_is_string_latin1)(value_of<string_tag> value) -> std::optional<bool> = nullptr;
-auto (*maybe_is_shared_array_buffer)(napi_env env, value_of<object_tag> value) -> std::optional<bool> = nullptr;
+auto (*maybe_is_number_int32)(local_of<number_tag> value) -> std::optional<bool> = nullptr;
+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;
 
 // 'SharedArrayBuffer' functions
-auto (*make_shared_array_buffer)(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> value_of<shared_array_buffer_tag> = nullptr;
-auto (*shared_array_buffer_get_byte_length)(value_of<shared_array_buffer_tag> buffer) -> std::size_t = nullptr;
+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)(value_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<std::byte[]> = nullptr;
 
 // 'ArrayBufferView' constructors
-auto (*make_sab_data_view)(value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> = nullptr;
+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;
 
 template <class Type>
 using make_sab_typed_array_constructor =
-	auto(value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>>;
+	auto(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>>;
 
 template <class Type>
 make_sab_typed_array_constructor<Type>* make_sab_typed_array_of;

package/support/initialize.h.cc

@@ -34,8 +34,8 @@ class napi_js_module final : private detail::initialize_require {
 			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 = value_of<dictionary_tag>::from(exports);
-			exports_local.assign(client_environment, std::move(make_exports_)(client_environment));
+			auto exports_local = local_of<dictionary_tag>::from(exports);
+			exports_local->assign(client_environment, std::move(make_exports_)(client_environment));
 		}
 
 		Make make_exports_;

package/support/promise.cc

@@ -19,7 +19,7 @@ class resolver {
 		resolver(resolver&&) = default;
 		~resolver() {
 			if (scheduler_) {
-				resolve(std::monostate{});
+				resolve(nullptr);
 			}
 		}
 
@@ -117,7 +117,7 @@ auto make_promise(Environment& env, auto... dispatch) {
 	auto resolve = resolver{env, deferred, std::move(dispatch)...};
 
 	// `[ promise, resolver ]`
-	return std::tuple{value_of<promise_tag>::from(promise), std::move(resolve)};
+	return std::tuple{local_of<promise_tag>::from(promise), std::move(resolve)};
 }
 
 } // namespace js::napi

package/transfer/accept.cc

@@ -4,87 +4,87 @@ import std;
 namespace js::napi {
 
 // undefined & null
-auto accept_basic_napi_value::operator()(undefined_tag /*tag*/, visit_holder /*visit*/, std::monostate /*subject*/) const -> value_of<undefined_tag> {
-	return value_of<undefined_tag>::from(napi::invoke(napi_get_undefined, napi_env{*this}));
+auto accept_basic_napi_value::operator()(undefined_tag /*tag*/, visit_holder /*visit*/, std::monostate /*subject*/) const -> local_of<undefined_tag> {
+	return local_of<undefined_tag>::from(napi::invoke(napi_get_undefined, napi_env{*this}));
 }
 
-auto accept_basic_napi_value::operator()(null_tag /*tag*/, visit_holder /*visit*/, std::nullptr_t /*subject*/) const -> value_of<null_tag> {
-	return value_of<null_tag>::from(napi::invoke(napi_get_null, napi_env{*this}));
+auto accept_basic_napi_value::operator()(null_tag /*tag*/, visit_holder /*visit*/, std::nullptr_t /*subject*/) const -> local_of<null_tag> {
+	return local_of<null_tag>::from(napi::invoke(napi_get_null, napi_env{*this}));
 }
 
 // boolean
-auto accept_basic_napi_value::operator()(boolean_tag /*tag*/, visit_holder /*visit*/, bool subject) const -> value_of<boolean_tag> {
-	return value_of<boolean_tag>::from(napi::invoke(napi_get_boolean, napi_env{*this}, subject));
+auto accept_basic_napi_value::operator()(boolean_tag /*tag*/, visit_holder /*visit*/, bool subject) const -> local_of<boolean_tag> {
+	return local_of<boolean_tag>::from(napi::invoke(napi_get_boolean, napi_env{*this}, subject));
 }
 
 // number
-auto accept_basic_napi_value::operator()(number_tag_of<double> /*tag*/, visit_holder /*visit*/, double subject) const -> value_of<number_tag_of<double>> {
-	return value_of<number_tag_of<double>>::from(napi::invoke(napi_create_double, napi_env{*this}, subject));
+auto accept_basic_napi_value::operator()(number_tag_of<double> /*tag*/, visit_holder /*visit*/, double subject) const -> local_of<number_tag_of<double>> {
+	return local_of<number_tag_of<double>>::from(napi::invoke(napi_create_double, napi_env{*this}, subject));
 }
 
-auto accept_basic_napi_value::operator()(number_tag_of<std::int32_t> /*tag*/, visit_holder /*visit*/, std::int32_t subject) const -> value_of<number_tag_of<std::int32_t>> {
-	return value_of<number_tag_of<std::int32_t>>::from(napi::invoke(napi_create_int32, napi_env{*this}, subject));
+auto accept_basic_napi_value::operator()(number_tag_of<std::int32_t> /*tag*/, visit_holder /*visit*/, std::int32_t subject) const -> local_of<number_tag_of<std::int32_t>> {
+	return local_of<number_tag_of<std::int32_t>>::from(napi::invoke(napi_create_int32, napi_env{*this}, subject));
 }
 
-auto accept_basic_napi_value::operator()(number_tag_of<std::uint32_t> /*tag*/, visit_holder /*visit*/, std::uint32_t subject) const -> value_of<number_tag_of<std::uint32_t>> {
-	return value_of<number_tag_of<std::uint32_t>>::from(napi::invoke(napi_create_uint32, napi_env{*this}, subject));
+auto accept_basic_napi_value::operator()(number_tag_of<std::uint32_t> /*tag*/, visit_holder /*visit*/, std::uint32_t subject) const -> local_of<number_tag_of<std::uint32_t>> {
+	return local_of<number_tag_of<std::uint32_t>>::from(napi::invoke(napi_create_uint32, napi_env{*this}, subject));
 }
 
 // string
 auto accept_basic_napi_value::operator()(string_tag_of<char> /*tag*/, visit_holder /*visit*/, std::string_view subject) const
-	-> js::referenceable_value<value_of<string_tag_of<char>>> {
+	-> js::referenceable_value<local_of<string_tag_of<char>>> {
 	auto* value = napi::invoke(napi_create_string_latin1, napi_env{*this}, subject.data(), subject.length());
-	return js::referenceable_value{value_of<string_tag_of<char>>::from(value)};
+	return js::referenceable_value{local_of<string_tag_of<char>>::from(value)};
 }
 
 auto accept_basic_napi_value::operator()(string_tag_of<char8_t> /*tag*/, visit_holder /*visit*/, std::u8string_view subject) const
-	-> js::referenceable_value<value_of<string_tag_of<char8_t>>> {
+	-> js::referenceable_value<local_of<string_tag_of<char8_t>>> {
 	auto* value = napi::invoke(napi_create_string_utf8, napi_env{*this}, reinterpret_cast<const char*>(subject.data()), subject.length());
-	return js::referenceable_value{value_of<string_tag_of<char8_t>>::from(value)};
+	return js::referenceable_value{local_of<string_tag_of<char8_t>>::from(value)};
 }
 
 auto accept_basic_napi_value::operator()(string_tag_of<char16_t> /*tag*/, visit_holder /*visit*/, std::u16string_view subject) const
-	-> js::referenceable_value<value_of<string_tag_of<char16_t>>> {
+	-> js::referenceable_value<local_of<string_tag_of<char16_t>>> {
 	auto* value = napi::invoke(napi_create_string_utf16, napi_env{*this}, subject.data(), subject.length());
-	return js::referenceable_value{value_of<string_tag_of<char16_t>>::from(value)};
+	return js::referenceable_value{local_of<string_tag_of<char16_t>>::from(value)};
 }
 
 // bigint
 auto accept_basic_napi_value::operator()(bigint_tag_of<std::int64_t> /*tag*/, visit_holder /*visit*/, std::int64_t subject) const
-	-> js::referenceable_value<value_of<bigint_tag_of<std::int64_t>>> {
+	-> js::referenceable_value<local_of<bigint_tag_of<std::int64_t>>> {
 	auto* value = napi::invoke(napi_create_bigint_int64, napi_env{*this}, subject);
-	return js::referenceable_value{value_of<bigint_tag_of<std::int64_t>>::from(value)};
+	return js::referenceable_value{local_of<bigint_tag_of<std::int64_t>>::from(value)};
 }
 
 auto accept_basic_napi_value::operator()(bigint_tag_of<std::uint64_t> /*tag*/, visit_holder /*visit*/, std::uint64_t subject) const
-	-> js::referenceable_value<value_of<bigint_tag_of<std::uint64_t>>> {
+	-> js::referenceable_value<local_of<bigint_tag_of<std::uint64_t>>> {
 	auto* value = napi::invoke(napi_create_bigint_uint64, napi_env{*this}, subject);
-	return js::referenceable_value{value_of<bigint_tag_of<std::uint64_t>>::from(value)};
+	return js::referenceable_value{local_of<bigint_tag_of<std::uint64_t>>::from(value)};
 }
 
 auto accept_basic_napi_value::operator()(bigint_tag_of<js::bigint> /*tag*/, visit_holder /*visit*/, const js::bigint& subject) const
-	-> js::referenceable_value<value_of<bigint_tag_of<js::bigint>>> {
+	-> js::referenceable_value<local_of<bigint_tag_of<js::bigint>>> {
 	auto* value = napi::invoke(napi_create_bigint_words, napi_env{*this}, subject.sign_bit(), subject.size(), subject.data());
-	return js::referenceable_value{value_of<bigint_tag_of<js::bigint>>::from(value)};
+	return js::referenceable_value{local_of<bigint_tag_of<js::bigint>>::from(value)};
 }
 
 // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
 auto accept_basic_napi_value::operator()(bigint_tag_of<js::bigint> tag, visit_holder visit, js::bigint&& subject) const
-	-> js::referenceable_value<value_of<bigint_tag_of<js::bigint>>> {
+	-> js::referenceable_value<local_of<bigint_tag_of<js::bigint>>> {
 	return (*this)(tag, visit, static_cast<const js::bigint&>(subject));
 }
 
 // date
 auto accept_basic_napi_value::operator()(date_tag /*tag*/, visit_holder /*visit*/, js_clock::time_point subject) const
-	-> js::referenceable_value<value_of<date_tag>> {
-	auto value = value_of<date_tag>::from(napi::invoke(napi_create_date, napi_env{*this}, subject.time_since_epoch().count()));
+	-> js::referenceable_value<local_of<date_tag>> {
+	auto value = local_of<date_tag>::from(napi::invoke(napi_create_date, napi_env{*this}, subject.time_since_epoch().count()));
 	return js::referenceable_value{value};
 }
 
 // error
 auto accept_basic_napi_value::operator()(error_tag /*tag*/, visit_holder visit, const js::error_value& subject) const
-	-> js::referenceable_value<value_of<error_tag>> {
-	auto* message = napi_value{js::transfer_in<value_of<string_tag>>(subject.message(), environment())};
+	-> js::referenceable_value<local_of<error_tag>> {
+	auto* message = napi_value{js::transfer_in<local_of<string_tag>>(subject.message(), environment())};
 	auto* error = [ & ] -> napi_value {
 		switch (subject.name()) {
 			default:
@@ -99,12 +99,12 @@ auto accept_basic_napi_value::operator()(error_tag /*tag*/, visit_holder visit,
 	}();
 	auto stack = (*this)(string_tag{}, visit, subject.stack());
 	napi::invoke0(napi_set_named_property, napi_env{*this}, error, "stack", *std::move(stack));
-	return js::referenceable_value{value_of<error_tag>::from(error)};
+	return js::referenceable_value{local_of<error_tag>::from(error)};
 }
 
 // data blocks (array buffer, shared array buffer)
 auto accept_basic_napi_value::operator()(array_buffer_tag /*tag*/, visit_holder /*visit*/, const js::array_buffer& subject) const
-	-> js::referenceable_value<value_of<array_buffer_tag>> {
+	-> js::referenceable_value<local_of<array_buffer_tag>> {
 	auto view = std::span<const std::byte>{subject};
 	// You could avoid the extra copy for `js::data_block&&` here w/ v8 API. Napi requires the copy
 	// though.
@@ -115,18 +115,18 @@ auto accept_basic_napi_value::operator()(array_buffer_tag /*tag*/, visit_holder
 	// (and also) it maybe causes an infinite loop with musl
 	// https://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0
 	std::ranges::copy(view, static_cast<std::byte*>(bytes));
-	auto value = value_of<array_buffer_tag>::from(result);
+	auto value = local_of<array_buffer_tag>::from(result);
 	return js::referenceable_value{value};
 }
 
 auto accept_basic_napi_value::operator()(shared_array_buffer_tag /*tag*/, visit_holder /*visit*/, js::shared_array_buffer&& subject) const
-	-> js::referenceable_value<value_of<shared_array_buffer_tag>> {
+	-> js::referenceable_value<local_of<shared_array_buffer_tag>> {
 	auto value = make_shared_array_buffer(std::move(subject).acquire_ownership(), subject.byte_length());
 	return js::referenceable_value{value};
 }
 
 auto accept_basic_napi_value::operator()(shared_array_buffer_tag tag, visit_holder visit, const js::shared_array_buffer& subject) const
-	-> js::referenceable_value<value_of<shared_array_buffer_tag>> {
+	-> js::referenceable_value<local_of<shared_array_buffer_tag>> {
 	return (*this)(tag, visit, js::shared_array_buffer{subject});
 }