@auto_js/napi 0.0.10 → 0.0.12

package/transfer/visit.cc

@@ -1,4 +1,5 @@
 export module napi_js:visit;
+import :lock;
 import :utility;
 import :value;
 import std;
@@ -24,7 +25,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 = value_of{napi_env{visit_.get()}, local_of<Tag>::from(subject)};
+					auto value = value_of{visit_.get().lock(), local_of<Tag>::from(subject)};
 					return accept(tag, *this, value);
 				};
 				switch (napi::invoke(napi_typeof, napi_env{visit_.get()}, subject)) {
@@ -36,7 +37,7 @@ struct visit_property_name {
 			});
 		}
 
-		[[nodiscard]] auto environment() const -> auto& { return visit_.get().environment(); }
+		[[nodiscard]] auto lock() const -> const auto& { return visit_.get().lock(); }
 
 	private:
 		std::reference_wrapper<Visit> visit_;
@@ -50,34 +51,34 @@ 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::local_of<string_tag_of<char>> {
-					auto* value = napi::invoke(node_api_create_property_key_latin1, napi_env{env}, subject.data(), subject.length());
+				[](environment_lock_witness lock, std::string_view subject) -> napi::local_of<string_tag_of<char>> {
+					auto* value = napi::invoke(node_api_create_property_key_latin1, napi_env{lock}, subject.data(), subject.length());
 					return napi::local_of<string_tag_of<char>>::from(value);
 				},
-				[](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());
+				[](environment_lock_witness lock, std::u16string_view subject) -> napi::local_of<string_tag_of<char16_t>> {
+					auto* value = napi::invoke(node_api_create_property_key_utf16, napi_env{lock}, subject.data(), subject.length());
 					return napi::local_of<string_tag_of<char16_t>>::from(value);
 				},
-				[](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());
+				[](environment_lock_witness lock, std::u8string_view subject) -> napi::local_of<string_tag_of<char8_t>> {
+					auto* value = napi::invoke(node_api_create_property_key_utf8, napi_env{lock}, reinterpret_cast<const char*>(subject.data()), subject.length());
 					return napi::local_of<string_tag_of<char8_t>>::from(value);
 				},
 			};
 			if (local_key_ == napi_value{}) {
 				constexpr auto key = util::make_consteval_string_view(Key);
-				auto& environment = accept_or_visit.environment();
-				auto storage = environment.string_table_storage(Key);
+				const auto& lock = accept_or_visit.lock();
+				auto storage = lock->string_table_storage(Key);
 				if (storage) {
 					auto& reference = *storage;
 					if (reference) {
-						local_key_ = reference.get(environment);
+						local_key_ = reference.get(lock);
 					} else {
-						auto value = make(environment, key);
-						reference.reset(environment, value);
+						auto value = make(lock, key);
+						reference.reset(lock, value);
 						local_key_ = napi_value{value};
 					}
 				} else {
-					return make(environment, key);
+					return make(lock, key);
 				}
 			}
 			return local_key_;
@@ -90,7 +91,7 @@ struct visit_napi_key_literal {
 // Base napi visitor implementing all functionality. Napi doesn't give us granular information like
 // "is this a latin1 string" and all checks must be made at once. So it's structured it great deal
 // differently than the v8 visitor.
-template <auto_environment Environment, class Ref>
+template <class Lock, class Ref>
 struct visit_value;
 
 template <class Meta>
@@ -98,85 +99,85 @@ using visit_value_with = visit_value<
 	typename Meta::visit_context_type,
 	typename Meta::accept_reference_type>;
 
-template <auto_environment Environment, class Reference>
+template <class Lock, class Reference>
 struct visit_value : reference_map_t<Reference, reference_map_type> {
 	public:
 		using reference_map_t<Reference, reference_map_type>::lookup_or_visit;
 
-		visit_value(auto* /*transfer*/, Environment& env) :
-				env_{env} {}
+		visit_value(auto* /*transfer*/, const Lock& lock) :
+				lock_{lock} {}
 
-		// 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.
+		// If the `immediate` operation is defined: this operation will first perform a
+		// reference map lookup, then delegate to the `immediate` operation if not found.
 		template <class Tag, class 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);
+		auto operator()(this auto& self, local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
+			requires requires { self.immediate(subject, accept); } {
+			return self.lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
+				return self.immediate(subject, accept);
 			});
 		}
 
 		// Visit operations for non-refable types.
 		template <class Accept>
