@isolated-vm/experimental 0.0.9 → 0.0.10

package/addon/transfer/accept.cc

@@ -13,79 +13,79 @@ struct accept_vm_primitive {
 		explicit accept_vm_primitive(const basic_lock& lock) : lock_{lock} {}
 
 		// undefined
-		auto operator()(undefined_tag /*tag*/, visit_holder /*visit*/, std::monostate /*subject*/) const -> value_of<undefined_tag> {
-			return value_of<undefined_tag>::make(lock());
+		auto operator()(undefined_tag /*tag*/, visit_holder /*visit*/, std::monostate /*subject*/) const -> local_of<undefined_tag> {
+			return local_of<undefined_tag>::make(lock());
 		}
 
-		auto operator()(undefined_tag tag, visit_holder visit, const auto& /*subject*/) const -> value_of<undefined_tag> {
+		auto operator()(undefined_tag tag, visit_holder visit, const auto& /*subject*/) const -> local_of<undefined_tag> {
 			return (*this)(tag, visit, std::monostate{});
 		}
 
 		// null
-		auto operator()(null_tag /*tag*/, visit_holder /*visit*/, std::nullptr_t /*subject*/) const -> value_of<null_tag> {
-			return value_of<null_tag>::make(lock());
+		auto operator()(null_tag /*tag*/, visit_holder /*visit*/, std::nullptr_t /*subject*/) const -> local_of<null_tag> {
+			return local_of<null_tag>::make(lock());
 		}
 
-		auto operator()(null_tag tag, visit_holder visit, const auto& /*subject*/) const -> value_of<null_tag> {
+		auto operator()(null_tag tag, visit_holder visit, const auto& /*subject*/) const -> local_of<null_tag> {
 			return (*this)(tag, visit, nullptr);
 		}
 
 		// boolean
-		auto operator()(boolean_tag /*tag*/, visit_holder /*visit*/, bool subject) const -> value_of<boolean_tag> {
-			return value_of<boolean_tag>::make(lock(), subject);
+		auto operator()(boolean_tag /*tag*/, visit_holder /*visit*/, bool subject) const -> local_of<boolean_tag> {
+			return local_of<boolean_tag>::make(lock(), subject);
 		}
 
 		// number
-		auto operator()(number_tag_of<double> /*tag*/, visit_holder /*visit*/, double subject) const -> value_of<number_tag_of<double>> {
-			return value_of<number_tag>::make(lock(), subject);
+		auto operator()(number_tag_of<double> /*tag*/, visit_holder /*visit*/, double subject) const -> local_of<number_tag_of<double>> {
+			return local_of<number_tag_of<double>>::make(lock(), subject);
 		}
 
-		auto operator()(number_tag_of<std::int32_t> /*tag*/, visit_holder /*visit*/, std::int32_t subject) const -> value_of<number_tag_of<std::int32_t>> {
-			return value_of<number_tag>::make(lock(), subject);
+		auto operator()(number_tag_of<std::int32_t> /*tag*/, visit_holder /*visit*/, std::int32_t subject) const -> local_of<number_tag_of<std::int32_t>> {
+			return local_of<number_tag_of<std::int32_t>>::make(lock(), subject);
 		}
 
-		auto operator()(number_tag /*tag*/, visit_holder visit, auto&& subject) const -> value_of<number_tag> {
+		auto operator()(number_tag /*tag*/, visit_holder visit, auto&& subject) const -> local_of<number_tag> {
 			return (*this)(number_tag_of<double>{}, visit, double{std::forward<decltype(subject)>(subject)});
 		}
 
 		template <class Type>
-		auto operator()(number_tag_of<Type> tag, visit_holder visit, auto&& subject) const -> value_of<number_tag_of<Type>> {
+		auto operator()(number_tag_of<Type> tag, visit_holder visit, auto&& subject) const -> local_of<number_tag_of<Type>> {
 			return (*this)(tag, visit, Type{std::forward<decltype(subject)>(subject)});
 		}
 
 		// string
 		auto operator()(string_tag_of<char> /*tag*/, visit_holder /*visit*/, std::string_view subject) const
-			-> js::referenceable_value<value_of<string_tag_of<char>>> {
-			return js::referenceable_value{value_of<string_tag>::make(lock(), subject)};
+			-> js::referenceable_value<local_of<string_tag_of<char>>> {
+			return js::referenceable_value{local_of<string_tag_of<char>>::make(lock(), subject)};
 		}
 
 		auto operator()(string_tag_of<char16_t> /*tag*/, visit_holder /*visit*/, std::u16string_view subject) const
-			-> js::referenceable_value<value_of<string_tag_of<char16_t>>> {
-			return js::referenceable_value{value_of<string_tag>::make(lock(), subject)};
+			-> js::referenceable_value<local_of<string_tag_of<char16_t>>> {
+			return js::referenceable_value{local_of<string_tag_of<char16_t>>::make(lock(), subject)};
 		}
 
 		auto operator()(string_tag /*tag*/, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<value_of<string_tag>> {
+			-> js::referenceable_value<local_of<string_tag>> {
 			auto value = (*this)(string_tag_of<char16_t>{}, visit, std::u16string_view{std::forward<decltype(subject)>(subject)});
-			return js::referenceable_value{value_of<string_tag>{*value}};
+			return js::referenceable_value{local_of<string_tag>{*value}};
 		}
 
 		template <class Char>
 		auto operator()(string_tag_of<Char> tag, visit_holder visit, std::convertible_to<std::basic_string_view<Char>> auto&& subject) const
-			-> js::referenceable_value<value_of<string_tag_of<Char>>> {
+			-> js::referenceable_value<local_of<string_tag_of<Char>>> {
 			return (*this)(tag, visit, std::basic_string_view<Char>{std::forward<decltype(subject)>(subject)});
 		}
 
 		template <class Char>
 		auto operator()(string_tag_of<Char> tag, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<value_of<string_tag_of<Char>>> {
+			-> js::referenceable_value<local_of<string_tag_of<Char>>> {
 			return (*this)(tag, visit, std::basic_string<Char>{std::forward<decltype(subject)>(subject)});
 		}
 
 		// bigint (int64)
 		auto operator()(bigint_tag_of<std::int64_t> /*tag*/, visit_holder /*visit*/, std::int64_t subject) const
-			-> js::referenceable_value<value_of<bigint_tag_of<std::int64_t>>> {
-			return js::referenceable_value{value_of<bigint_tag>::make(lock(), subject)};
+			-> js::referenceable_value<local_of<bigint_tag_of<std::int64_t>>> {
+			return js::referenceable_value{local_of<bigint_tag_of<std::int64_t>>::make(lock(), subject)};
 		}
 
 		[[nodiscard]] auto lock() const -> const basic_lock& { return lock_; }
@@ -102,22 +102,22 @@ struct accept_vm_prototype : accept_vm_primitive {
 
 		// cast primitive to prototype
 		template <std::convertible_to<primitive_tag> Tag>
-		auto operator()(Tag tag, auto& visit, auto&& subject) const -> value_of<prototype_tag> {
+		auto operator()(Tag tag, auto& visit, auto&& subject) const -> local_of<prototype_tag> {
 			const accept_vm_primitive& accept = *this;
 			auto result = accept(tag, visit, std::forward<decltype(subject)>(subject));
 			constexpr auto unwrap = util::overloaded{
 				[](auto value) { return value; },
 				[]<class Type>(js::referenceable_value<Type> value) { return *std::move(value); },
 			};
-			return value_of<prototype_tag>::from(unwrap(result));
+			return local_of<prototype_tag>::from(unwrap(result));
 		}
 
 		// function
-		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> value_of<function_prototype_tag> {
+		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> local_of<function_prototype_tag> {
 			using lock_type = const runtime_lock&;
 			auto [ function, length ] = make_free_function<lock_type>(std::move(subject).callback);
 			auto data = make_callback_storage(std::move(function));
-			return value_of<function_prototype_tag>::make(lock(), std::move(data), length);
+			return local_of<function_prototype_tag>::make(lock(), std::move(data), length);
 		}
 };
 
@@ -128,39 +128,39 @@ struct accept_vm_value : accept_vm_primitive {
 
 		// bigint (from words)
 		auto operator()(bigint_tag_of<js::bigint> /*tag*/, visit_holder /*visit*/, const js::bigint& subject) const
-			-> js::referenceable_value<value_of<bigint_tag_of<js::bigint>>> {
-			return js::referenceable_value{value_of<bigint_tag>::make(lock(), subject)};
+			-> js::referenceable_value<local_of<bigint_tag_of<js::bigint>>> {
+			return js::referenceable_value{local_of<bigint_tag_of<js::bigint>>::make(lock(), subject)};
 		}
 
 		auto operator()(bigint_tag_of<js::bigint> /*tag*/, visit_holder /*visit*/, js::bigint&& subject) const
-			-> js::referenceable_value<value_of<bigint_tag_of<js::bigint>>> {
-			return js::referenceable_value{value_of<bigint_tag>::make(lock(), std::move(subject))};
+			-> js::referenceable_value<local_of<bigint_tag_of<js::bigint>>> {
+			return js::referenceable_value{local_of<bigint_tag_of<js::bigint>>::make(lock(), std::move(subject))};
 		}
 
 		auto operator()(bigint_tag /*tag*/, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<value_of<bigint_tag>> {
+			-> js::referenceable_value<local_of<bigint_tag>> {
 			auto value = (*this)(bigint_tag_of<js::bigint>{}, visit, js::bigint{std::forward<decltype(subject)>(subject)});
-			return js::referenceable_value{value_of<bigint_tag>{*std::move(value)}};
+			return js::referenceable_value{local_of<bigint_tag>{*std::move(value)}};
 		}
 
 		template <class Type>
 		auto operator()(bigint_tag_of<Type> tag, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<value_of<bigint_tag_of<Type>>> {
+			-> js::referenceable_value<local_of<bigint_tag_of<Type>>> {
 			return (*this)(tag, visit, Type{std::forward<decltype(subject)>(subject)});
 		}
 
 		// array
 		auto operator()(this const auto& self, list_tag /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<value_of<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
+			-> js::deferred_receiver<local_of<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
 			return {
-				value_of<list_tag>::make(self.lock()),
+				local_of<list_tag>::make(self.lock()),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](value_of<list_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+				[](local_of<list_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
 					for (auto&& [ key, value ] : util::forward_range(std::forward<decltype(range)>(range))) {
 						auto name = visit.first(std::forward<decltype(key)>(key), self);
 						auto item = visit.first(std::forward<decltype(value)>(value), self);
-						receiver.set(self.lock(), name, item);
+						receiver->set(self.lock(), name, item);
 					}
 				},
 			};
@@ -168,17 +168,17 @@ struct accept_vm_value : accept_vm_primitive {
 
 		// vectors
 		auto operator()(this const auto& self, vector_tag /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<value_of<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
+			-> js::deferred_receiver<local_of<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
 			auto [... size ] = util::maybe_range_size(subject);
 			return {
-				value_of<list_tag>::make(self.lock(), size...),
+				local_of<list_tag>::make(self.lock(), size...),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](value_of<list_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+				[](local_of<list_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					int 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);
-						receiver.set(self.lock(), ii++, item);
+						receiver->set(self.lock(), ii++, item);
 					}
 				},
 			};
@@ -186,15 +186,15 @@ struct accept_vm_value : accept_vm_primitive {
 
 		template <std::size_t Size>
 		auto operator()(this const auto& self, tuple_tag<Size> /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<value_of<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
+			-> js::deferred_receiver<local_of<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
 			return {
-				value_of<list_tag>::make(self.lock(), Size),
+				local_of<list_tag>::make(self.lock(), Size),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](value_of<list_tag> receiver, auto& self, auto& visit, auto /*&&*/ tuple) -> void {
+				[](local_of<list_tag> receiver, 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(receiver.set(self.lock(), indices, element));
+						unmaybe(receiver->set(self.lock(), indices, element));
 					}());
 				}
 			};
@@ -202,15 +202,15 @@ struct accept_vm_value : accept_vm_primitive {
 
 		// dictionary
 		auto operator()(this const auto& self, dictionary_tag /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<value_of<dictionary_tag>, decltype(self), decltype(visit), decltype(subject)> {
+			-> js::deferred_receiver<local_of<dictionary_tag>, decltype(self), decltype(visit), decltype(subject)> {
 			return {
-				value_of<record_tag>::make(self.lock()),
+				local_of<record_tag>::make(self.lock()),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](value_of<dictionary_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+				[](local_of<dictionary_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					for (auto&& [ key, value ] : util::into_range(subject)) {
 						auto name = visit.first(std::forward<decltype(key)>(key), self);
 						auto item = visit.first(std::forward<decltype(value)>(value), self);
-						receiver.set(self.lock(), name, item);
+						receiver->set(self.lock(), name, item);
 					}
 				},
 			};
@@ -219,30 +219,30 @@ struct accept_vm_value : accept_vm_primitive {
 		// structs
 		template <std::size_t Size>
 		auto operator()(this const auto& self, struct_tag<Size> /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<value_of<record_tag>, decltype(self), decltype(visit), decltype(subject)> {
+			-> js::deferred_receiver<local_of<record_tag>, decltype(self), decltype(visit), decltype(subject)> {
 			return {
-				value_of<record_tag>::make(self.lock()),
+				local_of<record_tag>::make(self.lock()),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](value_of<record_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+				[](local_of<record_tag> receiver, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					self.template accept_entry_pair_struct<Size>(visit, receiver, std::forward<decltype(subject)>(subject));
 				}
 			};
 		}
 
 		template <std::size_t Size>
-		auto accept_entry_pair_struct(this const auto& self, auto& visit, value_of<record_tag> receiver, auto&& subject) -> void {
+		auto accept_entry_pair_struct(this const auto& self, auto& visit, local_of<record_tag> receiver, auto&& subject) -> void {
 			const auto [... indices ] = util::sequence<Size>;
 			(..., [ & ]() -> void {
 				auto accept_entry = accept_entry_pair<decltype(self), decltype(self)>{self};
 				auto entry = visit(std::integral_constant<std::size_t, indices>{}, std::forward<decltype(subject)>(subject), accept_entry);
-				receiver.set(self.lock(), entry.first, entry.second);
+				receiver->set(self.lock(), entry.first, entry.second);
 			}());
 		}
 
 		// array buffer
 		auto operator()(array_buffer_tag /*tag*/, visit_holder /*visit*/, js::array_buffer subject) const
-			-> js::referenceable_value<value_of<array_buffer_tag>> {
-			return js::referenceable_value{value_of<array_buffer_tag>::make(lock(), std::move(subject))};
+			-> js::referenceable_value<local_of<array_buffer_tag>> {
+			return js::referenceable_value{local_of<array_buffer_tag>::make(lock(), std::move(subject))};
 		}
 
 		[[nodiscard]] auto lock() const -> const runtime_lock& {
@@ -250,6 +250,20 @@ struct accept_vm_value : accept_vm_primitive {
 		}
 };
 
+// Forward `value_of<T>`
+template <class Tag>
+struct accept_vm_value_of {
+	public:
+		explicit accept_vm_value_of(auto* /*transfer*/) {}
+
+		auto operator()(Tag /*tag*/, visit_holder /*visit*/, value_of<Tag> subject) const -> value_of<Tag> {
+			return subject;
+		}
+
+		consteval static auto accept_tags_of() { return std::tuple{Tag{}}; }
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+};
+
 // Object key lookup (struct_template, etc)
 template <class Meta, auto Key, class Type>
 struct accept_vm_property_value {
@@ -267,7 +281,7 @@ struct accept_vm_property_value {
 		}
 
 	private:
-		mutable visit_key_literal<Key, value_of<record_tag>> first;
+		mutable visit_key_literal<Key, local_of<record_tag>> first;
 		accept_value<Meta, Type> second;
 };
 
@@ -277,31 +291,37 @@ namespace js {
 using namespace isolated_vm;
 
 template <class Tag>
-struct accept_property_subject<value_of<Tag>> : std::type_identity<value_of<record_tag>> {};
+struct accept_property_subject<local_of<Tag>> : std::type_identity<local_of<record_tag>> {};
 
 // Primitive acceptor
 template <std::convertible_to<value_tag> Tag>
 	requires std::is_convertible_v<Tag, primitive_tag>
-struct accept<void, value_of<Tag>> : accept_vm_primitive {
+struct accept<void, local_of<Tag>> : accept_vm_primitive {
 		using accept_vm_primitive::accept_vm_primitive;
 };
 
 // Template / prototype acceptor
 template <class Tag>
 	requires std::is_convertible_v<Tag, prototype_tag>
-struct accept<void, value_of<Tag>> : accept_vm_prototype {
+struct accept<void, local_of<Tag>> : accept_vm_prototype {
 		using accept_vm_prototype::accept_vm_prototype;
 };
 
 // Value acceptor
 template <std::convertible_to<value_tag> Tag>
-struct accept<void, value_of<Tag>> : accept_vm_value {
+struct accept<void, local_of<Tag>> : accept_vm_value {
 		using accept_vm_value::accept_vm_value;
 };
 
+// Forward `value_of<T>`
+template <class Meta, class Tag>
+struct accept<Meta, isolated_vm::value_of<Tag>> : isolated_vm::accept_vm_value_of<Tag> {
+		using isolated_vm::accept_vm_value_of<Tag>::accept_vm_value_of;
+};
+
 // Object key lookup (struct_template, etc)
 template <class Meta, auto Key, class Type>
-struct accept_property_value<Meta, Key, Type, value_of<record_tag>> : accept_vm_property_value<Meta, Key, Type> {
+struct accept_property_value<Meta, Key, Type, local_of<record_tag>> : accept_vm_property_value<Meta, Key, Type> {
 		using accept_vm_property_value<Meta, Key, Type>::accept_vm_property_value;
 };
 

package/addon/transfer/visit.cc

@@ -47,18 +47,18 @@ struct visit_vm_property_key {
 		explicit visit_vm_property_key(Visit& visit) : visit_{visit} {}
 
 		template <class Accept>
-		auto operator()(value_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			auto accept_as = [ & ]<class Tag>(Tag tag) -> auto {
-				auto value = bound_value{lock(), value_of<Tag>::from(subject)};
+				auto value = value_of{lock(), local_of<Tag>::from(subject)};
 				return accept(tag, *this, value);
 			};
-			if (subject.is_string()) {
-				if (value_of<string_tag>::from(subject).is_latin1()) {
+			if (subject->is_string()) {
+				if (local_of<string_tag>::from(subject)->is_latin1()) {
 					return accept_as(string_tag_of<char>{});
 				} else {
 					return accept_as(string_tag_of<char16_t>{});
 				}
-			} else if (subject.is_number()) {
+			} else if (subject->is_number()) {
 				return accept_as(number_tag_of<std::int32_t>{});
 			} else {
 				return accept_as(symbol_tag{});
@@ -75,16 +75,16 @@ template <auto Key>
 struct visit_vm_key_literal {
 		explicit constexpr visit_vm_key_literal(auto* /*transfer*/) {}
 
-		auto operator()(const auto& /*anything*/, const auto& accept_or_visit) -> value_of<name_tag> {
+		auto operator()(const auto& /*anything*/, const auto& accept_or_visit) -> local_of<name_tag> {
 			if (!local_key_) {
 				constexpr auto key = util::make_consteval_string_view(Key);
-				local_key_ = transfer_in<value_of<name_tag>>(key, accept_or_visit.lock());
+				local_key_ = transfer_in<local_of<name_tag>>(key, accept_or_visit.lock());
 			}
 			return local_key_;
 		}
 
 	private:
-		value_of<name_tag> local_key_;
+		local_of<name_tag> local_key_;
 };
 
 struct visit_vm_value {
@@ -92,38 +92,38 @@ struct visit_vm_value {
 		explicit visit_vm_value(const runtime_lock& lock) : lock_{lock} {}
 
 		template <class Accept>
-		auto operator()(value_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
 			// TODO: reference map
 			return util::template_traverse(
 				accept_tags_of_v<Accept>,
 				util::overloaded{
 					// Fast paths
 					[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_undefined() ? accept_as(undefined_tag{}, subject, accept) : next();
+						return subject->is_undefined() ? accept_as(undefined_tag{}, subject, accept) : next();
 					},
 					[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_null() ? accept_as(null_tag{}, subject, accept) : next();
+						return subject->is_null() ? accept_as(null_tag{}, subject, accept) : next();
 					},
 					[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_boolean() ? accept_as(boolean_tag{}, subject, accept) : next();
+						return subject->is_boolean() ? accept_as(boolean_tag{}, subject, accept) : next();
 					},
 					[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_number() ? accept_as(number_tag{}, subject, accept) : next();
+						return subject->is_number() ? accept_as(number_tag{}, subject, accept) : next();
 					},
 					[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_string() ? accept_as(string_tag{}, subject, accept) : next();
+						return subject->is_string() ? accept_as(string_tag{}, subject, accept) : next();
 					},
 					[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_bigint() ? accept_as(bigint_tag{}, subject, accept) : next();
+						return subject->is_bigint() ? accept_as(bigint_tag{}, subject, accept) : next();
 					},
 					[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_date() ? accept_as(date_tag{}, subject, accept) : next();
+						return subject->is_date() ? accept_as(date_tag{}, subject, accept) : next();
 					},
 					[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_array() ? accept_as(list_tag{}, subject, accept) : next();
+						return subject->is_array() ? accept_as(list_tag{}, subject, accept) : next();
 					},
 					[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-						return subject.is_function() ? accept_as(function_tag{}, subject, accept) : next();
+						return subject->is_function() ? accept_as(function_tag{}, subject, accept) : next();
 					},
 
 					// Unknown tag
@@ -131,12 +131,12 @@ struct visit_vm_value {
 
 					// Slow path
 					[ & ]() -> accept_target_t<Accept> {
-						auto type = subject.inspect();
+						auto type = subject->inspect();
 						const auto [... primitive_types ] = primitive_typeofs;
 						if ((... || (type == primitive_types))) {
-							return inspected(type, value_of<primitive_tag>::from(subject), accept);
+							return inspected(type, local_of<primitive_tag>::from(subject), accept);
 						} else {
-							return inspected(type, value_of<object_tag>::from(subject), accept);
+							return inspected(type, local_of<object_tag>::from(subject), accept);
 						}
 					},
 				}
@@ -144,13 +144,13 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			switch (subject.inspect()) {
+		auto operator()(local_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			switch (subject->inspect()) {
 				case value_typeof::number: return accept_as(number_tag{}, subject, accept);
 				case value_typeof::number_i32: return accept_as(number_tag_of<std::int32_t>{}, subject, accept);
 				default: std::unreachable();
@@ -158,8 +158,8 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			switch (subject.inspect()) {
+		auto operator()(local_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			switch (subject->inspect()) {
 				case value_typeof::string: return accept_as(string_tag_of<char16_t>{}, subject, accept);
 				case value_typeof::string_latin1: return accept_as(string_tag_of<char>{}, subject, accept);
 				default: std::unreachable();
@@ -167,8 +167,8 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			switch (subject.inspect()) {
+		auto operator()(local_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			switch (subject->inspect()) {
 				case value_typeof::bigint: return accept_as(bigint_tag{}, subject, accept);
 				case value_typeof::bigint_i64: return accept_as(bigint_tag_of<std::int64_t>{}, subject, accept);
 				default: std::unreachable();
@@ -176,18 +176,18 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		auto operator()(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return inspected(subject.inspect(), subject, accept);
+		auto operator()(local_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return inspected(subject->inspect(), subject, accept);
 		}
 
 		[[nodiscard]] auto lock() const -> const runtime_lock& { return lock_.get(); }
@@ -195,7 +195,7 @@ struct visit_vm_value {
 
 	private:
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<primitive_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			switch (type_of) {
 				case value_typeof::undefined: return accept_as(undefined_tag{}, subject, accept);
 				case value_typeof::null: return accept_as(null_tag{}, subject, accept);
@@ -212,13 +212,13 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			const auto [... data_block_types ] = data_block_typeofs;
 			const auto [... array_buffer_view_types ] = array_buffer_view_typeofs;
 			if ((... || (type_of == data_block_types))) {
-				return inspected(type_of, value_of<data_block_tag>::from(subject), accept);
+				return inspected(type_of, local_of<data_block_tag>::from(subject), accept);
 			} else if ((... || (type_of == array_buffer_view_types))) {
-				return inspected(type_of, value_of<array_buffer_view_tag>::from(subject), accept);
+				return inspected(type_of, local_of<array_buffer_view_tag>::from(subject), accept);
 			} else {
 				switch (type_of) {
 					case value_typeof::external: return accept_as(external_tag{}, subject, accept);
@@ -228,12 +228,12 @@ struct visit_vm_value {
 					case value_typeof::array:
 						{
 							auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_vm_value>, visit_vm_value&>{*this};
-							return accept(list_tag{}, visit_entry, bound_value{lock_, value_of<record_tag>::from(subject)});
+							return accept(list_tag{}, visit_entry, value_of{lock_, local_of<record_tag>::from(subject)});
 						}
 					case value_typeof::dictionary:
 						{
 							auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_vm_value>, visit_vm_value&>{*this};
-							return accept(dictionary_tag{}, visit_entry, bound_value{lock_, value_of<record_tag>::from(subject)});
+							return accept(dictionary_tag{}, visit_entry, value_of{lock_, local_of<record_tag>::from(subject)});
 						}
 					default: std::unreachable();
 				}
@@ -241,7 +241,7 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			switch (type_of) {
 				case value_typeof::array_buffer: return accept_as(array_buffer_tag{}, subject, accept);
 				case value_typeof::shared_array_buffer: return accept_as(shared_array_buffer_tag{}, subject, accept);
@@ -250,7 +250,7 @@ struct visit_vm_value {
 		}
 
 		template <class Accept>
-		constexpr auto inspected(value_typeof type_of, value_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		constexpr auto inspected(value_typeof type_of, local_of<array_buffer_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			switch (type_of) {
 				case value_typeof::bigint64_array: return accept_as(typed_array_tag_of<std::int64_t>{}, subject, accept);
 				case value_typeof::biguint64_array: return accept_as(typed_array_tag_of<std::uint64_t>{}, subject, accept);
@@ -270,25 +270,68 @@ struct visit_vm_value {
 		}
 
 		template <class Accept, class Tag>
-		auto accept_as(Tag tag, value_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(tag, *this, bound_value{lock_, value_of<Tag>::from(subject)});
+		auto accept_as(Tag tag, local_of<> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(tag, *this, value_of{lock_, local_of<Tag>::from(subject)});
 		}
 
 		std::reference_wrapper<const runtime_lock> lock_;
 };
 
+// Forward `value_of<T>` back to acceptor
+template <class Tag>
+struct visit_vm_value_of {
+	private:
+		using visit_type = visit_vm_value;
+
+	public:
+		constexpr explicit visit_vm_value_of(const runtime_lock& lock) : visit_{lock} {}
+
+		template <class Accept>
+		constexpr auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, visit_, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, object_tag>
+		constexpr auto operator()(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_type>, visit_type&>{visit_};
+			return accept(object_tag{}, visit_entry, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, list_tag>
+		constexpr auto operator()(value_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_vm_property_key<visit_type>, visit_type&>{visit_};
+			return accept(list_tag{}, visit_entry, subject);
+		}
+
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+
+	private:
+		visit_type visit_;
+};
+
 } // namespace isolated_vm
 
 namespace js {
 using namespace isolated_vm;
 
 template <class Tag>
-struct visit<void, value_of<Tag>> : visit_vm_value {
+struct visit<void, local_of<Tag>> : visit_vm_value {
 		using visit_vm_value::visit_vm_value;
 };
 
+// Pass through `value_of<Tag>`
+template <class Tag>
+struct visit<void, isolated_vm::value_of<Tag>> : isolated_vm::visit_vm_value_of<Tag> {
+		using isolated_vm::visit_vm_value_of<Tag>::visit_vm_value_of;
+};
+
+template <class Tag>
+struct visit_subject_for<isolated_vm::value_of<Tag>> : std::type_identity<isolated_vm::local_of<Tag>> {};
+
 template <auto Key>
-struct visit_key_literal<Key, value_of<record_tag>> : visit_vm_key_literal<Key> {
+struct visit_key_literal<Key, local_of<record_tag>> : visit_vm_key_literal<Key> {
 		using visit_vm_key_literal<Key>::visit_vm_key_literal;
 };