@auto_js/napi 0.0.4 → 0.0.5

package/api/callback_info.cc

@@ -13,17 +13,22 @@ export struct callback_info : util::non_copyable {
 		callback_info(napi_env env, napi_callback_info info) {
 			napi::invoke0(napi_get_cb_info, env, info, &count_, storage_.data(), &this_, &data_);
 			if (count_ > storage_.size()) {
-				throw js::range_error{u"Too many arguments provided for a function call"};
+				constexpr auto message = std::string_view{"Too many arguments provided for a function call"};
+				napi::invoke0(napi_throw_range_error, env, nullptr, message.data());
+				count_ = 0;
+			} else {
+				++count_;
 			}
 		}
 
-		[[nodiscard]] auto arguments() const -> std::span<const napi_value> { return std::span{storage_}.first(count_); }
+		[[nodiscard]] auto arguments() const -> std::span<const napi_value> { return std::span{storage_}.first(count_ - 1); }
 		[[nodiscard]] auto data() const -> void* { return data_; }
 		[[nodiscard]] auto this_arg() const -> napi_value { return this_; }
+		explicit operator bool() const { return count_ != 0; }
 
 	private:
 		napi_value this_;
-		std::array<napi_value, 8> storage_;
+		std::array<napi_value, 16> storage_;
 		std::size_t count_{storage_.size()};
 		void* data_;
 };

package/api/uv_scheduler.h.cc

@@ -3,21 +3,12 @@ import :api.uv_handle;
 import std;
 import util;
 
-#if _LIBCPP_VERSION
-// clang 22.1.0
-// /usr/lib/llvm-22/bin/../include/c++/v1/__new/allocate.h:39:30: error: no matching function for call to 'operator new'
-//    39 |     return static_cast<_Tp*>(__builtin_operator_new(__size, static_cast<align_val_t>(__align)));
-export {
-	using ::operator new;
-}
-#endif
-
 namespace js::napi {
 
 // Shareable libuv scheduler
 export class uv_scheduler {
 	private:
-		using task_type = util::maybe_move_only_function<auto()->void>;
+		using task_type = util::move_only_function<auto()->void>;
 
 	public:
 		auto close(util::function_ref<auto()->void> close_hook) -> void;
@@ -57,7 +48,7 @@ auto uv_scheduler::operator()(auto task, auto&&... args) const -> void {
 	auto& async = *async_;
 	auto shared = async->shared.write();
 	if (shared->is_open) {
-		shared->tasks.push_back(
+		shared->tasks.emplace_back(
 			[ task = std::move(task),
 				... args = std::forward<decltype(args)>(args) ]() mutable -> void {
 				task(std::move(args)...);

package/handle/remote.cc

@@ -59,12 +59,11 @@ template <class Tag>
 auto remote<Tag>::expire(remote* ptr) -> void {
 	std::unique_ptr<remote> self{ptr};
 	ptr->scheduler_(
-		util::make_indirect_moveable_function(
-			[ self = std::move(self) ] mutable -> auto {
-				const auto scope = handle_scope{self->env()};
-				self.reset();
-			}
-		)
+		[](auto self) -> void {
+			const auto scope = handle_scope{self->env()};
+			self.reset();
+		},
+		std::move(self)
 	);
 }
 

package/handle/types.cc

@@ -99,6 +99,11 @@ struct value_specialization<function_tag> : value_defaults<function_tag> {
 		using value_type = class value_for_function;
 };
 
+template <>
+struct value_specialization<data_block_tag> : value_defaults<data_block_tag> {
+		using bound_type = class bound_value_for_data_block;
+};
+
 template <>
 struct value_specialization<array_buffer_tag> : value_defaults<array_buffer_tag> {
 		using bound_type = class bound_value_for_array_buffer;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "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.4",
-    "@auto_js/v8_exports": "^0.0.2",
-    "@auto_js/napi_exports": "^0.0.4"
+    "@auto_js/v8_exports": "^0.0.3",
+    "@auto_js/js": "^0.0.5",
+    "@auto_js/napi_exports": "^0.0.5"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -46,7 +46,7 @@ constexpr auto make_free_function(auto function) {
 							callback,
 							std::tuple_cat(
 								std::forward_as_tuple(env),
-								js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
+								js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
 							)
 						);
 					}};
@@ -117,7 +117,7 @@ constexpr auto make_constructor_function(auto constructor) {
 								callback,
 								std::tuple_cat(
 									std::forward_as_tuple(env, value_of<object_tag>::from(info.this_arg())),
-									js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
+									js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
 								)
 							);
 							return wrap(std::move(instance));
@@ -214,7 +214,7 @@ constexpr auto make_member_function(Method method) {
 							callback,
 							std::tuple_cat(
 								std::forward_as_tuple(**maybe_that, env),
-								js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
+								js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
 							)
 						);
 					}};

package/support/callback_storage.cc

@@ -22,9 +22,13 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 			// Constant expression function, expressed entirely in the type. `data` is the environment.
 			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
 				const auto args = callback_info{nenv, info};
-				auto invoke = function_type{};
-				auto& env = *static_cast<Environment*>(args.data());
-				return invoke(env, args);
+				if (args) {
+					auto invoke = function_type{};
+					auto& env = *static_cast<Environment*>(args.data());
+					return invoke(env, args);
+				} else {
+					return {};
+				}
 			}};
 			return std::tuple{callback, &env};
 		} else if constexpr (sizeof(function_type) <= sizeof(void*)) {
@@ -34,10 +38,14 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 			auto* data = reinterpret_cast<void*&>(function);
 			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
 				const auto args = callback_info{nenv, info};
-				auto* data = args.data();
-				auto& invoke = reinterpret_cast<function_type&>(data);
-				auto& env = *callback_env_local<Environment>;
-				return invoke(env, args);
+				if (args) {
+					auto* data = args.data();
+					auto& invoke = reinterpret_cast<function_type&>(data);
+					auto& env = *callback_env_local<Environment>;
+					return invoke(env, args);
+				} else {
+					return {};
+				}
 			}};
 			return std::tuple{callback, data};
 		} else {
@@ -49,8 +57,12 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 		auto external_data = std::make_unique<pair_type>(&env, std::move(function));
 		const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
 			const auto args = callback_info{nenv, info};
-			auto& state = *static_cast<pair_type*>(args.data());
-			return state.second(*state.first, args);
+			if (args) {
+				auto& state = *static_cast<pair_type*>(args.data());
+				return state.second(*state.first, args);
+			} else {
+				return {};
+			}
 		}};
 		return std::tuple{callback, std::move(external_data)};
 	}