-		auto operator()(local_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return immediate(subject, accept);
+		auto operator()(this auto& self, local_of<null_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(local_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return immediate(subject, accept);
+		auto operator()(this auto& self, local_of<undefined_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(local_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return immediate(subject, accept);
+		auto operator()(this auto& self, local_of<boolean_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.immediate(subject, accept);
 		}
 
 		template <class Accept>
-		auto operator()(local_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(this auto& self, 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);
+				return self.immediate(local_of<number_tag_of<std::int32_t>>::from(subject), accept);
 			} else {
-				return immediate(local_of<number_tag_of<double>>::from(subject), accept);
+				return self.immediate(local_of<number_tag_of<double>>::from(subject), accept);
 			}
 		}
 
 		template <class Accept, class Type>
-		auto operator()(local_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return immediate(subject, accept);
+		auto operator()(this auto& self, local_of<number_tag_of<Type>> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.immediate(subject, accept);
 		}
 
 		// General purpose visit operation which actually performs the type check
 		template <class Accept>
-		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(this auto& self, napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
 
 			// Check the reference map, and lookup type via napi
-			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
+			return self.lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				// This is the pure-napi implementation
 				auto slow_path = util::overloaded{
 					[ & ] -> accept_target_t<Accept> {
-						auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
+						auto type_of = napi::invoke(napi_typeof, napi_env{self}, subject);
 						switch (type_of) {
 							case napi_undefined:
-								return (*this)(local_of<undefined_tag>::from(subject), accept);
+								return self(local_of<undefined_tag>::from(subject), accept);
 							case napi_null:
-								return (*this)(local_of<null_tag>::from(subject), accept);
+								return self(local_of<null_tag>::from(subject), accept);
 							case napi_boolean:
-								return (*this)(local_of<boolean_tag>::from(subject), accept);
+								return self(local_of<boolean_tag>::from(subject), accept);
 							case napi_number:
-								return (*this)(local_of<number_tag>::from(subject), accept);
+								return self(local_of<number_tag>::from(subject), accept);
 							case napi_string:
-								return immediate(local_of<string_tag>::from(subject), accept);
+								return self.immediate(local_of<string_tag>::from(subject), accept);
 							case napi_symbol:
-								return immediate(local_of<symbol_tag>::from(subject), accept);
+								return self.immediate(local_of<symbol_tag>::from(subject), accept);
 							case napi_object:
-								return immediate(local_of<object_tag>::from(subject), accept);
+								return self.immediate(local_of<object_tag>::from(subject), accept);
 							case napi_function:
-								return immediate(local_of<function_tag>::from(subject), accept);
+								return self.immediate(local_of<function_tag>::from(subject), accept);
 							case napi_external:
-								return immediate(local_of<external_tag>::from(subject), accept);
+								return self.immediate(local_of<external_tag>::from(subject), accept);
 							case napi_bigint:
-								return immediate(local_of<bigint_tag>::from(subject), accept);
+								return self.immediate(local_of<bigint_tag>::from(subject), accept);
 						}
 						std::unreachable();
 					},
@@ -187,16 +188,16 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 				// 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();
+						return fast_is_undefined(napi_env{self}, subject) ? self(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();
+						return fast_is_null(napi_env{self}, subject) ? self(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);
+						if (fast_is_false(napi_env{self}, subject)) {
+							return self(local_of<false_tag>::from(subject), accept);
+						} else if (fast_is_true(napi_env{self}, subject)) {
+							return self(local_of<true_tag>::from(subject), accept);
 						} else {
 							return next();
 						}
@@ -206,27 +207,27 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 				// 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();
+						return fast_is_number(subject) ? self(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();
+						return fast_is_string(subject) ? self.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();
+						return fast_is_bigint(subject) ? self.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();
+						return napi::invoke(napi_is_date, napi_env{self}, subject) ? self.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();
+						return fast_is_array(subject) ? self.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();
+						return fast_is_object(subject) ? self.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();
+						return fast_is_function(subject) ? self.immediate(local_of<function_tag>::from(subject), accept) : next();
 					},
 
 					// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
@@ -246,19 +247,19 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		template <class 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> {
+		auto operator()(this auto& self, local_of<data_block_tag> 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);
 						}
 					}
 				);
@@ -266,88 +267,88 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		// extras
-		[[nodiscard]] auto environment() const -> Environment& { return env_; }
-		explicit operator napi_env() const { return napi_env{env_.get()}; }
+		[[nodiscard]] auto lock() const -> const Lock& { return lock_; }
+		explicit operator napi_env() const { return napi_env{lock_.get()}; }
 		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
 
-	private:
+	protected:
 		// I think this only applies to `symbol_tag`
 		template <class Accept, class Tag>
 			requires std::is_convertible_v<Tag, primitive_tag>
-		auto immediate(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// strings
 		template <class Accept>
-		auto immediate(local_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+		auto immediate(this auto& self, 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);
+				return self.accept_tagged(local_of<string_tag_of<char>>::from(subject), accept);
 			} else {
-				return accept_tagged(local_of<string_tag_of<char16_t>>::from(subject), accept);
+				return self.accept_tagged(local_of<string_tag_of<char16_t>>::from(subject), accept);
 			}
 		}
 
 		// bigint
 		template <class 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);
+		auto immediate(this auto& self, local_of<bigint_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(local_of<bigint_tag_of<bigint>>::from(subject), accept);
 		}
 
-		// date
+		// objects
 		template <class 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(local_of<list_tag>::from(subject), accept);
-			} else if (napi::invoke(napi_is_date, napi_env{*this}, subject)) {
-				return immediate(local_of<date_tag>::from(subject), accept);
-			} else if (napi::invoke(napi_is_typedarray, napi_env{*this}, subject)) {
-				return immediate(local_of<typed_array_tag>::from(subject), accept);
-			} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
-				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(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(local_of<promise_tag>::from(subject), accept);
+		auto immediate(this auto& self, local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (napi::invoke(napi_is_array, napi_env{self}, subject)) {
+				return self.immediate(local_of<list_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_date, napi_env{self}, subject)) {
+				return self.immediate(local_of<date_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_typedarray, napi_env{self}, subject)) {
+				return self.immediate(local_of<typed_array_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_dataview, napi_env{self}, subject)) {
+				return self.immediate(local_of<data_view_tag>::from(subject), accept);
+			} else if (maybe_is_shared_array_buffer(napi_env{self}, subject).value_or(false)) {
+				return self.immediate(local_of<shared_array_buffer_tag>::from(subject), accept);
+			} else if (is_object_array_buffer(napi_env{self}, subject)) {
+				return self.immediate(local_of<array_buffer_tag>::from(subject), accept);
+			} else if (napi::invoke(napi_is_promise, napi_env{self}, subject)) {
+				return self.immediate(local_of<promise_tag>::from(subject), accept);
 			} else {
-				return immediate(local_of<dictionary_tag>::from(subject), accept);
+				return self.immediate(local_of<dictionary_tag>::from(subject), accept);
 			}
 		}
 
 		// date
 		template <class Accept>
-		auto immediate(local_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<date_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// data blocks
 		template <class 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);
+		auto immediate(this auto& self, local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			if (is_data_block_array_buffer(napi_env{self}, subject)) {
+				return self.immediate(local_of<array_buffer_tag>::from(subject), accept);
 			} else {
-				return immediate(local_of<shared_array_buffer_tag>::from(subject), accept);
+				return self.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(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// array buffer views
 		template <class Accept>
-		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);
+		auto immediate(this auto& self, local_of<typed_array_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto bound_subject_variant = value_for_typed_array::make_bound(self.lock(), subject);
 			if (bound_subject_variant.index() == std::variant_npos) {
 				std::unreachable();
 			} else {
 				return std::visit(
 					[ & ]<class Tag>(value_of<Tag> value) -> accept_target_t<Accept> {
-						return accept(Tag{}, *this, value);
+						return accept(Tag{}, self, value);
 					},
 					bound_subject_variant
 				);
@@ -355,51 +356,95 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		}
 
 		template <class Accept>
-		auto immediate(local_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<data_view_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// externals
 		template <class Accept>
-		auto immediate(local_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<external_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// promise
 		template <class Accept>
-		auto immediate(local_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<promise_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// function
 		template <class Accept>
-		auto immediate(local_of<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept_tagged(subject, accept);
+		auto immediate(this auto& self, local_of<function_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.accept_tagged(subject, accept);
 		}
 
 		// array
-		template <class Accept>
-		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};
+		template <class Visit, class Accept>
+		auto immediate(this Visit& self, local_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto target = napi::value_of{self.lock(), local_of<list_tag>::from(subject)};
+			auto visit_entry = visit_entry_pair<visit_property_name<Visit>, Visit&>{self};
 			return accept(list_tag{}, visit_entry, target);
 		}
 
 		// object / record
-		template <class Accept>
-		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};
+		template <class Visit, class Accept>
+		auto immediate(this Visit& self, local_of<dictionary_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto target = napi::value_of{self.lock(), local_of<dictionary_tag>::from(subject)};
+			auto visit_entry = visit_entry_pair<visit_property_name<Visit>, Visit&>{self};
 			return accept(dictionary_tag{}, visit_entry, target);
 		}
 
 		// Convenience function which wraps in `napi::value_of` and invokes `accept`.
 		template <class Tag, class Accept>
-		[[nodiscard]] auto accept_tagged(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return accept(Tag{}, *this, napi::value_of{environment(), subject});
+		[[nodiscard]] auto accept_tagged(this auto& self, local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, self, napi::value_of{self.lock(), subject});
+		}
+
+	private:
+		std::reference_wrapper<const Lock> lock_;
+};
+
+// Visitor with transfer delegate
+template <class Lock, class Reference, class Delegate>
+struct visit_value_delegate;
+
+template <class Meta, class Delegate>
+using visit_value_delegate_with =
+	visit_value_delegate<typename Meta::visit_context_type, typename Meta::accept_reference_type, Delegate>;
+
+template <class Lock, class Reference, class Delegate>
+struct visit_value_delegate : visit_value<Lock, Reference> {
+	private:
+		using visit_type = visit_value<Lock, Reference>;
+
+	public:
+		visit_value_delegate(auto* transfer, const Lock& lock, Delegate& delegate) :
+				visit_type{transfer, lock},
+				delegate_{delegate} {}
+
+		using visit_type::operator();
+		using visit_type::immediate;
+
+		template <class Accept>
+		auto immediate(this auto& self, local_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return self.claim_or_immediate(subject, accept);
+		}
+
+		template <class Accept>
+		auto immediate(this auto& self, local_of<data_block_tag> 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<Lock, Reference>::immediate(subject, accept);
 		}
 
-		std::reference_wrapper<Environment> env_;
+		std::reference_wrapper<Delegate> delegate_;
 };
 
 // Forward `value_of<T>` back to acceptor
@@ -409,7 +454,7 @@ struct visit_napi_value_of {
 		using visit_type = visit_value_with<Meta>;
 
 	public:
-		constexpr explicit visit_napi_value_of(auto* transfer, auto& environment) : visit_{transfer, environment} {}
+		constexpr explicit visit_napi_value_of(auto* transfer, const auto& lock) : visit_{transfer, lock} {}
 
 		template <class Accept>
 		constexpr auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
@@ -451,6 +496,21 @@ struct visit<Meta, napi::local_of<Tag>> : napi::visit_value_with<Meta> {
 		using napi::visit_value_with<Meta>::visit_value_with;
 };
 
+// `transferee_visit_subject` subject visitor
+template <class Meta, class Tag, class Delegate>
+struct visit<Meta, transferee_visit_subject<napi::local_of<Tag>, Delegate>> : napi::visit_value_delegate_with<Meta, Delegate> {
+	private:
+		using visit_type = napi::visit_value_delegate_with<Meta, Delegate>;
+
+	public:
+		using visit_type::visit_type;
+
+		template <class Accept>
+		auto operator()(const transferee_visit_subject<napi::local_of<Tag>, Delegate>& subject, const Accept& accept) -> accept_target_t<Accept> {
+			return util::invoke_as<visit_type>(*this, *subject, accept);
+		}
+};
+
 // Pass through `value_of<Tag>`
 template <class Meta, class Tag>
 struct visit<Meta, napi::value_of<Tag>> : napi::visit_napi_value_of<Meta, Tag> {

package/value/array.cc

@@ -22,7 +22,12 @@ value_for_vector::iterator::iterator(value_for_vector subject, size_type index)
 		index_{index} {}
 
 auto value_for_vector::iterator::operator*() const -> value_type {
-	return value_type::from(napi::invoke(napi_get_element, subject_.env(), napi_value{subject_}, index_));
+	auto lock = subject_.lock();
+	auto* subject = napi_value{subject_};
+	if (subject_.maybe_sparse_ && !fast_has_element(lock, subject, index_)) {
+		throw js::type_error{u"Sparse arrays are not supported"};
+	}
+	return value_type::from(fast_get_element(lock, subject, index_));
 }
 
 } // namespace js::napi

package/value/array.h.cc

@@ -8,15 +8,20 @@ namespace js::napi {
 class value_for_vector : public value_next<vector_tag> {
 	public:
 		class iterator;
-		using value_next<vector_tag>::value_next;
-		using value_type = local_of<value_tag>;
+		using value_type = local_of<>;
+
+		value_for_vector() = default;
+		value_for_vector(environment_lock_witness lock, local_of<vector_tag> value, bool maybe_sparse = true) :
+				value_next{lock, value},
+				maybe_sparse_{maybe_sparse} {}
 
 		[[nodiscard]] auto begin() const -> iterator;
 		[[nodiscard]] auto end() const -> iterator;
 		[[nodiscard]] auto size() const -> std::uint32_t;
 
 	private:
-		mutable std::uint32_t size_{};
+		bool maybe_sparse_ : 1 = true;
+		mutable std::uint32_t size_ : 31 {};
 };
 
 class value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {