@auto_js/v8 0.0.11 → 0.0.12

package/CMakeLists.txt

@@ -39,10 +39,12 @@ target_sources(${v8_js}
 		support/lock.h.cc
 		support/unmaybe.cc
 		transfer/accept.h.cc
+		transfer/transfer_list.cc
 		transfer/visit.cc
 		value/array_buffer.h.cc
 		value/array.h.cc
 		value/callback_info.cc
+		value/external.h.cc
 		value/fixed_array.h.cc
 		value/function.cc
 		value/function.h.cc

package/_module.cc

@@ -11,6 +11,7 @@ export import :handle.value;
 export import :hash;
 export import :lock;
 export import :remote;
+export import :transfer_list;
 export import :unmaybe;
 export import :value;
 export import :value.tag;

package/container/hash.cc

@@ -4,13 +4,17 @@ import v8;
 
 namespace js::iv8 {
 
+// Physical location of the local handle's value, comparable between unrelated handle types
+export constexpr auto handle_addressof =
+	[]<class Type>(v8::Local<Type> local) -> void* { return *local; };
+
 // Hash based on the physical location of the local handle's value
 export struct address_hash : std::hash<void*> {
 		using std::hash<void*>::operator();
 
 		template <class Type>
 		auto operator()(v8::Local<Type> local) const -> std::size_t {
-			return (*this)(*local);
+			return (*this)(handle_addressof(local));
 		}
 };
 

package/evaluation/module.cc

@@ -132,7 +132,9 @@ auto module_record::link(context_lock_witness lock, module_link_record link_reco
 		}
 		return link_record.modules.at(link_record.payload.at(it->second + index));
 	};
+	// nb: The initializer only runs on the first pass through the declaration.
 	thread_local auto* linker_ptr = &linker;
+	linker_ptr = &linker;
 
 	// v8 linker callback
 	auto v8_callback = v8::Module::ResolveModuleByIndexCallback{

package/handle/collected_handle.cc

@@ -1,5 +1,3 @@
-module;
-#include <v8_js/version.h>
 export module v8_js:collected_handle;
 import :lock;
 import std;
@@ -34,6 +32,7 @@ class collected_handle
 				pool_{pool},
 				value_{std::forward<decltype(args)>(args)...} {}
 
+		auto get() -> Type* { return &value_; }
 		auto operator*() -> Type& { return value_; }
 		static auto make(const collected_handle_lock& lock, auto&&... args) -> unique_ptr
 			requires std::constructible_from<Type, decltype(args)...>;
@@ -45,10 +44,6 @@ class collected_handle
 		Type value_;
 };
 
-// Untagged v8-managed host object
-export template <class Type>
-using collected_external_of = collected_handle<v8::External, Type>;
-
 // ---
 
 template <class Value, class Type>
@@ -73,27 +68,4 @@ auto collected_handle<Value, Type>::reset(const collected_handle_lock& lock, uni
 	});
 }
 
-export template <class Type>
-auto make_collected_external(const collected_handle_lock& lock, auto&&... args) -> v8::Local<v8::External> {
-	auto unique = collected_external_of<Type>::make(lock, std::forward<decltype(args)>(args)...);
-#if V8_HAS_TAGGED_EXTERNAL
-	auto value = v8::External::New(lock.isolate(), unique.get(), 0);
-#else
-	auto value = v8::External::New(lock.isolate(), unique.get());
-#endif
-	collected_handle<v8::External, Type>::reset(lock, std::move(unique), value);
-	return value;
-}
-
-export template <class Type>
-auto unwrap_collected_external(v8::Local<v8::External> external) -> Type& {
-	using handle_type = collected_external_of<Type>;
-#if V8_HAS_TAGGED_EXTERNAL
-	// TODO: Use this feature
-	return **static_cast<handle_type*>(external->Value(0));
-#else
-	return **static_cast<handle_type*>(external->Value());
-#endif
-}
-
 } // namespace js::iv8

package/handle/value_of.cc

