@auto_js/v8 0.0.2 → 0.0.5

package/CMakeLists.txt

@@ -49,10 +49,13 @@ target_sources("${TARGET_NAME}"
 		value/array.h.cc
 		value/callback_info.cc
 		value/fixed_array.h.cc
+		value/function.cc
+		value/function.h.cc
 		value/handle.cc
 		value/object.h.cc
 		value/primitive.h.cc
 		value/tag.cc
+		value/value.cc
 )
 
 if(TARGET_NAME STREQUAL "embedded_v8_js")

package/_module.cc

@@ -1,21 +1,18 @@
 export module v8_js;
 export import :accept;
-export import :array_buffer;
-export import :array;
 export import :boost;
 export import :callback_info;
 export import :callback;
 export import :collected_handle;
 export import :error;
-export import :fixed_array;
+export import :function_definitions;
 export import :handle;
 export import :handle.value;
 export import :hash;
 export import :lock;
-export import :object;
-export import :primitive;
 export import :remote;
 export import :unmaybe;
+export import :value;
 export import :value.tag;
 export import :visit;
 export import :weak_map;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@auto_js/v8",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/v8",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/js": "^0.0.2",
-    "@auto_js/v8_exports": "^0.0.2"
+    "@auto_js/js": "^0.0.5",
+    "@auto_js/v8_exports": "^0.0.3"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -35,7 +35,7 @@ constexpr auto make_free_function_with_try_catch =
 						callback,
 						std::tuple_cat(
 							std::forward_as_tuple(lock),
-							js::transfer_out<std::tuple<Args...>>(info, lock)
+							js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info, lock)
 						)
 					);
 				}};

package/support/callback_storage.cc

@@ -15,9 +15,7 @@ constexpr auto make_plain_callback =
 	) -> auto {
 	return util::bind{
 		[](auto& function, const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
-			auto isolate_witness = isolate_lock_witness::make_witness(info.GetIsolate());
-			auto context_witness = context_lock_witness::from_isolate(isolate_witness);
-			function(context_witness, info);
+			function(context_lock_witness{info}, info);
 		},
 		std::move(function),
 	};
@@ -32,9 +30,8 @@ constexpr auto make_decorated_callback =
 	) -> auto {
 	return util::bind{
 		[](auto& agent, auto& function, const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
-			auto isolate_witness = isolate_lock_witness::make_witness(info.GetIsolate());
-			auto context_witness = context_lock_witness::from_isolate(isolate_witness);
-			auto decorated_witness = context_lock_witness_of<Agent, Implements...>{context_witness, agent};
+			auto witness = context_lock_witness{info};
+			auto decorated_witness = context_lock_witness_of<Agent, Implements...>{witness, agent};
 			function(decorated_witness, info);
 		},
 		std::ref(*lock),

package/support/lock.cc

@@ -36,10 +36,6 @@ isolate_unlock::isolate_unlock(isolate_lock_witness lock) :
 		unlocker_{lock.isolate()} {}
 
 // `context_lock_witness`
-auto context_lock_witness::from_isolate(isolate_lock_witness lock) -> context_lock_witness {
-	return context_lock_witness{lock, lock.isolate()->GetCurrentContext()};
-}
-
 auto context_lock_witness::make_witness(isolate_lock_witness lock, v8::Local<v8::Context> context) -> context_lock_witness {
 	return context_lock_witness{lock, context};
 }

package/support/lock.h.cc

@@ -105,8 +105,11 @@ export class context_lock_witness : public isolate_lock_witness {
 				context_{context} {}
 
 	public:
+		explicit context_lock_witness(const v8::FunctionCallbackInfo<v8::Value>& info) :
+				isolate_lock_witness{isolate_lock_witness::make_witness(info.GetIsolate())},
+				context_{isolate()->GetCurrentContext()} {}
+
 		[[nodiscard]] auto context() const -> v8::Local<v8::Context> { return context_; }
-		[[nodiscard]] static auto from_isolate(isolate_lock_witness lock) -> context_lock_witness;
 		[[nodiscard]] static auto make_witness(isolate_lock_witness lock, v8::Local<v8::Context> context) -> context_lock_witness;
 
 	private:

package/transfer/accept.cc

@@ -108,14 +108,14 @@ auto accept_v8_value::operator()(error_tag /*tag*/, visit_holder /*visit*/, cons
 }
 
 // function
-auto accept_v8_value::operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, v8::Local<v8::FunctionTemplate> subject) const -> v8::Local<v8::Function> {
-	return unmaybe(subject->GetFunction(context_));
+auto accept_v8_value::operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, v8::Local<v8::FunctionTemplate> subject) const -> v8::Local<iv8::Function> {
+	return unmaybe(subject->GetFunction(context_).As<iv8::Function>());
 }
 
 // data blocks
 auto accept_v8_value::operator()(array_buffer_tag /*tag*/, visit_holder /*visit*/, js::array_buffer subject) const
 	-> js::referenceable_value<v8::Local<v8::ArrayBuffer>> {
-	auto byte_length = subject.size();
+	auto byte_length = subject.byte_length();
 	auto backing_store = v8::ArrayBuffer::NewBackingStore(
 		std::move(subject).acquire_ownership().release(),
 		byte_length,
@@ -130,7 +130,7 @@ auto accept_v8_value::operator()(array_buffer_tag /*tag*/, visit_holder /*visit*
 
 auto accept_v8_value::operator()(shared_array_buffer_tag /*tag*/, visit_holder /*visit*/, js::shared_array_buffer&& subject) const
 	-> js::referenceable_value<v8::Local<v8::SharedArrayBuffer>> {
-	auto byte_length = subject.size();
+	auto byte_length = subject.byte_length();
 	auto backing_store = [ & ]() -> auto {
 		if (byte_length == 0) {
 			// v8 does not call the deleter if `byte_length` is zero. So the heap-allocated shared_ptr

package/transfer/accept.h.cc

@@ -1,8 +1,7 @@
 export module v8_js:accept;
-import :array_buffer;
 import :callback_storage;
 import :hash;
-import :primitive;
+import :value;
 import auto_js;
 import std;
 import util;
@@ -105,6 +104,7 @@ struct accept_v8_primitive {
 struct accept_v8_value : accept_v8_primitive {
 	public:
 		using accept_type = accept_v8_primitive;
+		using accept_target_type = v8::Local<v8::Value>;
 		explicit accept_v8_value(auto* transfer, context_lock_witness lock) :
 				accept_type{transfer, lock},
 				context_{lock.context()} {}
@@ -155,7 +155,7 @@ struct accept_v8_value : accept_v8_primitive {
 		}
 
 		// function
-		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, v8::Local<v8::FunctionTemplate> subject) const -> v8::Local<v8::Function>;
+		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, v8::Local<v8::FunctionTemplate> subject) const -> v8::Local<iv8::Function>;
 
 		// array
 		auto operator()(this const auto& self, list_tag /*tag*/, auto& visit, auto&& subject)
@@ -177,6 +177,40 @@ struct accept_v8_value : accept_v8_primitive {
 			};
 		}
 
+		// vectors
+		auto operator()(this const auto& self, vector_tag /*tag*/, auto& visit, auto&& subject)
+			-> js::deferred_receiver<v8::Local<v8::Array>, decltype(self), decltype(visit), decltype(subject)> {
+			auto [... size ] = util::maybe_range_size(subject);
+			return {
+				v8::Array::New(self.isolate(), size...),
+				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
+				[](v8::Local<v8::Array> array, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+					std::uint32_t ii = 0;
+					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
+					for (auto&& element : util::forward_range(std::forward<decltype(range)>(range))) {
+						auto item = visit(std::forward<decltype(element)>(element), self);
+						unmaybe(array->Set(self.context_, ii++, item));
+					}
+				},
+			};
+		}
+
+		template <std::size_t Size>
+		auto operator()(this const auto& self, tuple_tag<Size> /*tag*/, auto& visit, auto&& subject)
+			-> js::deferred_receiver<v8::Local<v8::Array>, decltype(self), decltype(visit), decltype(subject)> {
+			return {
+				v8::Array::New(self.isolate(), Size),
+				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
+				[](v8::Local<v8::Array> array, auto& self, auto& visit, auto /*&&*/ tuple) -> void {
+					const auto [... indices ] = util::sequence<Size>;
+					(..., [ & ]() -> void {
+						auto element = visit(indices, std::forward<decltype(tuple)>(tuple), self);
+						unmaybe(array->Set(self.context_, indices, element));
+					}());
+				}
+			};
+		}
+
 		// object
 		auto operator()(this const auto& self, dictionary_tag /*tag*/, auto& visit, auto&& subject)
 			-> js::deferred_receiver<v8::Local<v8::Object>, decltype(self), decltype(visit), decltype(subject)> {
@@ -236,7 +270,7 @@ struct accept_v8_value : accept_v8_primitive {
 		auto operator()(this const auto& self, struct_tag<Size> /*tag*/, auto& visit, auto&& subject)
 			-> js::deferred_receiver<v8::Local<v8::Object>, decltype(self), decltype(visit), decltype(subject)> {
 			return {
-				v8::Local<v8::Object>::New(self.isolate()),
+				v8::Object::New(self.isolate()),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
 				[](v8::Local<v8::Object> object, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					self.template accept_entry_pair_struct<Size>(visit, object, std::forward<decltype(subject)>(subject));
@@ -269,10 +303,10 @@ struct accept_v8_value_with<context_lock_witness> : accept_v8_value {
 		using accept_v8_value::witness;
 
 		// function instantiation
-		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<v8::Function> {
+		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<iv8::Function> {
 			auto [ function, length ] = make_free_function<context_lock_witness>(std::move(subject).callback);
 			auto [ callback, data ] = make_callback_storage(witness(), std::move(function));
-			return unmaybe(v8::Function::New(witness().context(), callback, data, length, v8::ConstructorBehavior::kThrow));
+			return unmaybe(v8::Function::New(witness().context(), callback, data, length, v8::ConstructorBehavior::kThrow).template As<iv8::Function>());
 		}
 };
 
@@ -286,7 +320,7 @@ struct accept_v8_value_with : accept_v8_value {
 		using accept_v8_value::operator();
 
 		// function instantiation
-		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<v8::Function> {
+		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<iv8::Function> {
 			auto [ function, length ] = make_free_function<Lock>(std::move(subject).callback);
 			auto [ callback, data ] = make_callback_storage(lock_.get(), std::move(function));
 			return v8::Function::New(lock_.get().context(), callback, data, length, v8::ConstructorBehavior::kThrow);
@@ -315,6 +349,27 @@ struct accept_v8_template : accept_v8_primitive {
 		std::reference_wrapper<const Lock> lock_;
 };
 
+// object key lookup (struct_template, etc)
+template <class Meta, auto Key, class Type>
+struct accept_v8_property_value {
+	public:
+		explicit constexpr accept_v8_property_value(auto* transfer) :
+				first{transfer},
+				second{transfer} {}
+
+		auto operator()(dictionary_tag /*tag*/, auto& visit, const auto& subject) const -> Type {
+			if (auto local = first(std::type_identity<void>{}, visit.first); subject.has(local)) {
+				return visit.second(subject.get(local), second);
+			} else {
+				return second(undefined_in_tag{}, visit.second, std::monostate{});
+			}
+		}
+
+	private:
+		mutable visit_key_literal<Key, v8::Local<v8::Object>> first;
+		accept_value<Meta, Type> second;
+};
+
 // `return_into(...)`
 struct return_into_marker {};
 
@@ -360,8 +415,9 @@ struct accept_v8_return_into : accept_v8_value_with<Lock> {
 		}
 
 		auto operator()(auto tag, auto& visit, auto&& subject) const -> return_into_marker
-			requires std::invocable<const accept_type&, decltype(visit), decltype(tag), decltype(subject)> {
-			return_value_.Set(util::invoke_as<accept_type>(*this, tag, visit, std::forward<decltype(subject)>(subject)));
+			requires std::invocable<const accept_type&, decltype(tag), decltype(visit), decltype(subject)> {
+			auto value = util::invoke_as<accept_type>(*this, tag, visit, std::forward<decltype(subject)>(subject));
+			return_value_.Set(js::dispatch_referenceable(std::move(value)));
 			return {};
 		}
 
@@ -403,9 +459,12 @@ struct accept_v8_object_assign {
 
 namespace js {
 
+template <class Type>
+struct accept_property_subject<v8::Local<Type>> : std::type_identity<v8::Local<v8::Object>> {};
+
 // primitives
 template <class Meta, class Type>
-	requires std::is_base_of_v<v8::Primitive, Type>
+	requires std::is_convertible_v<Type, v8::Primitive>
 struct accept<Meta, v8::Local<Type>> : iv8::accept_v8_primitive {
 		using accept_v8_primitive::accept_v8_primitive;
 };
@@ -418,7 +477,7 @@ struct accept<Meta, v8::Local<Type>> : iv8::accept_v8_value_with<typename Meta::
 
 // templates
 template <class Meta, class Type>
-	requires std::is_base_of_v<v8::Template, Type>
+	requires std::is_convertible_v<Type, v8::Template>
 struct accept<Meta, v8::Local<Type>> : iv8::accept_v8_template<Meta, typename Meta::accept_context_type> {
 		using iv8::accept_v8_template<Meta, typename Meta::accept_context_type>::accept_v8_template;
 };
@@ -441,7 +500,16 @@ struct accept<Meta, v8::MaybeLocal<Type>> : accept<Meta, v8::Local<Type>> {
 		}
 };
 
+// object key lookup (struct_template, etc)
+template <class Meta, auto Key, class Type>
+struct accept_property_value<Meta, Key, Type, v8::Local<v8::Object>> : iv8::accept_v8_property_value<Meta, Key, Type> {
+		using iv8::accept_v8_property_value<Meta, Key, Type>::accept_v8_property_value;
+};
+
 // return_into
+template <>
+struct accept_property_subject<iv8::return_into_marker> : accept_property_subject<v8::Local<v8::Value>> {};
+
 template <class Meta>
 struct accept<Meta, iv8::return_into_marker> : iv8::accept_v8_return_into<typename Meta::accept_context_type> {
 		using iv8::accept_v8_return_into<typename Meta::accept_context_type>::accept_v8_return_into;

package/transfer/visit.cc

@@ -3,8 +3,8 @@ import :array_buffer;
 import :callback_info;
 import :handle.value;
 import :hash;
-import :object;
 import :unmaybe;
+import :value;
 import auto_js;
 import std;
 import v8;
@@ -30,14 +30,14 @@ struct visit_property_name {
 					auto value = value_of{witness(), subject.As<tag_to_v8<Tag>>()};
 					return accept(tag, *this, value);
 				};
-				if (subject->IsNumber()) {
-					return accept_as(number_tag_of<std::int32_t>{});
-				} else if (subject->IsString()) {
+				if (subject->IsString()) {
 					if (subject.As<v8::String>()->IsOneByte()) {
 						return accept_as(string_tag_of<char>{});
 					} else {
 						return accept_as(string_tag_of<char16_t>{});
 					}
+				} else if (subject->IsNumber()) {
+					return accept_as(number_tag_of<std::int32_t>{});
 				} else {
 					return accept_as(symbol_tag{});
 				}
@@ -51,6 +51,23 @@ struct visit_property_name {
 		std::reference_wrapper<Visit> visit_;
 };
 
+// `visit_key_literal` instantiation for v8
+template <auto Key>
+struct visit_v8_key_literal {
+		explicit constexpr visit_v8_key_literal(auto* /*transfer*/) {}
+
+		auto operator()(const auto& /*anything*/, const auto& accept_or_visit) -> v8::Local<v8::Name> {
+			if (local_key_.IsEmpty()) {
+				constexpr auto key = util::make_consteval_string_view(Key);
+				local_key_ = transfer_in<v8::Local<v8::Name>>(key, accept_or_visit.witness());
+			}
+			return local_key_;
+		}
+
+	private:
+		v8::Local<v8::Name> local_key_;
+};
+
 // Implements `Visit`'s non-caching `immediate()` function as a caching visit operation.
 template <class Visit>
 struct visit_cached_immediate : Visit {
@@ -126,14 +143,10 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 		// primitives
 		template <class Accept>
 		auto immediate(v8::Local<v8::Primitive> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (subject->IsNullOrUndefined()) {
-				if (subject->IsNull()) {
-					null_ = subject;
-					return accept(null_tag{}, *this, subject);
-				} else {
-					undefined_ = subject;
-					return accept(undefined_tag{}, *this, subject);
-				}
+			if (subject->IsUndefined()) {
+				return accept(undefined_tag{}, *this, subject);
+			} else if (subject->IsNull()) {
+				return accept(null_tag{}, *this, subject);
 			} else if (subject->IsNumber()) {
 				return (*this)(subject.As<v8::Number>(), accept);
 			} else if (subject->IsName()) {
@@ -148,7 +161,7 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 		}
 
 		template <class Accept, class Type>
-			requires std::is_base_of_v<primitive_tag, iv8::v8_to_tag<Type>>
+			requires std::is_convertible_v<Type, v8::Primitive>
 		auto immediate(v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
@@ -201,7 +214,7 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 		}
 
 		template <class Accept, class Type>
-			requires std::is_base_of_v<data_block_tag, iv8::v8_to_tag<Type>>
+			requires std::is_convertible_v<iv8::v8_to_tag<Type>, data_block_tag>
 		auto immediate(v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
@@ -212,15 +225,16 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 			return accept_tagged(subject, accept);
 		}
 
-		// promise (cannot be accepted)
+		// promise (maybe could be forwarded)
 		template <class Accept>
 		auto immediate(v8::Local<v8::Promise> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept(promise_tag{}, *this, subject);
 		}
 
-		// function (cannot be accepted)
-		template <class Accept>
-		auto immediate(v8::Local<v8::Function> subject, const Accept& accept) -> accept_target_t<Accept> {
+		// function (can be forwarded)
+		template <class Type, class Accept>
+			requires std::is_convertible_v<Type, v8::Function>
+		auto immediate(v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept(function_tag{}, *this, subject);
 		}
 
@@ -230,13 +244,8 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 			return accept(iv8::v8_to_tag<Type>{}, *this, value_of{witness(), subject});
 		}
 
-		[[nodiscard]] auto is_cached_null(v8::Local<v8::Value> value) const { return value == null_; }
-		[[nodiscard]] auto is_cached_undefined(v8::Local<v8::Value> value) const { return value == undefined_; }
-
 	private:
 		isolate_lock_witness isolate_lock_;
-		v8::Local<v8::Primitive> null_;
-		v8::Local<v8::Primitive> undefined_;
 };
 
 // Primary visitor w/ `context_lock_witness`
@@ -251,9 +260,8 @@ struct visit_value : visit_flat_value<Target> {
 	public:
 		friend struct visit_flat_value<Target>;
 		using visit_type = visit_flat_value<Target>;
+		using visit_type::accept_tagged;
 		using visit_type::immediate;
-		using visit_type::is_cached_null;
-		using visit_type::is_cached_undefined;
 		using visit_type::lookup_or_visit;
 		using visit_type::witness;
 		using visit_type::operator();
@@ -266,27 +274,74 @@ struct visit_value : visit_flat_value<Target> {
 
 		template <class Accept>
 		auto operator()(v8::Local<v8::Value> subject, const Accept& accept) -> accept_target_t<Accept> {
-			// Check known address values before the map lookup
-			if (is_cached_null(subject)) {
-				return accept(null_tag{}, *this, subject);
-			} else if (is_cached_undefined(subject)) {
-				return accept(undefined_tag{}, *this, subject);
-			}
 
 			// Check the reference map, and check type
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
-				if (subject->IsObject()) {
-					return immediate(subject.As<v8::Object>(), accept);
-				} else {
-					return immediate(subject.As<v8::Primitive>(), accept);
-				}
+				return util::template_traverse(
+					accept_tags_of_v<Accept>,
+					util::overloaded{
+						// Fast paths
+						[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsUndefined() ? accept(undefined_tag{}, *this, subject.As<iv8::Undefined>()) : next();
+						},
+						[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsNull() ? accept(null_tag{}, *this, subject.As<iv8::Null>()) : next();
+						},
+						[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsBoolean() ? (*this)(subject.As<v8::Boolean>(), accept) : next();
+						},
+						[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsNumber() ? (*this)(subject.As<v8::Number>(), accept) : next();
+						},
+						[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsString() ? immediate(subject.As<v8::String>(), accept) : next();
+						},
+						[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsBigInt() ? immediate(subject.As<v8::BigInt>(), accept) : next();
+						},
+						[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsDate() ? immediate(subject.As<v8::Date>(), accept) : next();
+						},
+						[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsArray() ? immediate(subject.As<v8::Array>(), accept) : next();
+						},
+						[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+							return subject->IsFunction() ? immediate(subject.As<iv8::Function>(), accept) : next();
+						},
+
+						// Unknown tag
+						[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+
+						// Slow path
+						[ & ]() -> accept_target_t<Accept> {
+							if (subject->IsObject()) {
+								return immediate(subject.As<v8::Object>(), accept);
+							} else {
+								return immediate(subject.As<v8::Primitive>(), accept);
+							}
+						},
+					}
+				);
 			});
 		}
 
 		template <class Accept>
 		auto operator()(v8::Local<iv8::DataBlock> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
-				return immediate(subject, 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);
+						}
+					}
+				);
 			});
 		}
 
@@ -314,7 +369,7 @@ struct visit_value : visit_flat_value<Target> {
 			} else if (subject->IsPromise()) {
 				return immediate(subject.As<v8::Promise>(), accept);
 			} else if (subject->IsFunction()) {
-				return immediate(subject.As<v8::Function>(), accept);
+				return immediate(subject.As<iv8::Function>(), accept);
 			} else {
 				auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
 				return accept(dictionary_tag{}, visit_entry, value_of{witness(), subject.As<v8::Object>()});
@@ -341,6 +396,8 @@ struct visit_value : visit_flat_value<Target> {
 				return immediate(subject.As<v8::Uint8Array>(), accept);
 			} else if (subject->IsDataView()) {
 				return immediate(subject.As<v8::DataView>(), accept);
+			} else if (subject->IsUint8ClampedArray()) {
+				return immediate(subject.As<v8::Uint8ClampedArray>(), accept);
 			} else if (subject->IsInt8Array()) {
 				return immediate(subject.As<v8::Int8Array>(), accept);
 			} else if (subject->IsUint16Array()) {
@@ -351,6 +408,8 @@ struct visit_value : visit_flat_value<Target> {
 				return immediate(subject.As<v8::Uint32Array>(), accept);
 			} else if (subject->IsInt32Array()) {
 				return immediate(subject.As<v8::Int32Array>(), accept);
+			} else if (subject->IsFloat16Array()) {
+				return immediate(subject.As<v8::Float16Array>(), accept);
 			} else if (subject->IsFloat32Array()) {
 				return immediate(subject.As<v8::Float32Array>(), accept);
 			} else if (subject->IsFloat64Array()) {
@@ -359,15 +418,13 @@ struct visit_value : visit_flat_value<Target> {
 				return immediate(subject.As<v8::BigInt64Array>(), accept);
 			} else if (subject->IsBigUint64Array()) {
 				return immediate(subject.As<v8::BigUint64Array>(), accept);
-			} else if (subject->IsUint8ClampedArray()) {
-				return immediate(subject.As<v8::Uint8ClampedArray>(), accept);
 			} else {
 				throw js::type_error{u"Received exotic v8 'ArrayBufferView'"};
 			}
 		}
 
 		template <class Accept, class Type>
-			requires std::is_base_of_v<array_buffer_view_tag, v8_to_tag<Type>>
+			requires std::is_convertible_v<Type, v8::ArrayBufferView>
 		auto immediate(v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept(v8_to_tag<Type>{}, *this, value_of{witness(), subject});
 		}
@@ -399,7 +456,7 @@ namespace js {
 
 // Name visitor (string + symbol)
 template <class Meta, class Type>
-	requires std::is_base_of_v<v8::Primitive, Type>
+	requires std::is_convertible_v<Type, v8::Primitive>
 struct visit<Meta, v8::Local<Type>> : iv8::visit_uncached_flat_value_with<Meta> {
 		using iv8::visit_uncached_flat_value_with<Meta>::visit_uncached_flat_value_with;
 };
@@ -412,7 +469,7 @@ struct visit<Meta, v8::Local<Type>> : iv8::visit_value_with<Meta> {
 
 // Template visitor
 template <class Meta, class Type>
-	requires std::is_base_of_v<v8::Template, Type>
+	requires std::is_convertible_v<Type, v8::Template>
 struct visit<Meta, v8::Local<Type>> : iv8::visit_template {
 		using iv8::visit_template::visit_template;
 };
@@ -434,4 +491,10 @@ struct visit<Meta, v8::FunctionCallbackInfo<v8::Value>> : visit<Meta, v8::Local<
 		}
 };
 
+// Object key maker for v8 objects
+template <auto Key>
+struct visit_key_literal<Key, v8::Local<v8::Object>> : iv8::visit_v8_key_literal<Key> {
+		using iv8::visit_v8_key_literal<Key>::visit_v8_key_literal;
+};
+
 } // namespace js

package/value/array_buffer.cc

@@ -4,15 +4,6 @@ import std;
 
 namespace js::iv8 {
 
-// `value_for_array_buffer`
-value_for_array_buffer::operator js::array_buffer() const {
-	return js::array_buffer{std::span<std::byte>{*this}};
-}
-
-value_for_array_buffer::operator std::span<std::byte>() const {
-	return std::span<std::byte>{reinterpret_cast<std::byte*>((*this)->Data()), (*this)->ByteLength()};
-}
-
 // `value_for_shared_array_buffer`
 value_for_shared_array_buffer::operator js::shared_array_buffer() const {
 	auto backing_store = (*this)->GetBackingStore();
@@ -21,8 +12,4 @@ value_for_shared_array_buffer::operator js::shared_array_buffer() const {
 	return js::shared_array_buffer{(*this)->ByteLength(), std::move(data_shared_ptr)};
 }
 
-value_for_shared_array_buffer::operator std::span<std::byte>() const {
-	return std::span<std::byte>{reinterpret_cast<std::byte*>((*this)->Data()), (*this)->ByteLength()};
-}
-
 } // namespace js::iv8

package/value/array_buffer.h.cc

@@ -7,22 +7,32 @@ import v8;
 
 namespace js::iv8 {
 
+// nb: This handles `v8::ArrayBuffer` and also `v8::SharedArrayBuffer`. They aren't related by
+// inheritance but v8 seem to allow it, and even encourage it.
+class value_for_data_block : public handle_without_lock<v8::ArrayBuffer> {
+	public:
+		using handle_without_lock<v8::ArrayBuffer>::handle_without_lock;
+		[[nodiscard]] auto byte_length() const -> std::size_t { return (*this)->ByteLength(); }
+		[[nodiscard]] auto data() const -> std::byte* { return static_cast<std::byte*>((*this)->Data()); }
+		explicit operator std::span<std::byte>() const { return {data(), byte_length()}; }
+};
+
 class value_for_array_buffer : public handle_without_lock<v8::ArrayBuffer> {
 	public:
 		using handle_without_lock<v8::ArrayBuffer>::handle_without_lock;
+		[[nodiscard]] auto byte_length() const -> std::size_t { return (*this)->ByteLength(); }
 		[[nodiscard]] auto data() const -> std::byte* { return static_cast<std::byte*>((*this)->Data()); }
-		[[nodiscard]] auto size() const -> std::size_t { return (*this)->ByteLength(); }
-		explicit operator js::array_buffer() const;
-		explicit operator std::span<std::byte>() const;
+		explicit operator js::array_buffer() const { return js::array_buffer{std::span<std::byte>{*this}}; }
+		explicit operator std::span<std::byte>() const { return {data(), byte_length()}; }
 };
 
 class value_for_shared_array_buffer : public handle_without_lock<v8::SharedArrayBuffer> {
 	public:
 		using handle_without_lock<v8::SharedArrayBuffer>::handle_without_lock;
+		[[nodiscard]] auto byte_length() const -> std::size_t { return (*this)->ByteLength(); }
 		[[nodiscard]] auto data() const -> std::byte* { return static_cast<std::byte*>((*this)->Data()); }
-		[[nodiscard]] auto size() const -> std::size_t { return (*this)->ByteLength(); }
 		explicit operator js::shared_array_buffer() const;
-		explicit operator std::span<std::byte>() const;
+		explicit operator std::span<std::byte>() const { return {data(), byte_length()}; }
 };
 
 template <class Type>

package/value/function.cc

@@ -0,0 +1,41 @@
+export module v8_js:function_definitions;
+import :accept;
+import :function;
+import :unmaybe;
+import auto_js;
+import std;
+import v8;
+
+namespace js::iv8 {
+
+template <class Result = std::monostate>
+auto Function::apply(context_lock_witness lock, auto&& args) -> Result {
+	auto result = [ & ]() {
+		using args_type = std::vector<v8::Local<v8::Value>>;
+		auto handle_scope = v8::EscapableHandleScope{lock.isolate()};
+		auto undefined = js::transfer_in_strict<v8::Local<v8::Value>>(std::monostate{}, lock);
+		auto argv = js::transfer_in_strict<args_type>(std::forward<decltype(args)>(args), lock);
+		auto result = unmaybe(v8::Function::Call(lock.context(), undefined, argv.size(), argv.data()));
+		return handle_scope.Escape(result);
+	}();
+	return js::transfer_out<Result>(result, lock);
+}
+
+template <class Result = std::monostate>
+auto Function::call(context_lock_witness lock, auto&&... args) -> Result {
+	auto result = [ & ]() {
+		using args_type = std::array<v8::Local<v8::Value>, sizeof...(args) + 1>;
+		auto handle_scope = v8::EscapableHandleScope{lock.isolate()};
+		auto argv = js::transfer_in_strict<args_type>(
+			std::tuple_cat(
+				std::tuple{std::monostate{}},
+				std::forward_as_tuple(std::forward<decltype(args)>(args)...)
+			),
+			lock
+		);
+		return handle_scope.Escape(unmaybe(v8::Function::Call(lock.context(), argv[ 0 ], argv.size() - 1, argv.data() + 1)));
+	}();
+	return js::transfer_out<Result>(result, lock);
+}
+
+} // namespace js::iv8

package/value/function.h.cc

@@ -0,0 +1,16 @@
+export module v8_js:function;
+import :lock;
+import v8;
+
+namespace js::iv8 {
+
+class Function : public v8::Function {
+	public:
+		template <class Result = std::monostate>
+		auto apply(context_lock_witness lock, auto&& args) -> Result;
+
+		template <class Result = std::monostate>
+		auto call(context_lock_witness lock, auto&&... args) -> Result;
+};
+
+} // namespace js::iv8

package/value/object.cc

@@ -1,13 +1,28 @@
 module v8_js;
-import :array;
-import :handle;
-import :lock;
-import :primitive;
+import :object;
 import std;
 import v8;
 
 namespace js::iv8 {
 
+constexpr auto has_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Name> key) -> bool {
+	return iv8::unmaybe(object->HasRealNamedProperty(context, key));
+}
+
+constexpr auto has_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Number> key) -> bool {
+	return iv8::unmaybe(object->HasRealIndexedProperty(context, key.As<v8::Uint32>()->Value()));
+}
+
+constexpr auto has_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Primitive> key) -> bool {
+	// Weird `if` here since there is a "quick" `IsString()` internally, but not for name, number, or
+	// symbol.
+	if (key->IsString() || !key->IsNumber()) {
+		return has_property(context, object, key.As<v8::Name>());
+	} else {
+		return has_property(context, object, key.As<v8::Number>());
+	}
+}
+
 constexpr auto get_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Name> key) -> v8::Local<v8::Value> {
 	// Maybe I'm misunderstanding the "without causing side effects" part of `GetRealNamedProperty`'s
 	// documentation, but it definitely invokes getters.
@@ -42,15 +57,27 @@ auto value_for_object::keys() const -> const value_for_array& {
 	return keys_;
 }
 
-auto value_for_object::get(v8::Local<v8::Name> key) -> v8::Local<v8::Value> {
+auto value_for_object::has(v8::Local<v8::Name> key) const -> bool {
+	return has_property(context(), util::slice(*this), key);
+}
+
+auto value_for_object::has(v8::Local<v8::Number> key) const -> bool {
+	return has_property(context(), util::slice(*this), key);
+}
+
+auto value_for_object::has(v8::Local<v8::Primitive> key) const -> bool {
+	return has_property(context(), util::slice(*this), key);
+}
+
+auto value_for_object::get(v8::Local<v8::Name> key) const -> mapped_type {
 	return get_property(context(), util::slice(*this), key);
 }
 
-auto value_for_object::get(v8::Local<v8::Number> key) -> v8::Local<v8::Value> {
+auto value_for_object::get(v8::Local<v8::Number> key) const -> mapped_type {
 	return get_property(context(), util::slice(*this), key);
 }
 
-auto value_for_object::get(v8::Local<v8::Primitive> key) -> v8::Local<v8::Value> {
+auto value_for_object::get(v8::Local<v8::Primitive> key) const -> mapped_type {
 	return get_property(context(), util::slice(*this), key);
 }
 

package/value/object.h.cc

@@ -1,6 +1,5 @@
 export module v8_js:object;
 import :array;
-import :primitive;
 import auto_js;
 import std;
 import v8;
@@ -33,9 +32,12 @@ class value_for_object : public handle_with_context<v8::Object> {
 		using range_type = std::ranges::transform_view<std::views::all_t<const value_for_array&>, iterator_transform>;
 		using iterator = std::ranges::iterator_t<range_type>;
 
-		[[nodiscard]] auto get(v8::Local<v8::Name> key) -> v8::Local<v8::Value>;
-		[[nodiscard]] auto get(v8::Local<v8::Number> key) -> v8::Local<v8::Value>;
-		[[nodiscard]] auto get(v8::Local<v8::Primitive> key) -> v8::Local<v8::Value>;
+		[[nodiscard]] auto get(v8::Local<v8::Name> key) const -> mapped_type;
+		[[nodiscard]] auto get(v8::Local<v8::Number> key) const -> mapped_type;
+		[[nodiscard]] auto get(v8::Local<v8::Primitive> key) const -> mapped_type;
+		[[nodiscard]] auto has(v8::Local<v8::Name> key) const -> bool;
+		[[nodiscard]] auto has(v8::Local<v8::Number> key) const -> bool;
+		[[nodiscard]] auto has(v8::Local<v8::Primitive> key) const -> bool;
 		[[nodiscard]] auto into_range() -> range_type;
 		[[nodiscard]] auto size() const -> std::size_t;
 

package/value/primitive.cc

@@ -1,5 +1,4 @@
 module v8_js;
-import :handle;
 import :primitive;
 import std;
 import v8;
@@ -20,14 +19,6 @@ value_for_number::operator std::int32_t() const {
 	return this->As<v8::Int32>()->Value();
 }
 
-value_for_number::operator std::int64_t() const {
-	return this->As<v8::Integer>()->Value();
-}
-
-value_for_number::operator std::uint32_t() const {
-	return this->As<v8::Uint32>()->Value();
-}
-
 // `value_for_bigint`
 value_for_bigint::operator js::bigint() const {
 	auto bigint = js::bigint{};
@@ -58,18 +49,6 @@ value_for_string::operator std::string() const {
 	return string;
 }
 
-value_for_string::operator std::u8string() const {
-	std::u8string string;
-	string.resize_and_overwrite((*this)->Utf8LengthV2(isolate()), [ this ](char8_t* data, std::size_t length) -> std::size_t {
-		if (length > 0) {
-			auto* data_char = reinterpret_cast<char*>(data);
-			(*this)->WriteUtf8V2(isolate(), data_char, length, v8::String::WriteOptions::NO_NULL_TERMINATION);
-		}
-		return length;
-	});
-	return string;
-}
-
 value_for_string::operator std::u16string() const {
 	std::u16string string;
 	string.resize_and_overwrite((*this)->Length(), [ this ](char16_t* data, std::size_t length) -> std::size_t {

package/value/primitive.h.cc

@@ -17,8 +17,6 @@ class value_for_number : public handle_without_lock<v8::Number> {
 		using handle_without_lock<v8::Number>::handle_without_lock;
 		[[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;
 };
 
 class value_for_bigint : public handle_without_lock<v8::BigInt> {
@@ -43,7 +41,6 @@ class value_for_string : public handle_with_isolate<v8::String> {
 	public:
 		using handle_with_isolate<v8::String>::handle_with_isolate;
 		[[nodiscard]] explicit operator std::string() const;
-		[[nodiscard]] explicit operator std::u8string() const;
 		[[nodiscard]] explicit operator std::u16string() const;
 };
 

package/value/tag.cc

@@ -7,6 +7,7 @@ import v8;
 namespace js::iv8 {
 
 // These helper classes are provided to avoid extra visit inspections on tagged values
+export class Function;
 export class BigInt64 : public v8::BigInt {};
 export class BigIntU64 : public v8::BigInt {};
 export class BigIntWords : public v8::BigInt {};
@@ -19,7 +20,7 @@ export class Undefined : public v8::Primitive {};
 // `v8::Local<v8::ArrayBuffer>{}->Buffer()` returns a `v8::Local<v8::ArrayBuffer>`, even in the case
 // it has a `SharedArrayBuffer`. In this case `buffer->IsArrayBuffer()` will return false. This is a
 // wrapper to denote that there is a data block but we do not know what kind it is.
-class DataBlock : public v8::Object {};
+export class DataBlock : public v8::Object {};
 
 constexpr auto tag_to_v8_fn = util::overloaded{
 	[](value_tag /*tag*/) -> std::type_identity<v8::Value> { return {}; },
@@ -42,20 +43,26 @@ constexpr auto tag_to_v8_fn = util::overloaded{
 	[](symbol_tag /*tag*/) -> std::type_identity<v8::Symbol> { return {}; },
 
 	// objects
-	[](array_buffer_tag /*tag*/) -> std::type_identity<v8::ArrayBuffer> { return {}; },
 	[](date_tag /*tag*/) -> std::type_identity<v8::Date> { return {}; },
 	[](external_tag /*tag*/) -> std::type_identity<v8::External> { return {}; },
-	[](function_tag /*tag*/) -> std::type_identity<v8::Function> { return {}; },
+	[](function_tag /*tag*/) -> std::type_identity<iv8::Function> { return {}; },
 	[](list_tag /*tag*/) -> std::type_identity<v8::Array> { return {}; },
 	[](object_tag /*tag*/) -> std::type_identity<v8::Object> { return {}; },
 	[](promise_tag /*tag*/) -> std::type_identity<v8::Promise> { return {}; },
+	[](vector_tag /*tag*/) -> std::type_identity<v8::Array> { return {}; },
+
+	// data blocks
+	[](array_buffer_tag /*tag*/) -> std::type_identity<v8::ArrayBuffer> { return {}; },
+	[](data_block_tag /*tag*/) -> std::type_identity<iv8::DataBlock> { return {}; },
 	[](shared_array_buffer_tag /*tag*/) -> std::type_identity<v8::SharedArrayBuffer> { return {}; },
 
 	// typed arrays
+	[](array_buffer_view_tag /*tag*/) -> std::type_identity<v8::ArrayBufferView> { return {}; },
 	[](data_view_tag /*tag*/) -> std::type_identity<v8::DataView> { return {}; },
 	[](typed_array_tag_of<double> /*tag*/) -> std::type_identity<v8::Float64Array> { return {}; },
 	[](typed_array_tag_of<float> /*tag*/) -> std::type_identity<v8::Float32Array> { return {}; },
-	[](typed_array_tag_of<std::byte> /*tag*/) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
+	[](typed_array_tag_of<js::float16_t> /*tag*/) -> std::type_identity<v8::Float16Array> { return {}; },
+	[](typed_array_tag_of<js::uint8_clamped_t> /*tag*/) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
 	[](typed_array_tag_of<std::int16_t> /*tag*/) -> std::type_identity<v8::Int16Array> { return {}; },
 	[](typed_array_tag_of<std::int32_t> /*tag*/) -> std::type_identity<v8::Int32Array> { return {}; },
 	[](typed_array_tag_of<std::int64_t> /*tag*/) -> std::type_identity<v8::BigInt64Array> { return {}; },
@@ -94,19 +101,25 @@ constexpr auto v8_to_tag_fn = util::overloaded{
 	[](std::type_identity<v8::Uint32> /*type*/) -> number_tag_of<std::uint32_t> { return {}; },
 
 	// objects
+	[](std::type_identity<iv8::Function> /*type*/) -> function_tag { return {}; },
 	[](std::type_identity<v8::Array> /*type*/) -> list_tag { return {}; },
-	[](std::type_identity<v8::ArrayBuffer> /*type*/) -> array_buffer_tag { return {}; },
 	[](std::type_identity<v8::Date> /*type*/) -> date_tag { return {}; },
 	[](std::type_identity<v8::External> /*type*/) -> external_tag { return {}; },
 	[](std::type_identity<v8::Function> /*type*/) -> function_tag { return {}; },
 	[](std::type_identity<v8::Object> /*type*/) -> object_tag { return {}; },
 	[](std::type_identity<v8::Promise> /*type*/) -> promise_tag { return {}; },
+
+	// data blocks
+	[](std::type_identity<iv8::DataBlock> /*type*/) -> data_block_tag { return {}; },
+	[](std::type_identity<v8::ArrayBuffer> /*type*/) -> array_buffer_tag { return {}; },
 	[](std::type_identity<v8::SharedArrayBuffer> /*type*/) -> shared_array_buffer_tag { return {}; },
 
 	// typed arrays
+	[](std::type_identity<v8::ArrayBufferView> /*type*/) -> array_buffer_view_tag { return {}; },
 	[](std::type_identity<v8::BigInt64Array> /*type*/) -> typed_array_tag_of<std::int64_t> { return {}; },
 	[](std::type_identity<v8::BigUint64Array> /*type*/) -> typed_array_tag_of<std::uint64_t> { return {}; },
 	[](std::type_identity<v8::DataView> /*type*/) -> data_view_tag { return {}; },
+	[](std::type_identity<v8::Float16Array> /*type*/) -> typed_array_tag_of<js::float16_t> { return {}; },
 	[](std::type_identity<v8::Float32Array> /*type*/) -> typed_array_tag_of<float> { return {}; },
 	[](std::type_identity<v8::Float64Array> /*type*/) -> typed_array_tag_of<double> { return {}; },
 	[](std::type_identity<v8::Int16Array> /*type*/) -> typed_array_tag_of<std::int16_t> { return {}; },
@@ -115,7 +128,7 @@ constexpr auto v8_to_tag_fn = util::overloaded{
 	[](std::type_identity<v8::Uint16Array> /*type*/) -> typed_array_tag_of<std::uint16_t> { return {}; },
 	[](std::type_identity<v8::Uint32Array> /*type*/) -> typed_array_tag_of<std::uint32_t> { return {}; },
 	[](std::type_identity<v8::Uint8Array> /*type*/) -> typed_array_tag_of<std::uint8_t> { return {}; },
-	[](std::type_identity<v8::Uint8ClampedArray> /*type*/) -> typed_array_tag_of<std::byte> { return {}; },
+	[](std::type_identity<v8::Uint8ClampedArray> /*type*/) -> typed_array_tag_of<js::uint8_clamped_t> { return {}; },
 
 	// templates
 	[](std::type_identity<v8::FunctionTemplate> /*type*/) -> function_prototype_tag { return {}; },
@@ -130,3 +143,9 @@ export template <class Type>
 using v8_to_tag = decltype(v8_to_tag_fn(type<Type>));
 
 } // namespace js::iv8
+
+// Specialization for `js::forward`.
+namespace js {
+template <class Type>
+struct forward_tag_for<v8::Local<Type>> : std::type_identity<iv8::v8_to_tag<Type>> {};
+} // namespace js

package/value/value.cc

@@ -0,0 +1,8 @@
+export module v8_js:value;
+export import :array_buffer;
+export import :array;
+export import :fixed_array;
+export import :function;
+export import :object;
+export import :primitive;
+export import :value.tag;