@auto_js/napi 0.0.7 → 0.0.9

package/transfer/visit.cc

@@ -24,7 +24,7 @@ struct visit_property_name {
 		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
 			return visit_.get().lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				auto accept_as = [ & ]<class Tag>(Tag tag) -> auto {
-					auto value = bound_value{napi_env{visit_.get()}, value_of<Tag>::from(subject)};
+					auto value = value_of{napi_env{visit_.get()}, local_of<Tag>::from(subject)};
 					return accept(tag, *this, value);
 				};
 				switch (napi::invoke(napi_typeof, napi_env{visit_.get()}, subject)) {
@@ -50,17 +50,17 @@ struct visit_napi_key_literal {
 
 		auto operator()(const auto& /*could_be_literally_anything*/, const auto& accept_or_visit) -> napi_value {
 			const auto make = util::overloaded{
-				[](auto& env, std::string_view subject) -> napi::value_of<string_tag_of<char>> {
+				[](auto& env, std::string_view subject) -> napi::local_of<string_tag_of<char>> {
 					auto* value = napi::invoke(node_api_create_property_key_latin1, napi_env{env}, subject.data(), subject.length());
-					return napi::value_of<string_tag_of<char>>::from(value);
+					return napi::local_of<string_tag_of<char>>::from(value);
 				},
-				[](auto& env, std::u16string_view subject) -> napi::value_of<string_tag_of<char16_t>> {
+				[](auto& env, std::u16string_view subject) -> napi::local_of<string_tag_of<char16_t>> {
 					auto* value = napi::invoke(node_api_create_property_key_utf16, napi_env{env}, subject.data(), subject.length());
-					return napi::value_of<string_tag_of<char16_t>>::from(value);
+					return napi::local_of<string_tag_of<char16_t>>::from(value);
 				},
-				[](auto& env, std::u8string_view subject) -> napi::value_of<string_tag_of<char8_t>> {
+				[](auto& env, std::u8string_view subject) -> napi::local_of<string_tag_of<char8_t>> {
 					auto* value = napi::invoke(node_api_create_property_key_utf8, napi_env{env}, reinterpret_cast<const char*>(subject.data()), subject.length());
-					return napi::value_of<string_tag_of<char8_t>>::from(value);
+					return napi::local_of<string_tag_of<char8_t>>::from(value);
 				},
 			};
 			if (local_key_ == napi_value{}) {
@@ -109,7 +109,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// If the private `immediate` operation is defined: this public operation will first
 		// perform a reference map lookup, then delegate to the private operation if not found.
 		template <class Tag, class Accept>
-		auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
+		auto operator()(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
 			requires requires { immediate(subject, accept); } {
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				return immediate(subject, accept);
@@ -118,31 +118,31 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 		// Visit operations for non-refable types.
 		template <class Accept>
-		auto operator()(value_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (maybe_fast_is_number_int32(subject).value_or(false)) {
-				return immediate(value_of<number_tag_of<std::int32_t>>::from(subject), accept);
+		auto operator()(local_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (maybe_is_number_int32(subject).value_or(false)) {
+				return immediate(local_of<number_tag_of<std::int32_t>>::from(subject), accept);
 			} else {
-				return immediate(value_of<number_tag_of<double>>::from(subject), accept);
+				return immediate(local_of<number_tag_of<double>>::from(subject), accept);
 			}
 		}
 
 		template <class Accept, class Type>
-		auto operator()(value_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return immediate(subject, accept);
 		}
 
@@ -153,91 +153,100 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 			// Check the reference map, and lookup type via napi
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				// This is the pure-napi implementation
-				auto slow_path = [ & ]() -> accept_target_t<Accept> {
-					auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
-					switch (type_of) {
-						case napi_undefined:
-							return (*this)(value_of<undefined_tag>::from(subject), accept);
-						case napi_null:
-							return (*this)(value_of<null_tag>::from(subject), accept);
-						case napi_boolean:
-							return (*this)(value_of<boolean_tag>::from(subject), accept);
-						case napi_number:
-							return (*this)(value_of<number_tag>::from(subject), accept);
-						case napi_string:
-							return immediate(value_of<string_tag>::from(subject), accept);
-						case napi_symbol:
-							return immediate(value_of<symbol_tag>::from(subject), accept);
-						case napi_object:
-							return immediate(value_of<object_tag>::from(subject), accept);
-						case napi_function:
-							return immediate(value_of<function_tag>::from(subject), accept);
-						case napi_external:
-							return immediate(value_of<external_tag>::from(subject), accept);
-						case napi_bigint:
-							return immediate(value_of<bigint_tag>::from(subject), accept);
-					}
-					std::unreachable();
+				auto slow_path = util::overloaded{
+					[ & ]() -> accept_target_t<Accept> {
+						auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
+						switch (type_of) {
+							case napi_undefined:
+								return (*this)(local_of<undefined_tag>::from(subject), accept);
+							case napi_null:
+								return (*this)(local_of<null_tag>::from(subject), accept);
+							case napi_boolean:
+								return (*this)(local_of<boolean_tag>::from(subject), accept);
+							case napi_number:
+								return (*this)(local_of<number_tag>::from(subject), accept);
+							case napi_string:
+								return immediate(local_of<string_tag>::from(subject), accept);
+							case napi_symbol:
+								return immediate(local_of<symbol_tag>::from(subject), accept);
+							case napi_object:
+								return immediate(local_of<object_tag>::from(subject), accept);
+							case napi_function:
+								return immediate(local_of<function_tag>::from(subject), accept);
+							case napi_external:
+								return immediate(local_of<external_tag>::from(subject), accept);
+							case napi_bigint:
+								return immediate(local_of<bigint_tag>::from(subject), accept);
+						}
+						std::unreachable();
+					},
+
+					[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
 				};
 
-				if (has_fast_is_functions) {
-					return util::template_traverse(
-						accept_tags_of_v<Accept>,
-						util::overloaded{
-							// Fast paths
-							[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_undefined(subject) ? (*this)(value_of<undefined_tag>::from(subject), accept) : next();
-							},
-							[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_null(subject) ? (*this)(value_of<null_tag>::from(subject), accept) : next();
-							},
-							[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_boolean(subject) ? (*this)(value_of<boolean_tag>::from(subject), accept) : next();
-							},
-							[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_number(subject) ? (*this)(value_of<number_tag>::from(subject), accept) : next();
-							},
-							[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_string(subject) ? immediate(value_of<string_tag>::from(subject), accept) : next();
-							},
-							[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_bigint(subject) ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
-							},
-							[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(value_of<date_tag>::from(subject), accept) : next();
-							},
-							[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_array(subject) ? immediate(value_of<list_tag>::from(subject), accept) : next();
-							},
-							[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
-								// checks. We don't really want to accept those types here, I don't think..
-								return fast_is_object(subject) ? immediate(value_of<object_tag>::from(subject), accept) : next();
-							},
-							[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_function(subject) ? immediate(value_of<function_tag>::from(subject), accept) : next();
-							},
-
-							// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
-							// differentiate between.
-							[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-							[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-
-							// Unknown tag
-							[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-
-							// Slow path
-							slow_path,
+				// Universal fast checks
+				auto fast_path = util::overloaded{
+					[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_undefined(napi_env{*this}, subject) ? (*this)(local_of<undefined_tag>::from(subject), accept) : next();
+					},
+					[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_null(napi_env{*this}, subject) ? (*this)(local_of<null_tag>::from(subject), accept) : next();
+					},
+					[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						if (fast_is_false(napi_env{*this}, subject)) {
+							return (*this)(local_of<false_tag>::from(subject), accept);
+						} else if (fast_is_true(napi_env{*this}, subject)) {
+							return (*this)(local_of<true_tag>::from(subject), accept);
+						} else {
+							return next();
 						}
-					);
+					},
+				};
+
+				// Extended fast checks
+				auto extended_fast_path = util::overloaded{
+					[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_number(subject) ? (*this)(local_of<number_tag>::from(subject), accept) : next();
+					},
+					[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_string(subject) ? immediate(local_of<string_tag>::from(subject), accept) : next();
+					},
+					[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_bigint(subject) ? immediate(local_of<bigint_tag>::from(subject), accept) : next();
+					},
+					[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(local_of<date_tag>::from(subject), accept) : next();
+					},
+					[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_array(subject) ? immediate(local_of<list_tag>::from(subject), accept) : next();
+					},
+					[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
+						// checks. We don't really want to accept those types here, I don't think..
+						return fast_is_object(subject) ? immediate(local_of<object_tag>::from(subject), accept) : next();
+					},
+					[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_function(subject) ? immediate(local_of<function_tag>::from(subject), accept) : next();
+					},
+
+					// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
+					// differentiate between.
+					[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+					[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+				};
+
+				if (has_extended_fast_is_functions) {
+					auto traverse = util::overloaded{fast_path, extended_fast_path, slow_path};
+					return util::template_traverse(accept_tags_of_v<Accept>, traverse);
 				} else {
-					return slow_path();
+					auto traverse = util::overloaded{fast_path, slow_path};
+					return util::template_traverse(accept_tags_of_v<Accept>, traverse);
 				}
 			});
 		}
 
 		template <class Accept>
-		auto operator()(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				return util::template_traverse(
 					accept_tags_of_v<Accept>,
@@ -265,79 +274,79 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// I think this only applies to `symbol_tag`
 		template <class Accept, class Tag>
 			requires std::is_convertible_v<Tag, primitive_tag>
-		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// strings
 		template <class Accept>
-		auto immediate(value_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (maybe_fast_is_string_one_byte(subject).value_or(false)) {
-				return accept_tagged(value_of<string_tag_of<char>>::from(subject), accept);
+		auto immediate(local_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (maybe_is_string_latin1(subject).value_or(false)) {
+				return accept_tagged(local_of<string_tag_of<char>>::from(subject), accept);
 			} else {
-				return accept_tagged(value_of<string_tag_of<char16_t>>::from(subject), accept);
+				return accept_tagged(local_of<string_tag_of<char16_t>>::from(subject), accept);
 			}
 		}
 
 		// bigint
 		template <class Accept>
-		auto immediate(value_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(value_of<bigint_tag_of<bigint>>::from(subject), accept);
+		auto immediate(local_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept_tagged(local_of<bigint_tag_of<bigint>>::from(subject), accept);
 		}
 
 		// date
 		template <class Accept>
-		auto immediate(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			if (napi::invoke(napi_is_array, napi_env{*this}, subject)) {
-				return immediate(value_of<list_tag>::from(subject), accept);
+				return immediate(local_of<list_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
-				return immediate(value_of<date_tag>::from(subject), accept);
+				return immediate(local_of<date_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_typedarray, napi_env{*this}, subject)) {
-				return immediate(value_of<typed_array_tag>::from(subject), accept);
+				return immediate(local_of<typed_array_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
-				return immediate(value_of<data_view_tag>::from(subject), accept);
+				return immediate(local_of<data_view_tag>::from(subject), accept);
 			} else if (maybe_is_shared_array_buffer(env_.get(), subject).value_or(false)) {
-				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
-			} else if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
-				return immediate(value_of<array_buffer_tag>::from(subject), accept);
+				return immediate(local_of<shared_array_buffer_tag>::from(subject), accept);
+			} else if (is_object_array_buffer(env_.get(), subject)) {
+				return immediate(local_of<array_buffer_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_promise, napi_env{*this}, subject)) {
-				return immediate(value_of<promise_tag>::from(subject), accept);
+				return immediate(local_of<promise_tag>::from(subject), accept);
 			} else {
-				return immediate(value_of<dictionary_tag>::from(subject), accept);
+				return immediate(local_of<dictionary_tag>::from(subject), accept);
 			}
 		}
 
 		// date
 		template <class Accept>
-		auto immediate(value_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// data blocks
 		template <class Accept>
-		auto immediate(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
-				return immediate(value_of<array_buffer_tag>::from(subject), accept);
+		auto immediate(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (is_data_block_array_buffer(env_.get(), subject)) {
+				return immediate(local_of<array_buffer_tag>::from(subject), accept);
 			} else {
-				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
+				return immediate(local_of<shared_array_buffer_tag>::from(subject), accept);
 			}
 		}
 
 		template <class Accept, class Tag>
 			requires std::is_convertible_v<Tag, data_block_tag>
-		auto immediate(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// array buffer views
 		template <class Accept>
-		auto immediate(value_of<typed_array_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto bound_subject_variant = bound_value_for_typed_array::make_bound(environment(), subject);
+		auto immediate(local_of<typed_array_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto bound_subject_variant = value_for_typed_array::make_bound(environment(), subject);
 			if (bound_subject_variant.index() == std::variant_npos) {
 				std::unreachable();
 			} else {
 				return std::visit(
-					[ & ]<class Tag>(bound_value<Tag> value) -> accept_target_t<Accept> {
+					[ & ]<class Tag>(value_of<Tag> value) -> accept_target_t<Accept> {
 						return accept(Tag{}, *this, value);
 					},
 					bound_subject_variant
@@ -346,53 +355,87 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		template <class Accept>
-		auto immediate(value_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// externals
 		template <class Accept>
-		auto immediate(value_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// promise
 		template <class Accept>
-		auto immediate(value_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// function
 		template <class Accept>
-		auto immediate(value_of<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(local_of<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
 			return accept_tagged(subject, accept);
 		}
 
 		// array
 		template <class Accept>
-		auto immediate(value_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto target = napi::bound_value{napi_env{*this}, value_of<list_tag>::from(subject)};
+		auto immediate(local_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto target = napi::value_of{napi_env{*this}, local_of<list_tag>::from(subject)};
 			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
 			return accept(list_tag{}, visit_entry, target);
 		}
 
 		// object / record
 		template <class Accept>
-		auto immediate(value_of<dictionary_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			auto target = napi::bound_value{napi_env{*this}, value_of<dictionary_tag>::from(subject)};
+		auto immediate(local_of<dictionary_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto target = napi::value_of{napi_env{*this}, local_of<dictionary_tag>::from(subject)};
 			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
 			return accept(dictionary_tag{}, visit_entry, target);
 		}
 
-		// Convenience function which wraps in `napi::bound_value` and invokes `accept`.
+		// Convenience function which wraps in `napi::value_of` and invokes `accept`.
 		template <class Tag, class Accept>
-		[[nodiscard]] auto accept_tagged(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(Tag{}, *this, napi::bound_value{environment(), subject});
+		[[nodiscard]] auto accept_tagged(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, *this, napi::value_of{environment(), subject});
 		}
 
 		std::reference_wrapper<Environment> env_;
 };
 
+// Forward `value_of<T>` back to acceptor
+template <class Meta, class Tag>
+struct visit_napi_value_of {
+	private:
+		using visit_type = visit_value_with<Meta>;
+
+	public:
+		constexpr explicit visit_napi_value_of(auto* transfer, auto& environment) : visit_{transfer, environment} {}
+
+		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_property_name<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_property_name<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 js::napi
 
 namespace js {
@@ -404,10 +447,19 @@ struct visit<Meta, napi_value> : napi::visit_value_with<Meta> {
 };
 
 template <class Meta, class Tag>
-struct visit<Meta, napi::value_of<Tag>> : napi::visit_value_with<Meta> {
+struct visit<Meta, napi::local_of<Tag>> : napi::visit_value_with<Meta> {
 		using napi::visit_value_with<Meta>::visit_value_with;
 };
 
+// Pass through `value_of<Tag>`
+template <class Meta, class Tag>
+struct visit<Meta, napi::value_of<Tag>> : napi::visit_napi_value_of<Meta, Tag> {
+		using napi::visit_napi_value_of<Meta, Tag>::visit_napi_value_of;
+};
+
+template <class Tag>
+struct visit_subject_for<napi::value_of<Tag>> : std::type_identity<napi_value> {};
+
 // Object key maker via napi
 template <auto Key>
 struct visit_key_literal<Key, napi_value> : napi::visit_napi_key_literal<Key> {

package/value/array.cc

@@ -1,29 +1,27 @@
 module napi_js;
-import :api;
-import :bound_value;
 
 namespace js::napi {
 
-auto bound_value_for_vector::begin() const -> iterator {
+auto value_for_vector::begin() const -> iterator {
 	return {*this, 0};
 }
 
-auto bound_value_for_vector::end() const -> iterator {
+auto value_for_vector::end() const -> iterator {
 	return {*this, size()};
 }
 
-auto bound_value_for_vector::size() const -> std::uint32_t {
+auto value_for_vector::size() const -> std::uint32_t {
 	if (size_ == 0) {
 		size_ = napi::invoke(napi_get_array_length, env(), napi_value{*this}) + 1;
 	}
 	return size_ - 1;
 }
 
-bound_value_for_vector::iterator::iterator(bound_value_for_vector subject, size_type index) :
+value_for_vector::iterator::iterator(value_for_vector subject, size_type index) :
 		subject_{subject},
 		index_{index} {}
 
-auto bound_value_for_vector::iterator::operator*() const -> value_type {
+auto value_for_vector::iterator::operator*() const -> value_type {
 	return value_type::from(napi::invoke(napi_get_element, subject_.env(), napi_value{subject_}, index_));
 }
 

package/value/array.h.cc

@@ -5,11 +5,11 @@ import util;
 
 namespace js::napi {
 
-class bound_value_for_vector : public bound_value_next<vector_tag> {
+class value_for_vector : public value_next<vector_tag> {
 	public:
 		class iterator;
-		using bound_value_next<vector_tag>::bound_value_next;
-		using value_type = value_of<value_tag>;
+		using value_next<vector_tag>::value_next;
+		using value_type = local_of<value_tag>;
 
 		[[nodiscard]] auto begin() const -> iterator;
 		[[nodiscard]] auto end() const -> iterator;
@@ -19,15 +19,15 @@ class bound_value_for_vector : public bound_value_next<vector_tag> {
 		mutable std::uint32_t size_{};
 };
 
-class bound_value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
+class value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
 	public:
 		using arithmetic_facade::operator+;
 		using difference_type = arithmetic_facade::difference_type;
 		using size_type = std::uint32_t;
-		using value_type = bound_value_for_vector::value_type;
+		using value_type = value_for_vector::value_type;
 
 		iterator() = default;
-		iterator(bound_value_for_vector subject, size_type index);
+		iterator(value_for_vector subject, size_type index);
 
 		auto operator*() const -> value_type;
 
@@ -42,7 +42,7 @@ class bound_value_for_vector::iterator : public util::random_access_iterator_fac
 	private:
 		auto operator+() const -> size_type { return index_; }
 
-		bound_value_for_vector subject_;
+		value_for_vector subject_;
 		size_type index_{};
 };