@@ -16,8 +16,11 @@ class value_of : public value_specialization<Tag>::type {
 	public:
 		using value_specialization<Tag>::type::type;
 
+		template <std::convertible_to<tag_to_v8<Tag>> Type>
 		// NOLINTNEXTLINE(google-explicit-constructor)
-		operator v8::Local<tag_to_v8<Tag>>() const { return std::bit_cast<v8::Local<tag_to_v8<Tag>>>(*this); }
+		operator v8::Local<Type>() const {
+			return std::bit_cast<v8::Local<Type>>(v8::Local<v8::Data>{*this});
+		}
 };
 
 template <class Type>

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@auto_js/v8",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "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.11",
-    "@auto_js/v8_exports": "^0.0.8"
+    "@auto_js/js": "^0.0.12",
+    "@auto_js/v8_exports": "^0.0.9"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -28,6 +28,8 @@ constexpr auto make_free_function_with_try_catch =
 	using callback_type = decltype(callback);
 	auto bound_function = util::bind{
 		[](callback_type& callback, Lock lock, const v8::FunctionCallbackInfo<v8::Value>& info) noexcept(Nx) -> void {
+			auto disallow_js =
+				v8::Isolate::DisallowJavascriptExecutionScope{lock.isolate(), v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE};
 			// NOLINTNEXTLINE(cppcoreguidelines-slicing)
 			auto result = invoke_internal_error_scope(lock, [ & ] -> auto {
 				auto run = util::regular_return{[ & ] -> decltype(auto) {
@@ -61,6 +63,8 @@ constexpr auto make_free_function_noexcept =
 	using callback_type = decltype(callback);
 	auto bound_function = util::bind{
 		[](callback_type& callback, Lock lock, const v8::FunctionCallbackInfo<v8::Value>& /*info*/) noexcept -> void {
+			auto disallow_js =
+				v8::Isolate::DisallowJavascriptExecutionScope{lock.isolate(), v8::Isolate::DisallowJavascriptExecutionScope::CRASH_ON_FAILURE};
 			auto run = util::regular_return{[ & ] -> decltype(auto) {
 				return callback(lock);
 			}};

package/support/callback_storage.cc

@@ -1,7 +1,5 @@
-module;
-#include <v8_js/version.h>
 export module v8_js:callback_storage;
-import :collected_handle;
+import :external;
 import :unmaybe;
 import std;
 import v8;
@@ -70,41 +68,32 @@ auto make_callback_storage(const auto& lock, auto function) {
 	auto bound = make_bound_callback(std::type_identity<signature_type>{}, lock, std::move(function));
 	using bound_type = decltype(bound);
 	if constexpr (std::is_trivially_copyable_v<bound_type>) {
-		static_assert(std::is_trivially_destructible_v<bound_type>);
 		if constexpr (std::is_empty_v<bound_type>) {
 			// Constant expression function of 0 size. No data needed at all!
 			auto data = v8::Local<v8::Value>{};
-			const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
+			constexpr auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
 				auto invoke = bound_type{};
 				invoke(info);
 			}};
 			return std::tuple{callback, data};
-		} else if constexpr (sizeof(bound_type) == sizeof(void*)) {
-			// Trivial function of pointer type. Data() is the function data.
-			auto data = [ & ] -> auto {
-#if V8_HAS_TAGGED_EXTERNAL
-				return v8::External::New(lock.isolate(), std::bit_cast<void*>(bound), 0);
-#else
-				return v8::External::New(lock.isolate(), std::bit_cast<void*>(bound));
-#endif
-			}();
-			const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
-				auto invoke = [ & ] -> auto {
-#if V8_HAS_TAGGED_EXTERNAL
-					// TODO: Use this feature
-					return std::bit_cast<bound_type>(info.Data().As<v8::External>()->Value(0));
-#else
-					return std::bit_cast<bound_type>(info.Data().As<v8::External>()->Value());
-#endif
-				}();
-				invoke(info);
-			}};
-			return std::tuple{callback, data};
 		} else {
-			// Trivial data-only function type. `Data()` is a latin1 string containing the agent & function data.
+			if constexpr (sizeof(bound_type) <= sizeof(void*)) {
+				// Trivial function which can fit inside a pointer. There is a v8 DCHECK on nullptr, so in
+				// that case it falls through to the latin1 representation.
+				if (auto* pointer = util::bit_padding_cast<void*>(bound); pointer != nullptr) {
+					using external_type = untagged_external<void>;
+					auto data = v8::Local<v8::Value>{external_type::make(lock, pointer)};
+					constexpr auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
+						auto invoke = util::bit_truncation_cast<bound_type>(info.Data().As<external_type>()->value());
+						invoke(info);
+					}};
+					return std::tuple{callback, data};
+				}
+			}
+			// Trivial data-only function type. `Data()` is a latin1 string containing the function data.
 			auto data =
 				unmaybe(v8::String::NewFromOneByte(lock.isolate(), reinterpret_cast<const std::uint8_t*>(&bound), v8::NewStringType::kNormal, sizeof(bound)));
-			const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
+			constexpr auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
 				// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 				std::array<std::byte, sizeof(bound_type)> data;
 				auto* isolate = info.GetIsolate();
@@ -112,13 +101,14 @@ auto make_callback_storage(const auto& lock, auto function) {
 				auto invoke = std::bit_cast<bound_type>(data);
 				invoke(info);
 			}};
-			return std::tuple{callback, data};
+			return std::tuple{callback, v8::Local<v8::Value>{data}};
 		}
 	} else {
-		// Otherwise the function requires bound state w/ a destructor
-		auto data = make_collected_external<bound_type>(lock, std::move(bound));
-		const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
-			auto& invoke = unwrap_collected_external<bound_type>(info.Data().As<v8::External>());
+		// Otherwise `Data()` is a collected external.
+		using external_type = untagged_external<bound_type>;
+		auto data = external_type::make_collected(lock, std::move(bound));
+		constexpr auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
+			auto& invoke = *info.Data().As<external_type>()->value();
 			invoke(info);
 		}};
 		return std::tuple{callback, data};

package/transfer/accept.cc

@@ -116,14 +116,24 @@ auto accept_v8_value::operator()(function_prototype_tag /*tag*/, visit_holder /*
 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.byte_length();
-	auto backing_store = v8::ArrayBuffer::NewBackingStore(
-		std::move(subject).acquire_ownership().release(),
-		byte_length,
-		[](void* data, std::size_t /*length*/, void* /*deleter_data*/) -> void {
-			std::ignore = js::array_buffer::unique_pointer_type{reinterpret_cast<std::byte*>(data)};
-		},
-		nullptr
-	);
+	auto backing_store = [ & ] -> auto {
+		// nb: v8 does not call the deleter when `byte_length` is zero.
+		if (byte_length == 0) {
+			return v8::ArrayBuffer::NewBackingStore(nullptr, 0, nullptr, nullptr);
+		} else {
+			auto holder = std::make_unique<js::array_buffer>(std::move(subject));
+			auto backing_store = v8::ArrayBuffer::NewBackingStore(
+				holder->data(),
+				byte_length,
+				[](void* /*data*/, std::size_t /*length*/, void* param) -> void {
+					delete static_cast<js::array_buffer*>(param);
+				},
+				holder.get()
+			);
+			std::ignore = holder.release();
+			return backing_store;
+		}
+	}();
 	auto value = v8::ArrayBuffer::New(isolate(), std::move(backing_store));
 	return js::referenceable_value{value};
 }