package/support/class_template_storage.cc

@@ -5,16 +5,6 @@ import std;
 import util;
 using namespace std::string_literals;
 
-#if _LIBCPP_VERSION || _MSVC_STL_UPDATE
-// clang 22.1.0 w/ -stdlib=libc++ (and also MS STL)
-// /workspace/packages/auto_js/napi/support/class_template_storage.cc:28:45: error: invalid operands
-// to binary expression ('basic_string<char>' and 'const std::basic_string_view<char>')
-// 28 |                         static_assert(index, "Class template '"s + name_sv + "' is missing in storage"s);
-export {
-	using std::operator+;
-}
-#endif
-
 namespace js::napi {
 
 // Given a pack of strings it returns a static reference to a `util::sealed_map` of napi object

package/transfer/accept.cc

@@ -105,15 +105,16 @@ auto accept_basic_napi_value::operator()(error_tag /*tag*/, visit_holder visit,
 // 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>> {
+	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.
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	void* bytes;
-	auto* result = napi::invoke(napi_create_arraybuffer, napi_env{*this}, subject.size(), &bytes);
+	auto* result = napi::invoke(napi_create_arraybuffer, napi_env{*this}, view.size(), &bytes);
 	// nb: `std::memcpy` *technically* results in undefined behavior on block size 0
 	// (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(std::span<const std::byte>{subject}, static_cast<std::byte*>(bytes));
+	std::ranges::copy(view, static_cast<std::byte*>(bytes));
 	auto value = value_of<array_buffer_tag>::from(result);
 	return js::referenceable_value{value};
 }
@@ -121,7 +122,7 @@ auto accept_basic_napi_value::operator()(array_buffer_tag /*tag*/, visit_holder
 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>> {
 	auto backing_store = [ & ]() -> auto {
-		auto byte_length = subject.size();
+		auto byte_length = subject.byte_length();
 		// 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) {

package/transfer/accept.h.cc

@@ -168,15 +168,16 @@ struct accept_napi_value : accept_basic_napi_value {
 		// vectors
 		auto operator()(this const auto& self, vector_tag /*tag*/, auto& visit, auto&& subject)
 			-> js::deferred_receiver<value_of<vector_tag>, decltype(self), decltype(visit), decltype(subject)> {
+			auto [... size ] = util::maybe_range_size(subject, 0);
 			return {
-				value_of<vector_tag>::from(napi::invoke(napi_create_array_with_length, napi_env{self}, subject.size())),
+				value_of<vector_tag>::from(napi::invoke(napi_create_array_with_length, napi_env{self}, size...)),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
 				[](value_of<vector_tag> array, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					int ii = 0;
 					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
-					for (auto&& subject : util::forward_range(std::forward<decltype(range)>(range))) {
-						auto* element = napi_value{visit(std::forward<decltype(subject)>(subject), self)};
-						napi::invoke0(napi_set_element, napi_env{self}, napi_value{array}, ii++, element);
+					for (auto&& element : util::forward_range(std::forward<decltype(range)>(range))) {
+						auto* item = napi_value{visit(std::forward<decltype(element)>(element), self)};
+						napi::invoke0(napi_set_element, napi_env{self}, napi_value{array}, ii++, item);
 					}
 				},
 			};

package/transfer/visit.cc

@@ -153,48 +153,101 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 			// Check the reference map, and lookup type via napi
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
-				auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
-				switch (type_of) {
-					case napi_undefined:
-						return (*this)(value_of<undefined_tag>::from(subject), accept);
-					case napi_null:
-						return (*this)(value_of<null_tag>::from(subject), accept);
-					case napi_boolean:
-						return (*this)(value_of<boolean_tag>::from(subject), accept);
-					case napi_number:
-						return (*this)(value_of<number_tag>::from(subject), accept);
-					case napi_string:
-						return immediate(value_of<string_tag>::from(subject), accept);
-					case napi_symbol:
-						return immediate(value_of<symbol_tag>::from(subject), accept);
-					case napi_object:
-						{
-							if (napi::invoke(napi_is_array, napi_env{*this}, subject)) {
-								return immediate(value_of<list_tag>::from(subject), accept);
-							} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
-								return immediate(value_of<date_tag>::from(subject), accept);
-							} else if (napi::invoke(napi_is_typedarray, napi_env{*this}, subject)) {
-								return immediate(value_of<typed_array_tag>::from(subject), accept);
-							} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
-								return immediate(value_of<data_view_tag>::from(subject), accept);
-							} else if (std::bit_cast<v8::Local<v8::Object>>(subject)->IsSharedArrayBuffer()) {
-								return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
-							} else if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
-								return immediate(value_of<array_buffer_tag>::from(subject), accept);
-							} else if (napi::invoke(napi_is_promise, napi_env{*this}, subject)) {
-								return immediate(value_of<promise_tag>::from(subject), accept);
-							} else {
-								return immediate(value_of<dictionary_tag>::from(subject), accept);
+				auto v8_subject = std::bit_cast<v8::Local<v8::Value>>(subject);
+				return util::template_traverse(
+					accept_tags_of_v<Accept>,
+					util::overloaded{
+						// Fast paths
+						[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsUndefined() ? (*this)(value_of<undefined_tag>::from(subject), accept) : next();
+						},
+						[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsNull() ? (*this)(value_of<null_tag>::from(subject), accept) : next();
+						},
+						[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsBoolean() ? (*this)(value_of<boolean_tag>::from(subject), accept) : next();
+						},
+						[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsNumber() ? (*this)(value_of<number_tag>::from(subject), accept) : next();
+						},
+						[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsString() ? immediate(value_of<string_tag>::from(subject), accept) : next();
+						},
+						[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsBigInt() ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
+						},
+						[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsDate() ? immediate(value_of<date_tag>::from(subject), accept) : next();
+						},
+						[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsArray() ? immediate(value_of<list_tag>::from(subject), accept) : next();
+						},
+						[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
+							// checks. We don't really want to accept those types here, I don't think..
+							return v8_subject->IsObject() ? immediate(value_of<object_tag>::from(subject), accept) : next();
+						},
+						[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return v8_subject->IsFunction() ? immediate(value_of<function_tag>::from(subject), accept) : next();
+						},
+
+						// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
+						// differentiate between.
+						[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+						[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+
+						// Unknown tag
+						[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+
+						// Slow path
+						[ & ]() -> accept_target_t<Accept> {
+							auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
+							switch (type_of) {
+								case napi_undefined:
+									return (*this)(value_of<undefined_tag>::from(subject), accept);
+								case napi_null:
+									return (*this)(value_of<null_tag>::from(subject), accept);
+								case napi_boolean:
+									return (*this)(value_of<boolean_tag>::from(subject), accept);
+								case napi_number:
+									return (*this)(value_of<number_tag>::from(subject), accept);
+								case napi_string:
+									return immediate(value_of<string_tag>::from(subject), accept);
+								case napi_symbol:
+									return immediate(value_of<symbol_tag>::from(subject), accept);
+								case napi_object:
+									return immediate(value_of<object_tag>::from(subject), accept);
+								case napi_function:
+									return immediate(value_of<function_tag>::from(subject), accept);
+								case napi_external:
+									return immediate(value_of<external_tag>::from(subject), accept);
+								case napi_bigint:
+									return immediate(value_of<bigint_tag>::from(subject), accept);
 							}
+							std::unreachable();
+						},
+					}
+				);
+			});
+		}
+
+		template <class Accept>
+		auto operator()(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+				return util::template_traverse(
+					accept_tags_of_v<Accept>,
+					util::overloaded{
+						// Fast paths
+						[ & ](data_block_tag /*tag*/, auto /*next*/) -> accept_target_t<Accept> { return accept_tagged(subject, accept); },
+						[ & ](array_buffer_tag /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+						[ & ](shared_array_buffer_tag /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+
+						// Slow path
+						[ & ]() -> accept_target_t<Accept> {
+							return immediate(subject, accept);
 						}
-					case napi_function:
-						return immediate(value_of<function_tag>::from(subject), accept);
-					case napi_external:
-						return immediate(value_of<external_tag>::from(subject), accept);
-					case napi_bigint:
-						return immediate(value_of<bigint_tag>::from(subject), accept);
-				}
-				std::unreachable();
+					}
+				);
 			});
 		}
 
@@ -206,7 +259,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 	private:
 		// I think this only applies to `symbol_tag`
 		template <class Accept, class Tag>
-			requires std::is_base_of_v<primitive_tag, Tag>
+			requires std::is_convertible_v<Tag, primitive_tag>
 		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
@@ -227,6 +280,28 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 			return accept_tagged(value_of<bigint_tag_of<bigint>>::from(subject), accept);
 		}
 
+		// date
+		template <class Accept>
+		auto immediate(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (napi::invoke(napi_is_array, napi_env{*this}, subject)) {
+				return immediate(value_of<list_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
+				return immediate(value_of<date_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_typedarray, napi_env{*this}, subject)) {
+				return immediate(value_of<typed_array_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
+				return immediate(value_of<data_view_tag>::from(subject), accept);
+			} else if (std::bit_cast<v8::Local<v8::Object>>(subject)->IsSharedArrayBuffer()) {
+				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
+				return immediate(value_of<array_buffer_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_promise, napi_env{*this}, subject)) {
+				return immediate(value_of<promise_tag>::from(subject), accept);
+			} else {
+				return immediate(value_of<dictionary_tag>::from(subject), accept);
+			}
+		}
+
 		// date
 		template <class Accept>
 		auto immediate(value_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
@@ -244,7 +319,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		template <class Accept, class Tag>
-			requires std::is_base_of_v<data_block_tag, Tag>
+			requires std::is_convertible_v<Tag, data_block_tag>
 		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}

package/value/array_buffer.cc

@@ -6,6 +6,14 @@ import v8;
 
 namespace js::napi {
 
+// `bound_value_for_data_block`
+bound_value_for_data_block::operator std::span<std::byte>() const {
+	auto local = std::bit_cast<v8::Local<v8::ArrayBuffer>>(napi_value{*this});
+	auto* data = reinterpret_cast<std::byte*>(local->Data());
+	auto byte_length = local->ByteLength();
+	return std::span{data, byte_length};
+}
+
 // `bound_value_for_array_buffer`
 bound_value_for_array_buffer::operator js::array_buffer() const {
 	return js::array_buffer{std::span<std::byte>{*this}};
@@ -17,7 +25,7 @@ bound_value_for_array_buffer::operator std::span<std::byte>() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	std::size_t byte_length;
 	napi::invoke0(napi_get_arraybuffer_info, env(), napi_value{*this}, &bytes, &byte_length);
-	return std::span<std::byte>{reinterpret_cast<std::byte*>(bytes), byte_length};
+	return std::span{reinterpret_cast<std::byte*>(bytes), byte_length};
 }
 
 // `bound_value_for_shared_array_buffer`
@@ -31,7 +39,7 @@ bound_value_for_shared_array_buffer::operator js::shared_array_buffer() const {
 
 bound_value_for_shared_array_buffer::operator std::span<std::byte>() const {
 	auto local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{*this});
-	return std::span<std::byte>{reinterpret_cast<std::byte*>(local->Data()), local->ByteLength()};
+	return std::span{reinterpret_cast<std::byte*>(local->Data()), local->ByteLength()};
 }
 
 // `value_for_typed_array`
@@ -56,7 +64,7 @@ auto bound_value_for_typed_array::make_bound(const environment& env, value_of<ty
 	switch (type_tag) {
 		case napi_bigint64_array: return make(typed_array_tag_of<std::int64_t>{});
 		case napi_biguint64_array: return make(typed_array_tag_of<std::uint64_t>{});
-		case napi_float16_array: throw std::logic_error{"unsupported"};
+		case napi_float16_array: return make(typed_array_tag_of<js::float16_t>{});
 		case napi_float32_array: return make(typed_array_tag_of<float>{});
 		case napi_float64_array: return make(typed_array_tag_of<double>{});
 		case napi_int16_array: return make(typed_array_tag_of<std::int16_t>{});
@@ -65,7 +73,7 @@ auto bound_value_for_typed_array::make_bound(const environment& env, value_of<ty
 		case napi_uint16_array: return make(typed_array_tag_of<std::uint16_t>{});
 		case napi_uint32_array: return make(typed_array_tag_of<std::uint32_t>{});
 		case napi_uint8_array: return make(typed_array_tag_of<std::uint8_t>{});
-		case napi_uint8_clamped_array: return make(typed_array_tag_of<std::byte>{});
+		case napi_uint8_clamped_array: return make(typed_array_tag_of<js::uint8_clamped_t>{});
 	}
 	std::unreachable();
 }

package/value/array_buffer.h.cc

@@ -7,11 +7,21 @@ import v8;
 
 namespace js::napi {
 
+// Data blocks
+class bound_value_for_data_block : public bound_value_next<data_block_tag> {
+	public:
+		using bound_value_next<data_block_tag>::bound_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(); }
+		explicit operator std::span<std::byte>() const;
+};
+
 // `ArrayBuffer`
 class bound_value_for_array_buffer : public bound_value_next<array_buffer_tag> {
 	public:
 		using bound_value_next<array_buffer_tag>::bound_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(); }
 		explicit operator js::array_buffer() const;
 		explicit operator std::span<std::byte>() const;
 };
@@ -20,7 +30,8 @@ class bound_value_for_array_buffer : public bound_value_next<array_buffer_tag> {
 class bound_value_for_shared_array_buffer : public bound_value_next<shared_array_buffer_tag> {
 	public:
 		using bound_value_next<shared_array_buffer_tag>::bound_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(); }
 		explicit operator js::shared_array_buffer() const;
 		explicit operator std::span<std::byte>() const;
 };
@@ -62,7 +73,8 @@ class bound_value_for_typed_array : public bound_value_next<typed_array_tag> {
 		using any_bound_typed_array = std::variant<
 			bound_value<typed_array_tag_of<double>>,
 			bound_value<typed_array_tag_of<float>>,
-			bound_value<typed_array_tag_of<std::byte>>,
+			bound_value<typed_array_tag_of<js::float16_t>>,
+			bound_value<typed_array_tag_of<js::uint8_clamped_t>>,
 			bound_value<typed_array_tag_of<std::int16_t>>,
 			bound_value<typed_array_tag_of<std::int32_t>>,
 			bound_value<typed_array_tag_of<std::int64_t>>,
@@ -92,7 +104,8 @@ class value_for_typed_array_of : public value_next<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; },
-				[](std::type_identity<std::byte>) -> napi_typedarray_type { return napi_uint8_clamped_array; },
+				[](std::type_identity<js::float16_t>) -> napi_typedarray_type { return napi_float16_array; },
+				[](std::type_identity<js::uint8_clamped_t>) -> napi_typedarray_type { return napi_uint8_clamped_array; },
 				[](std::type_identity<std::int16_t>) -> napi_typedarray_type { return napi_int16_array; },
 				[](std::type_identity<std::int32_t>) -> napi_typedarray_type { return napi_int32_array; },
 				[](std::type_identity<std::int64_t>) -> napi_typedarray_type { return napi_bigint64_array; },
@@ -110,7 +123,8 @@ class value_for_typed_array_of : public value_next<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 {}; },
-				[](std::type_identity<std::byte>) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
+				[](std::type_identity<js::float16_t>) -> std::type_identity<v8::Float16Array> { return {}; },
+				[](std::type_identity<js::uint8_clamped_t>) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
 				[](std::type_identity<std::int16_t>) -> std::type_identity<v8::Int16Array> { return {}; },
 				[](std::type_identity<std::int32_t>) -> std::type_identity<v8::Int32Array> { return {}; },
 				[](std::type_identity<std::int64_t>) -> std::type_identity<v8::BigInt64Array> { return {}; },

package/value/class.cc

@@ -37,7 +37,7 @@ template <class Type>
 template <class... Args>
 auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value_of<object_tag> {
 	using element_type = decltype(instance)::element_type;
-	auto construct = [ & ](napi_value this_arg) mutable -> napi_value {
+	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>);
 

package/value/function.cc

@@ -6,14 +6,14 @@ namespace js::napi {
 
 template <class Result>
 auto value_for_function::apply(auto_environment auto& env, auto&& args) -> Result {
-	auto arg_values = js::transfer_in_strict<std::vector<napi_value>>(std::forward<decltype(args)>(args), env);
-	return invoke<Result>(env, std::span{arg_values});
+	auto argv = js::transfer_in_strict<std::vector<napi_value>>(std::forward<decltype(args)>(args), env);
+	return invoke<Result>(env, std::span{argv});
 }
 
 template <class Result>
 auto value_for_function::call(auto_environment auto& env, auto&&... args) -> Result {
-	auto arg_values = js::transfer_in_strict<std::array<napi_value, sizeof...(args)>>(std::forward_as_tuple(args...), env);
-	return invoke<Result>(env, std::span{arg_values});
+	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});
 }
 
 template <class Result>

package/value/primitive.cc

@@ -20,14 +20,6 @@ bound_value_for_number::operator std::int32_t() const {
 	return napi::invoke(napi_get_value_int32, env(), napi_value{*this});
 }
 
-bound_value_for_number::operator std::int64_t() const {
-	return napi::invoke(napi_get_value_int64, env(), napi_value{*this});
-}
-
-bound_value_for_number::operator std::uint32_t() const {
-	return napi::invoke(napi_get_value_uint32, env(), napi_value{*this});
-}
-
 // bigint
 bound_value_for_bigint::operator bigint() const {
 	js::bigint value;
@@ -55,13 +47,6 @@ bound_value_for_bigint::operator std::int64_t() const {
 	return value;
 }
 
-bound_value_for_bigint::operator std::uint64_t() const {
-	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-	std::uint64_t value;
-	napi::invoke(napi_get_value_bigint_uint64, env(), napi_value{*this}, &value);
-	return value;
-}
-
 // string
 bound_value_for_string::operator std::string() const {
 	std::string string;

package/value/primitive.h.cc

@@ -19,8 +19,6 @@ class bound_value_for_number : public bound_value_next<number_tag> {
 		using bound_value_next<number_tag>::bound_value_next;
 		[[nodiscard]] explicit operator double() const;
 		[[nodiscard]] explicit operator std::int32_t() const;
-		[[nodiscard]] explicit operator std::int64_t() const;
-		[[nodiscard]] explicit operator std::uint32_t() const;
 };
 
 // bigint
@@ -29,7 +27,6 @@ class bound_value_for_bigint : public bound_value_next<bigint_tag> {
 		using bound_value_next<bigint_tag>::bound_value_next;
 		[[nodiscard]] explicit operator bigint() const;
 		[[nodiscard]] explicit operator std::int64_t() const;
-		[[nodiscard]] explicit operator std::uint64_t() const;
 };
 
 // string