@auto_js/napi 0.0.8 → 0.0.10

package/package.json

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

package/support/callback.cc

@@ -13,7 +13,7 @@ template <class Type>
 constexpr auto unwrap_member_this = [](auto_environment auto& env, napi_value this_arg) noexcept -> std::optional<tagged_external<Type>> {
 	return napi::invoke_maybe(napi_coerce_to_object, napi_env{env}, this_arg)
 		.and_then([ &env ](napi_value coerced_this_arg) -> std::optional<tagged_external<Type>> {
-			auto as_object = bound_value{env, value_of<object_tag>::from(coerced_this_arg)};
+			auto as_object = value_of{env, 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) {
@@ -40,8 +40,8 @@ constexpr auto make_free_function(auto function) {
 		using callback_type = decltype(callback);
 		return util::bind{
 			[](callback_type& callback, Environment& env, const callback_info& info) noexcept(Nx) -> napi_value {
-				return invoke_internal_error_scope(env, [ & ]() -> napi_value {
-					auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				return invoke_internal_error_scope(env, [ & ] -> napi_value {
+					auto run = util::regular_return{[ & ] -> decltype(auto) {
 						return std::apply(
 							callback,
 							std::tuple_cat(
@@ -65,7 +65,7 @@ constexpr auto make_free_function(auto function) {
 		using callback_type = decltype(callback);
 		return util::bind{
 			[](callback_type& callback, Environment& env, const callback_info& /*info*/) noexcept -> napi_value {
-				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				auto run = util::regular_return{[ & ] -> decltype(auto) {
 					return callback(env);
 				}};
 				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
@@ -112,11 +112,11 @@ constexpr auto make_constructor_function(auto constructor) {
 				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 {
+						return invoke_internal_error_scope(env, [ & ] -> napi_value {
 							auto instance = std::apply(
 								callback,
 								std::tuple_cat(
-									std::forward_as_tuple(env, value_of<object_tag>::from(info.this_arg())),
+									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)
 								)
 							);
@@ -136,7 +136,7 @@ constexpr auto make_constructor_function(auto constructor) {
 				using callback_type = decltype(callback);
 				return util::bind{
 					[](callback_type& callback, Environment& env, const callback_info& info) noexcept -> napi_value {
-						return wrap(callback(env, value_of<object_tag>::from(info.this_arg())));
+						return wrap(callback(env, local_of<object_tag>::from(info.this_arg())));
 					},
 					std::move(callback),
 				};
@@ -159,7 +159,7 @@ constexpr auto make_constructor_function(auto constructor) {
 		[](runtime_constructor_type& constructor, Environment& env, const callback_info& info) -> napi_value {
 			auto arguments = info.arguments();
 			if (!arguments.empty()) {
-				auto maybe_constructor = [ & ]() -> std::optional<internal_constructor*> {
+				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);
@@ -181,7 +181,7 @@ 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(env, [ & ] -> napi_value {
 						return constructor(info.this_arg());
 					});
 				}
@@ -208,8 +208,8 @@ constexpr auto make_member_function(Method method) {
 				if (!maybe_that) {
 					return nullptr;
 				}
-				return invoke_internal_error_scope(env, [ & ]() -> napi_value {
-					auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				return invoke_internal_error_scope(env, [ & ] -> napi_value {
+					auto run = util::regular_return{[ & ] -> decltype(auto) {
 						return std::apply(
 							callback,
 							std::tuple_cat(
@@ -237,7 +237,7 @@ constexpr auto make_member_function(Method method) {
 				if (!maybe_that) {
 					return nullptr;
 				}
-				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				auto run = util::regular_return{[ & ] -> decltype(auto) {
 					return callback(**maybe_that, env);
 				}};
 				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);

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

@@ -10,7 +10,7 @@ namespace js::napi {
 // Given a pack of strings it returns a static reference to a `util::sealed_map` of napi object
 // references.
 template <const auto& Strings>
-constexpr auto class_template_references_of = []() -> auto {
+constexpr auto class_template_references_of = [] consteval -> auto {
 	const auto [... strings ] = Strings;
 	return util::sealed_map{std::type_identity<napi::reference<class_tag>>{}, strings...};
 }();
@@ -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,8 +122,8 @@ 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 backing_store = [ & ]() -> auto {
+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.
 		if (byte_length == 0) {
@@ -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>
@@ -229,7 +233,7 @@ auto initialize_host_environment(napi_env env) -> void {
 			}
 
 			// Get `globalThis.process`
-			auto* process_global = [ & ]() -> napi_value {
+			auto* process_global = [ & ] -> napi_value {
 				auto* global = napi::invoke(napi_get_global, env);
 				constexpr auto process_cw = util::make_consteval_string_view(util::cw<"process">);
 				auto* process_str = napi::invoke(node_api_create_property_key_latin1, env, process_cw.data(), process_cw.length());
@@ -242,7 +246,7 @@ auto initialize_host_environment(napi_env env) -> void {
 			}();
 
 			// Detect bun via `process.isBun`
-			auto is_bun = process_global == nullptr ? false : [ & ]() -> bool {
+			auto is_bun = process_global == nullptr ? false : [ & ] -> bool {
 				constexpr auto is_bun_cw = util::make_consteval_string_view(util::cw<"isBun">);
 				auto* is_bun_str = napi::invoke(node_api_create_property_key_latin1, env, is_bun_cw.data(), is_bun_cw.length());
 				auto* is_bun = napi::invoke(napi_get_property, env, process_global, is_bun_str);
@@ -251,7 +255,7 @@ auto initialize_host_environment(napi_env env) -> void {
 			}();
 
 			// Detect deno via `process.versions.deno`
-			auto is_deno = process_global == nullptr ? false : [ & ]() -> bool {
+			auto is_deno = process_global == nullptr ? false : [ & ] -> bool {
 				constexpr auto versions_cw = util::make_consteval_string_view(util::cw<"versions">);
 				auto* versions_str = napi::invoke(node_api_create_property_key_latin1, env, versions_cw.data(), versions_cw.length());
 				auto* versions = napi::invoke(napi_get_property, env, process_global, versions_str);
@@ -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

@@ -31,11 +31,11 @@ class napi_js_module final : private detail::initialize_require {
 	private:
 		auto operator()(napi_env env, napi_value exports) -> void override {
 			// construct environment, set napi instance data w/ finalizer
-			const auto [... indices ] = util::sequence<sizeof...(Args)>;
+			constexpr 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/support/string_table.cc

@@ -10,7 +10,7 @@ namespace js::napi {
 // Given a pack of strings it returns a static reference to a `util::sealed_map` of napi string
 // references.
 template <const auto& Strings>
-constexpr auto string_table_of = []() -> auto {
+constexpr auto string_table_of = [] consteval -> auto {
 	const auto [... strings ] = Strings;
 	return util::sealed_map{std::type_identity<napi::reference<string_tag>>{}, strings...};
 }();

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});
 }