package/transfer/transfer_list.cc

@@ -0,0 +1,141 @@
+export module v8_js:transfer_list;
+import :array;
+import :handle.value;
+import :object;
+import :lock;
+import :unmaybe;
+import :value.tag;
+import auto_js;
+import std;
+import util;
+import v8;
+
+namespace js::iv8 {
+
+// Transfer delegate for `ArrayBuffer`
+export class array_buffer_transfer {
+	public:
+		array_buffer_transfer(context_lock_witness /*lock*/, std::vector<v8::Local<v8::Value>>& entries) :
+				buffers_{[ & ] -> auto {
+					constexpr auto maybe_claim_in = [](v8::Local<v8::Value> value) -> std::optional<v8::Local<v8::ArrayBuffer>> {
+						if (value->IsArrayBuffer()) {
+							auto buffer = value.As<v8::ArrayBuffer>();
+							if (!buffer->IsDetachable()) {
+								throw js::type_error{u"ArrayBuffer is not detachable"};
+							}
+							return buffer;
+						} else {
+							return std::nullopt;
+						}
+					};
+					return js::extract_transferees(util::cw<u"ArrayBuffer">, maybe_claim_in, std::equal_to{}, entries);
+				}()} {}
+
+		template <class Visit, class Accept>
+		auto operator()(v8::Local<v8::ArrayBuffer> subject, Visit& visit, const Accept& accept) {
+			return maybe_claim_out(subject, visit, accept);
+		}
+
+		template <class Visit, class Accept>
+		auto operator()(v8::Local<iv8::DataBlock> subject, Visit& visit, const Accept& accept) {
+			return maybe_claim_out(subject, visit, accept);
+		}
+
+		auto finalize() -> void {
+			for (auto entry : std::exchange(buffers_, {})) {
+				unmaybe(entry->Detach(v8::Local<v8::Value>{}));
+			}
+		}
+
+	private:
+		template <class Visit, class Accept>
+		auto maybe_claim_out(auto subject, Visit& visit, const Accept& accept) {
+			auto claim_out = [ & ](v8::Local<v8::ArrayBuffer> handle) -> accept_target_t<Accept> {
+				auto buffer = [ & ] -> js::array_buffer {
+					if (handle->ByteLength() == 0) {
+						return js::array_buffer{std::span<std::byte>{}};
+					} else {
+						// Steal the backing store, avoiding a copy of the contents
+						auto backing_store = std::make_unique<std::shared_ptr<v8::BackingStore>>(handle->GetBackingStore());
+						auto data = std::span{static_cast<std::byte*>((*backing_store)->Data()), (*backing_store)->ByteLength()};
+						return js::array_buffer{
+							data,
+							js::array_buffer::deleter{
+								[](std::shared_ptr<v8::BackingStore>* backing_store, std::byte* /*data*/) -> void {
+									delete backing_store;
+								},
+								backing_store.release()
+							}
+						};
+					}
+				}();
+				unmaybe(handle->Detach(v8::Local<v8::Value>{}));
+				return accept(array_buffer_tag{}, visit, js::transferred_value{v8::Local<v8::Data>{handle}, buffer});
+			};
+			return js::claim_transferee(buffers_, subject, std::equal_to{}, claim_out);
+		}
+
+		std::vector<v8::Local<v8::ArrayBuffer>> buffers_;
+};
+
+// v8 'transferList' delegate
+export template <class... Delegates>
+class transfer_list {
+	public:
+		template <class Type>
+		transfer_list(context_lock_witness lock, std::optional<Type> list) :
+				transfer_list{lock, list ? entries_of(lock, list->template As<v8::Array>()) : std::vector<v8::Local<v8::Value>>{}} {}
+
+		transfer_list(context_lock_witness lock, value_of<list_tag> list) :
+				transfer_list{lock, entries_of(lock, list.As<v8::Array>())} {}
+
+		// Constructs a list in place and invokes the given operation with it, finalizing afterwards
+		static auto with(context_lock_witness lock, auto list, auto operation) {
+			auto self = transfer_list{lock, std::move(list)};
+			auto result = operation(self);
+			self.finalize();
+			return result;
+		}
+
+		// Offers the subject to each delegate in order, claiming with the first which engages
+		template <class Visit, class Accept>
+		auto operator()(auto subject, Visit& visit, const Accept& accept) -> std::optional<accept_target_t<Accept>> {
+			return util::template_traverse(
+				util::sequence_cw<sizeof...(Delegates)>,
+				util::overloaded{
+					[ & ](auto ii, auto next) -> std::optional<accept_target_t<Accept>> {
+						auto& delegate = std::get<ii>(delegates_);
+						if constexpr (std::invocable<decltype(delegate), decltype(subject), Visit&, const Accept&>) {
+							if (auto claim = delegate(subject, visit, accept)) {
+								return std::optional{(*std::move(claim))()};
+							}
+						}
+						return next();
+					},
+					[] -> std::optional<accept_target_t<Accept>> { return std::nullopt; },
+				}
+			);
+		}
+
+		auto finalize() -> void {
+			constexpr auto [... ii ] = util::sequence<sizeof...(Delegates)>;
+			(..., std::get<ii>(delegates_).finalize());
+		}
+
+	private:
+		// Each delegate claims its entries from the vector. Anything left over is unknown.
+		transfer_list(context_lock_witness lock, std::vector<v8::Local<v8::Value>> entries) :
+				delegates_{Delegates{lock, entries}...} {
+			if (!entries.empty()) {
+				throw js::type_error{u"Transfer list contains unknown value"};
+			}
+		}
+
+		static auto entries_of(context_lock_witness lock, v8::Local<v8::Array> list) -> std::vector<v8::Local<v8::Value>> {
+			return std::vector{std::from_range, value_for_array{lock, list}};
+		}
+
+		std::tuple<Delegates...> delegates_;
+};
+
+} // namespace js::iv8

package/transfer/visit.cc

@@ -77,11 +77,11 @@ struct visit_cached_immediate : Visit {
 		using Visit::Visit;
 
 		template <class Accept>
-		auto operator()(auto subject, const Accept& accept) -> accept_target_t<Accept>
+		auto operator()(this auto& self, auto subject, const Accept& accept) -> accept_target_t<Accept>
 			// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124954
-			requires requires { this->immediate(subject, accept); } {
-			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
-				return immediate(subject, accept);
+			requires requires { self.immediate(subject, accept); } {
+			return self.lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
+				return self.immediate(subject, accept);
 			});
 		}
 };
@@ -94,10 +94,10 @@ struct visit_uncached_immediate : Visit {
 		using Visit::Visit;
 
 		template <class Accept>
-		auto operator()(auto subject, const Accept& accept) -> accept_target_t<Accept>
+		auto operator()(this auto& self, auto subject, const Accept& accept) -> accept_target_t<Accept>
 			// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124954
-			requires requires { this->immediate(subject, accept); } {
-			return immediate(subject, accept);
+			requires requires { self.immediate(subject, accept); } {
+			return self.immediate(subject, accept);
 		}
 };
 
@@ -121,18 +121,18 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 
 		// numbers
 		template <class Accept>
-		auto operator()(v8::Local<v8::Number> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(this auto& self, v8::Local<v8::Number> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsInt32()) {
-				return immediate(subject.As<v8::Int32>(), accept);
+				return self.immediate(subject.As<v8::Int32>(), accept);
 			} else {
-				return immediate(subject.As<iv8::Double>(), accept);
+				return self.immediate(subject.As<iv8::Double>(), accept);
 			}
 		}
 
 		// boolean
 		template <class Accept>
-		auto operator()(v8::Local<v8::Boolean> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return immediate(subject, accept);
+		auto operator()(this auto& self, v8::Local<v8::Boolean> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.immediate(subject, accept);
 		}
 
 		// extras
@@ -142,19 +142,19 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 	protected:
 		// primitives
 		template <class Accept>
-		auto immediate(v8::Local<v8::Primitive> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, v8::Local<v8::Primitive> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsUndefined()) {
-				return accept(undefined_tag{}, *this, subject);
+				return accept(undefined_tag{}, self, subject);
 			} else if (subject->IsNull()) {
-				return accept(null_tag{}, *this, subject);
+				return accept(null_tag{}, self, subject);
 			} else if (subject->IsNumber()) {
-				return (*this)(subject.As<v8::Number>(), accept);
+				return self(subject.As<v8::Number>(), accept);
 			} else if (subject->IsName()) {
-				return immediate(subject.As<v8::Name>(), accept);
+				return self.immediate(subject.As<v8::Name>(), accept);
 			} else if (subject->IsBoolean()) {
-				return (*this)(subject.As<v8::Boolean>(), accept);
+				return self(subject.As<v8::Boolean>(), accept);
 			} else if (subject->IsBigInt()) {
-				return immediate(subject.As<v8::BigInt>(), accept);
+				return self.immediate(subject.As<v8::BigInt>(), accept);
 			} else {
 				std::unreachable();
 			}
@@ -162,86 +162,86 @@ struct visit_flat_value : reference_map_t<Reference, visit_reference_map_type> {
 
 		template <class Accept, class 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);
+		auto immediate(this auto& self, v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// names
 		template <class Accept>
-		auto immediate(v8::Local<v8::Name> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, v8::Local<v8::Name> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsString()) {
-				return immediate(subject.As<v8::String>(), accept);
+				return self.immediate(subject.As<v8::String>(), accept);
 			} else {
-				return immediate(subject.As<v8::Symbol>(), accept);
+				return self.immediate(subject.As<v8::Symbol>(), accept);
 			}
 		}
 
 		template <class Accept>
-		auto immediate(v8::Local<v8::String> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, v8::Local<v8::String> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsOneByte()) {
-				return immediate(subject.As<iv8::StringOneByte>(), accept);
+				return self.immediate(subject.As<iv8::StringOneByte>(), accept);
 			} else {
-				return immediate(subject.As<iv8::StringTwoByte>(), accept);
+				return self.immediate(subject.As<iv8::StringTwoByte>(), accept);
 			}
 		}
 
 		// bigint
 		template <class Accept>
-		auto immediate(v8::Local<v8::BigInt> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, v8::Local<v8::BigInt> subject, const Accept& accept) -> accept_target_t<Accept> {
 			bool lossless{};
 			auto i64 = subject->Int64Value(&lossless);
 			if (lossless) {
-				return accept(bigint_tag_of<std::int64_t>{}, *this, value_of{witness(), subject.As<iv8::BigInt64>(), i64});
+				return accept(bigint_tag_of<std::int64_t>{}, self, value_of{self.witness(), subject.As<iv8::BigInt64>(), i64});
 			} else {
-				return immediate(subject.As<iv8::BigIntWords>(), accept);
+				return self.immediate(subject.As<iv8::BigIntWords>(), accept);
 			}
 		}
 
 		// date
 		template <class Accept>
-		auto immediate(v8::Local<v8::Date> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, v8::Local<v8::Date> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// data blocks
 		template <class Accept>
-		auto immediate(v8::Local<iv8::DataBlock> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, v8::Local<iv8::DataBlock> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsSharedArrayBuffer()) {
-				return immediate(subject.As<v8::SharedArrayBuffer>(), accept);
+				return self.immediate(subject.As<v8::SharedArrayBuffer>(), accept);
 			} else {
-				return immediate(subject.As<v8::ArrayBuffer>(), accept);
+				return self.immediate(subject.As<v8::ArrayBuffer>(), accept);
 			}
 		}
 
 		template <class Accept, class 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);
+		auto immediate(this auto& self, v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// external
 		template <class Accept>
-		auto immediate(v8::Local<v8::External> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, v8::Local<v8::External> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// 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);
+		auto immediate(this auto& self, v8::Local<v8::Promise> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(promise_tag{}, self, subject);
 		}
 
 		// 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);
+		auto immediate(this auto& self, v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(function_tag{}, self, subject);
 		}
 
 		// Convenience function which wraps in `iv8::value_of` and invokes `accept`.
 		template <class Type, class Accept>
-		[[nodiscard]] auto accept_tagged(v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(iv8::v8_to_tag<Type>{}, *this, value_of{witness(), subject});
+		[[nodiscard]] auto accept_tagged(this auto& self, v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(iv8::v8_to_tag<Type>{}, self, value_of{self.witness(), subject});
 		}
 
 	private:
@@ -273,40 +273,40 @@ struct visit_value : visit_flat_value<Target> {
 				visit_value{transfer, context_lock_witness{util::slice(lock)}} {}
 
 		template <class Accept>
-		auto operator()(v8::Local<v8::Value> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(this auto& self, v8::Local<v8::Value> subject, const Accept& accept) -> accept_target_t<Accept> {
 
 			// Check the reference map, and check type
-			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
+			return self.lookup_or_visit(subject, [ & ] -> accept_target_t<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();
+							return subject->IsUndefined() ? accept(undefined_tag{}, self, 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();
+							return subject->IsNull() ? accept(null_tag{}, self, subject.As<iv8::Null>()) : next();
 						},
 						[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return subject->IsBoolean() ? (*this)(subject.As<v8::Boolean>(), accept) : next();
+							return subject->IsBoolean() ? self(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();
+							return subject->IsNumber() ? self(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();
+							return subject->IsString() ? self.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();
+							return subject->IsBigInt() ? self.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();
+							return subject->IsDate() ? self.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();
+							return subject->IsArray() ? self.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();
+							return subject->IsFunction() ? self.immediate(subject.As<iv8::Function>(), accept) : next();
 						},
 
 						// Unknown tag
@@ -315,9 +315,9 @@ struct visit_value : visit_flat_value<Target> {
 						// Slow path
 						[ & ] -> accept_target_t<Accept> {
 							if (subject->IsObject()) {
-								return immediate(subject.As<v8::Object>(), accept);
+								return self.immediate(subject.As<v8::Object>(), accept);
 							} else {
-								return immediate(subject.As<v8::Primitive>(), accept);
+								return self.immediate(subject.As<v8::Primitive>(), accept);
 							}
 						},
 					}
@@ -326,19 +326,19 @@ struct visit_value : visit_flat_value<Target> {
 		}
 
 		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> {
+		auto operator()(this auto& self, v8::Local<iv8::DataBlock> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.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); },
+						[ & ](data_block_tag /*tag*/, auto /*next*/) -> accept_target_t<Accept> { return self.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);
+							return self.immediate(subject, accept);
 						}
 					}
 				);
@@ -352,72 +352,72 @@ struct visit_value : visit_flat_value<Target> {
 
 	protected:
 		// object
-		template <class Accept>
-		auto immediate(v8::Local<v8::Object> subject, const Accept& accept) -> accept_target_t<Accept> {
+		template <class Visit, class Accept>
+		auto immediate(this Visit& self, v8::Local<v8::Object> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsArray()) {
-				return immediate(subject.As<v8::Array>(), accept);
+				return self.immediate(subject.As<v8::Array>(), accept);
 			} else if (subject->IsExternal()) {
-				return immediate(subject.As<v8::External>(), accept);
+				return self.immediate(subject.As<v8::External>(), accept);
 			} else if (subject->IsDate()) {
-				return immediate(subject.As<v8::Date>(), accept);
+				return self.immediate(subject.As<v8::Date>(), accept);
 			} else if (subject->IsArrayBuffer()) {
-				return immediate(subject.As<v8::ArrayBuffer>(), accept);
+				return self.immediate(subject.As<v8::ArrayBuffer>(), accept);
 			} else if (subject->IsSharedArrayBuffer()) {
-				return immediate(subject.As<v8::SharedArrayBuffer>(), accept);
+				return self.immediate(subject.As<v8::SharedArrayBuffer>(), accept);
 			} else if (subject->IsArrayBufferView()) {
-				return immediate(subject.As<v8::ArrayBufferView>(), accept);
+				return self.immediate(subject.As<v8::ArrayBufferView>(), accept);
 			} else if (subject->IsPromise()) {
-				return immediate(subject.As<v8::Promise>(), accept);
+				return self.immediate(subject.As<v8::Promise>(), accept);
 			} else if (subject->IsFunction()) {
-				return immediate(subject.As<iv8::Function>(), accept);
+				return self.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>()});
+				auto visit_entry = visit_entry_pair<visit_property_name<Visit>, Visit&>{self};
+				return accept(dictionary_tag{}, visit_entry, value_of{self.witness(), subject.As<v8::Object>()});
 			}
 		}
 
 		// array
-		template <class Accept>
-		auto immediate(v8::Local<v8::Array> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
-			return accept(list_tag{}, visit_entry, value_of{witness(), subject.As<v8::Array>()});
+		template <class Visit, class Accept>
+		auto immediate(this Visit& self, v8::Local<v8::Array> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_property_name<Visit>, Visit&>{self};
+			return accept(list_tag{}, visit_entry, value_of{self.witness(), subject.As<v8::Array>()});
 		}
 
 		// function template
 		template <class Accept>
-		auto immediate(v8::Local<v8::FunctionTemplate> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(function_tag{}, *this, unmaybe(subject->GetFunction(context_)));
+		auto immediate(this auto& self, v8::Local<v8::FunctionTemplate> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(function_tag{}, self, unmaybe(subject->GetFunction(self.witness().context())));
 		}
 
 		// array buffer views (typed arrays, data view)
 		template <class Accept>
-		auto immediate(v8::Local<v8::ArrayBufferView> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, v8::Local<v8::ArrayBufferView> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (subject->IsUint8Array()) {
-				return immediate(subject.As<v8::Uint8Array>(), accept);
+				return self.immediate(subject.As<v8::Uint8Array>(), accept);
 			} else if (subject->IsDataView()) {
-				return immediate(subject.As<v8::DataView>(), accept);
+				return self.immediate(subject.As<v8::DataView>(), accept);
 			} else if (subject->IsUint8ClampedArray()) {
-				return immediate(subject.As<v8::Uint8ClampedArray>(), accept);
+				return self.immediate(subject.As<v8::Uint8ClampedArray>(), accept);
 			} else if (subject->IsInt8Array()) {
-				return immediate(subject.As<v8::Int8Array>(), accept);
+				return self.immediate(subject.As<v8::Int8Array>(), accept);
 			} else if (subject->IsUint16Array()) {
-				return immediate(subject.As<v8::Uint16Array>(), accept);
+				return self.immediate(subject.As<v8::Uint16Array>(), accept);
 			} else if (subject->IsInt16Array()) {
-				return immediate(subject.As<v8::Int16Array>(), accept);
+				return self.immediate(subject.As<v8::Int16Array>(), accept);
 			} else if (subject->IsUint32Array()) {
-				return immediate(subject.As<v8::Uint32Array>(), accept);
+				return self.immediate(subject.As<v8::Uint32Array>(), accept);
 			} else if (subject->IsInt32Array()) {
-				return immediate(subject.As<v8::Int32Array>(), accept);
+				return self.immediate(subject.As<v8::Int32Array>(), accept);
 			} else if (subject->IsFloat16Array()) {
-				return immediate(subject.As<v8::Float16Array>(), accept);
+				return self.immediate(subject.As<v8::Float16Array>(), accept);
 			} else if (subject->IsFloat32Array()) {
-				return immediate(subject.As<v8::Float32Array>(), accept);
+				return self.immediate(subject.As<v8::Float32Array>(), accept);
 			} else if (subject->IsFloat64Array()) {
-				return immediate(subject.As<v8::Float64Array>(), accept);
+				return self.immediate(subject.As<v8::Float64Array>(), accept);
 			} else if (subject->IsBigInt64Array()) {
-				return immediate(subject.As<v8::BigInt64Array>(), accept);
+				return self.immediate(subject.As<v8::BigInt64Array>(), accept);
 			} else if (subject->IsBigUint64Array()) {
-				return immediate(subject.As<v8::BigUint64Array>(), accept);
+				return self.immediate(subject.As<v8::BigUint64Array>(), accept);
 			} else {
 				throw js::type_error{u"Received exotic v8 'ArrayBufferView'"};
 			}
@@ -425,14 +425,56 @@ struct visit_value : visit_flat_value<Target> {
 
 		template <class Accept, class 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});
+		auto immediate(this auto& self, v8::Local<Type> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(v8_to_tag<Type>{}, self, value_of{self.witness(), subject});
 		}
 
 	private:
 		v8::Local<v8::Context> context_;
 };
 
+// Visitor with transfer delegate. The delegate is offered transferable subjects, claiming the ones
+// listed in its `transferList` before the underlying visitor gets a chance to copy them.
+template <class Target, class Delegate>
+struct visit_value_delegate : visit_value<Target> {
+	private:
+		using visit_type = visit_value<Target>;
+
+	public:
+		visit_value_delegate(auto* transfer, context_lock_witness lock, Delegate& delegate) :
+				visit_type{transfer, lock},
+				delegate_{delegate} {}
+		visit_value_delegate(auto* transfer, const auto& lock, Delegate& delegate) :
+				visit_value_delegate{transfer, context_lock_witness{util::slice(lock)}, delegate} {}
+
+		using visit_type::operator();
+		using visit_type::immediate;
+
+		template <class Accept>
+		auto immediate(this auto& self, v8::Local<v8::ArrayBuffer> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.claim_or_immediate(subject, accept);
+		}
+
+		template <class Accept>
+		auto immediate(this auto& self, v8::Local<iv8::DataBlock> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.claim_or_immediate(subject, accept);
+		}
+
+	private:
+		template <class Accept>
+		auto claim_or_immediate(this auto& self, auto subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (auto claimed = self.delegate_.get()(subject, self, accept)) {
+				return *std::move(claimed);
+			}
+			return self.visit_value<Target>::immediate(subject, accept);
+		}
+
+		std::reference_wrapper<Delegate> delegate_;
+};
+
+template <class Meta, class Delegate>
+using visit_value_delegate_with = visit_cached_immediate<visit_value_delegate<typename Meta::accept_reference_type, Delegate>>;
+
 // Forward `value_of<T>` back to acceptor
 template <class Tag>
 struct visit_v8_value_of {
@@ -512,6 +554,21 @@ struct visit<Meta, v8::Local<Type>> : iv8::visit_value_with<Meta> {
 		using iv8::visit_value_with<Meta>::visit_value_with;
 };
 
+// `transferee_visit_subject` subject visitor
+template <class Meta, class Type, class Delegate>
+struct visit<Meta, transferee_visit_subject<v8::Local<Type>, Delegate>> : iv8::visit_value_delegate_with<Meta, Delegate> {
+	private:
+		using visit_type = iv8::visit_value_delegate_with<Meta, Delegate>;
+
+	public:
+		using visit_type::visit_type;
+
+		template <class Accept>
+		auto operator()(const transferee_visit_subject<v8::Local<Type>, Delegate>& subject, const Accept& accept) -> accept_target_t<Accept> {
+			return util::invoke_as<visit_type>(*this, *subject, accept);
+		}
+};
+
 // value_of<T> visitor
 template <class Meta, class Tag>
 struct visit<Meta, iv8::value_of<Tag>> : iv8::visit_v8_value_of<Tag> {

package/value/array.cc

@@ -1,15 +1,16 @@
 module v8_js;
+import auto_js;
 import util;
 import v8;
 
 namespace js::iv8 {
 
 auto value_for_array::begin() const -> iterator {
-	return iterator{util::slice(*this), context(), 0};
+	return iterator{util::slice(*this), context(), 0, maybe_sparse_};
 }
 
 auto value_for_array::end() const -> iterator {
-	return iterator{util::slice(*this), context(), size()};
+	return iterator{util::slice(*this), context(), size(), maybe_sparse_};
 }
 
 auto value_for_array::size() const -> std::uint32_t {
@@ -20,12 +21,16 @@ auto value_for_array::size() const -> std::uint32_t {
 	return length_ - 1;
 }
 
-value_for_array::iterator::iterator(v8::Local<v8::Array> array, v8::Local<v8::Context> context, std::uint32_t index) :
+value_for_array::iterator::iterator(v8::Local<v8::Array> array, v8::Local<v8::Context> context, std::uint32_t index, bool maybe_sparse) :
 		array_{array},
 		context_{context},
-		index_{index} {}
+		index_{index},
+		maybe_sparse_{maybe_sparse} {}
 
 auto value_for_array::iterator::operator*() const -> value_type {
+	if (maybe_sparse_ && !iv8::unmaybe(array_->Has(context_, index_))) {
+		throw js::type_error{u"Sparse arrays are not supported"};
+	}
 	return iv8::unmaybe(array_->Get(context_, index_));
 }
 

package/value/array.h.cc

@@ -12,14 +12,21 @@ class value_for_array : public handle_with_context<v8::Array> {
 		class iterator;
 		struct handle_data;
 		using value_type = v8::Local<v8::Value>;
-		using handle_with_context<v8::Array>::handle_with_context;
+
+		value_for_array() = default;
+		explicit value_for_array(v8::Local<v8::Context> context, v8::Local<v8::Array> array, bool maybe_sparse = true) :
+				handle_with_context{context, array},
+				maybe_sparse_{maybe_sparse} {}
+		explicit value_for_array(context_lock_witness lock, v8::Local<v8::Array> array, bool maybe_sparse = true) :
+				value_for_array{lock.context(), array, maybe_sparse} {}
 
 		[[nodiscard]] auto begin() const -> iterator;
 		[[nodiscard]] auto end() const -> iterator;
 		[[nodiscard]] auto size() const -> std::uint32_t;
 
 	private:
-		mutable std::uint32_t length_{};
+		bool maybe_sparse_ : 1 = true;
+		mutable std::uint32_t length_ : 31 {};
 };
 
 class value_for_array::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
@@ -30,7 +37,7 @@ class value_for_array::iterator : public util::random_access_iterator_facade<std
 		using value_type = value_for_array::value_type;
 
 		iterator() = default;
-		iterator(v8::Local<v8::Array> array, v8::Local<v8::Context> context, std::uint32_t index);
+		iterator(v8::Local<v8::Array> array, v8::Local<v8::Context> context, std::uint32_t index, bool maybe_sparse);
 
 		auto operator*() const -> value_type;
 		auto operator+=(difference_type offset) -> iterator&;
@@ -43,6 +50,7 @@ class value_for_array::iterator : public util::random_access_iterator_facade<std
 		v8::Local<v8::Array> array_;
 		v8::Local<v8::Context> context_;
 		std::uint32_t index_{};
+		bool maybe_sparse_{};
 };
 
 static_assert(std::ranges::range<value_for_array>);

package/value/external.h.cc

@@ -0,0 +1,136 @@
+module;
+#include <v8_js/version.h>
+export module v8_js:external;
+import :collected_handle;
+import :lock;
+import std;
+import v8;
+
+namespace js::iv8 {
+
+// Untagged `v8::External` for pointer types.
+export template <class Type>
+class untagged_external : public v8::External {
+	public:
+		[[nodiscard]] auto value() const -> Type*;
+
+		static auto make(isolate_lock_witness lock, Type* value) -> v8::Local<untagged_external>;
+		static auto make_collected(const collected_handle_lock& lock, auto&&... args) -> v8::Local<untagged_external>
+			requires std::constructible_from<Type, decltype(args)...>;
+
+	private:
+		constexpr static auto type_tag = v8::ExternalPointerTypeTag{1};
+};
+
+// Tagged `v8::External` which holds a v8-managed host object.
+export template <class Type>
+class tagged_external : public v8::External {
+	private:
+		class holder;
+
+	public:
+		[[nodiscard]] auto get() const -> Type&;
+		[[nodiscard]] auto try_cast() const -> Type*;
+		static auto make_collected(const collected_handle_lock& lock, auto&&... args) -> v8::Local<tagged_external>
+			requires std::constructible_from<Type, decltype(args)...>;
+
+	private:
+		constexpr static auto type_tag = v8::ExternalPointerTypeTag{2};
+};
+
+// Inherited by `tagged_external<Type>::holder` instances
+struct external_type_tag {
+		std::reference_wrapper<const std::type_info> type_tag;
+};
+
+// Host object with type tag
+template <class Type>
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+class tagged_external<Type>::holder
+		: public external_type_tag,
+			public Type {
+	public:
+		explicit holder(auto&&... args)
+			requires std::constructible_from<Type, decltype(args)...> :
+				external_type_tag{typeid(Type)},
+				Type{std::forward<decltype(args)>(args)...} {}
+};
+
+// ---
+
+// untagged_external
+template <class Type>
+auto untagged_external<Type>::value() const -> Type* {
+#if V8_HAS_TAGGED_EXTERNAL
+	return static_cast<Type*>(Value(type_tag));
+#else
+	return static_cast<Type*>(Value());
+#endif
+}
+
+template <class Type>
+auto untagged_external<Type>::make(isolate_lock_witness lock, Type* value) -> v8::Local<untagged_external> {
+#if V8_HAS_TAGGED_EXTERNAL
+	return v8::External::New(lock.isolate(), value, type_tag).template As<untagged_external>();
+#else
+	return v8::External::New(lock.isolate(), value).template As<untagged_external>();
+#endif
+}
+
+template <class Type>
+auto untagged_external<Type>::make_collected(const collected_handle_lock& lock, auto&&... args) -> v8::Local<untagged_external>
+	requires std::constructible_from<Type, decltype(args)...> {
+	using collected_handle_type = collected_handle<untagged_external, Type>;
+	auto collected_handle = collected_handle_type::make(lock, std::forward<decltype(args)>(args)...);
+	auto value =
+#if V8_HAS_TAGGED_EXTERNAL
+		v8::External::New(lock.isolate(), collected_handle->get(), type_tag).template As<untagged_external>();
+#else
+		v8::External::New(lock.isolate(), collected_handle->get()).template As<untagged_external>();
+#endif
+	collected_handle_type::reset(lock, std::move(collected_handle), value);
+	return value;
+}
+
+// tagged_external
+template <class Type>
+auto tagged_external<Type>::get() const -> Type& {
+	auto* pointer = try_cast();
+	if (pointer == nullptr) {
+		throw std::logic_error{"external tag mismatch"};
+	} else {
+		return *pointer;
+	}
+}
+
+template <class Type>
+auto tagged_external<Type>::try_cast() const -> Type* {
+	auto& object =
+#if V8_HAS_TAGGED_EXTERNAL
+		*static_cast<holder*>(Value(type_tag));
+#else
+		*static_cast<holder*>(Value());
+#endif
+	if (object.type_tag.get() == typeid(Type)) {
+		return &object;
+	} else {
+		return nullptr;
+	}
+}
+
+template <class Type>
+auto tagged_external<Type>::make_collected(const collected_handle_lock& lock, auto&&... args) -> v8::Local<tagged_external>
+	requires std::constructible_from<Type, decltype(args)...> {
+	using collected_handle_type = collected_handle<tagged_external, holder>;
+	auto collected_handle = collected_handle_type::make(lock, std::forward<decltype(args)>(args)...);
+	auto value =
+#if V8_HAS_TAGGED_EXTERNAL
+		v8::External::New(lock.isolate(), collected_handle->get(), type_tag).template As<tagged_external>();
+#else
+		v8::External::New(lock.isolate(), collected_handle->get()).template As<tagged_external>();
+#endif
+	collected_handle_type::reset(lock, std::move(collected_handle), value);
+	return value;
+}
+
+} // namespace js::iv8

package/value/object.cc

@@ -52,7 +52,7 @@ auto value_for_object::keys() const -> const value_for_array& {
 			v8::IndexFilter::kIncludeIndices,
 			v8::KeyConversionMode::kKeepNumbers
 		);
-		keys_ = value_for_array{context(), unmaybe(property_names)};
+		keys_ = value_for_array{context(), unmaybe(property_names), false};
 	}
 	return keys_;
 }

package/value/primitive.cc

@@ -1,5 +1,3 @@
-module;
-#include <v8_js/version.h>
 module v8_js;
 import :primitive;
 import std;
@@ -68,14 +66,4 @@ value_for_date::operator js_clock::time_point() const {
 	return js_clock::time_point{js_clock::duration{(*this)->ValueOf()}};
 }
 
-// `value_for_external`
-value_for_external::operator void*() const {
-#if V8_HAS_TAGGED_EXTERNAL
-	// TODO: Use this feature
-	return (*this)->Value(0);
-#else
-	return (*this)->Value();
-#endif
-}
-
 } // namespace js::iv8

package/value/primitive.h.cc

@@ -62,6 +62,7 @@ class value_for_external : public v8::Local<v8::External> {
 		explicit value_for_external(null_lock_witness /*witness*/, v8::Local<v8::External> handle) :
 				v8::Local<v8::External>{handle} {}
 
+		// nb: Unused at this time.
 		[[nodiscard]] explicit operator void*() const;
 };
 

package/value/value.cc

@@ -1,6 +1,7 @@
 export module v8_js:value;
 export import :array_buffer;
 export import :array;
+export import :external;
 export import :fixed_array;
 export import :function;
 export import :object;