@auto_js/napi 0.0.1 → 0.0.4

package/support/string_table.cc

@@ -1,9 +1,7 @@
-module;
-#include <string> // IWYU pragma: keep
-#include <type_traits>
 export module napi_js:string_table;
 import :reference;
 import auto_js;
+import std;
 import util;
 using namespace std::string_literals;
 
@@ -26,8 +24,8 @@ struct string_table_options {
 export template <const auto& Strings, string_table_options Options = {}>
 class string_table {
 	public:
-		auto string_table_storage(const auto& string_value) {
-			constexpr auto string_sv = util::consteval_string_view{string_value};
+		auto string_table_storage(auto string_value) {
+			constexpr auto string_sv = util::make_consteval_string_view(string_value);
 			constexpr auto index = string_table_of<Strings>.lookup(string_sv);
 			if constexpr (index) {
 				return util::just<napi::reference<string_tag>&>{string_literal_storage_.at(index).second};

package/support/utility.cc

@@ -1,8 +1,8 @@
 module;
-#include <functional>
+#include "auto_js/no_unique_address.h"
 export module napi_js:utility;
-import :environment;
 import nodejs;
+import std;
 import util;
 
 namespace js::napi {
@@ -11,47 +11,71 @@ namespace js::napi {
 
 // Null handle for both direct and indirect handles
 // Note: 1 -> 0x1'0000'0000
-const void* null_value_handle_ = nullptr;
-export auto* const null_value_handle = reinterpret_cast<napi_value>(&null_value_handle_);
+const std::uint64_t null_value_handle_data = 0x7f7f'7f7f'7f7f'7f7f;
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+auto* const null_value_handle = reinterpret_cast<napi_value>(const_cast<std::uint64_t*>(&null_value_handle_data));
 
-// Address equality for underlying napi handles.
+// Unwrap the v8 address of the napi handle. This points into the v8 heap.
 // NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
-export struct virtual_address_equal {
+struct virtual_handle_address {
 	protected:
-		~virtual_address_equal() = default;
+		~virtual_handle_address() = default;
 
 	public:
-		virtual auto operator()(napi_value left, napi_value right) const -> bool = 0;
+		virtual auto operator()(napi_value value) const noexcept -> void* = 0;
 };
 
-export struct direct_address_equal final : virtual_address_equal {
-		auto operator()(napi_value left, napi_value right) const -> bool final {
-			return left == right;
+struct direct_handle_address final : virtual_handle_address {
+		auto operator()(napi_value value) const noexcept -> void* final {
+			return value;
 		}
 };
 
-export struct indirect_address_equal final : virtual_address_equal {
-		auto operator()(napi_value left, napi_value right) const -> bool final {
-			auto* indirect_left = reinterpret_cast<void**>(left);
-			auto* indirect_right = reinterpret_cast<void**>(right);
-			return *indirect_left == *indirect_right;
+struct indirect_handle_address final : virtual_handle_address {
+		auto operator()(napi_value value) const noexcept -> void* final {
+			return *reinterpret_cast<void**>(value);
 		}
 };
 
-// Equality comparator which respects napi's handle types
+// Address equality for underlying napi handles.
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
+struct virtual_address_equal {
+	protected:
+		~virtual_address_equal() = default;
+
+	public:
+		virtual auto operator()(napi_value left, napi_value right) const noexcept -> bool = 0;
+};
+
+template <class Address>
+struct virtual_address_equal_of final : virtual_address_equal {
+	public:
+		auto operator()(napi_value left, napi_value right) const noexcept -> bool final {
+			return address_(left) == address_(right);
+		}
+
+	private:
+		NO_UNIQUE_ADDRESS Address address_;
+};
+
+using direct_address_equal = virtual_address_equal_of<direct_handle_address>;
+using indirect_address_equal = virtual_address_equal_of<indirect_handle_address>;
+
+// Polymorphic address equality operator
 export class address_equal {
 	private:
 		using virtual_equal_type = util::covariant_value<virtual_address_equal, direct_address_equal, indirect_address_equal>;
 
 	public:
-		explicit address_equal(const environment& env) :
+		explicit address_equal(bool uses_direct_handles) :
 				equal_{
-					env.uses_direct_handles()
+					uses_direct_handles
 						? virtual_equal_type{direct_address_equal{}}
 						: virtual_equal_type{indirect_address_equal{}}
 				} {}
 
-		auto operator()(napi_value left, napi_value right) const -> bool {
+		auto operator()(napi_value left, napi_value right) const noexcept -> bool {
+			// NOLINTNEXTLINE(bugprone-exception-escape)
 			return (*equal_)(left, right);
 		}
 
@@ -60,17 +84,19 @@ export class address_equal {
 };
 
 // Address hash for napi value handles.
-export struct direct_address_hash : std::hash<void*> {};
-
-export struct indirect_address_hash : std::hash<void*> {
-	private:
-		using std::hash<void*>::operator();
-
+template <class Address>
+struct address_hash_of final {
 	public:
 		auto operator()(napi_value value) const noexcept -> std::size_t {
-			auto* indirect_handle = reinterpret_cast<void**>(value);
-			return (*this)(*indirect_handle);
+			return hash_(address_(value));
 		}
+
+	private:
+		NO_UNIQUE_ADDRESS Address address_;
+		NO_UNIQUE_ADDRESS std::hash<void*> hash_;
 };
 
+using direct_address_hash = address_hash_of<direct_handle_address>;
+using indirect_address_hash = address_hash_of<indirect_handle_address>;
+
 } // namespace js::napi

package/transfer/accept.cc

@@ -1,349 +1,153 @@
-module;
-#include <concepts>
-#include <string_view>
-#include <tuple>
-#include <utility>
-#include <variant>
-#include <vector>
-export module napi_js:accept;
-import :api;
-import :container;
-import :environment_fwd;
-import :value;
-import util;
+module napi_js;
+import std;
 
-namespace js {
-using namespace napi;
+namespace js::napi {
 
-// Generic napi acceptor which accepts all value types.
-template <class Environment>
-struct accept_napi_value;
-
-template <class Meta>
-using accept_napi_value_with = accept_napi_value<typename Meta::accept_context_type>;
-
-template <class Environment>
-struct accept_napi_value : napi::environment_scope<Environment> {
-	public:
-		// nb: This marks this acceptor as referential!
-		using accept_reference_type = napi_value;
-
-		using napi::environment_scope<Environment>::environment;
-
-		explicit accept_napi_value(auto* /*transfer*/, auto& env) :
-				napi::environment_scope<Environment>{env} {}
-
-		// reference provider
-		constexpr auto operator()(std::type_identity<napi_value> /*type*/, napi_value value) const -> napi_value { return value; }
-
-		template <class Tag>
-		constexpr auto operator()(std::type_identity<napi::value<Tag>> /*type*/, napi_value value) const -> napi::value<Tag> {
-			return napi::value<Tag>::from(value);
-		}
+// undefined & null
+auto accept_basic_napi_value::operator()(undefined_tag /*tag*/, visit_holder /*visit*/, std::monostate /*subject*/) const -> value_of<undefined_tag> {
+	return value_of<undefined_tag>::from(napi::invoke(napi_get_undefined, napi_env{*this}));
+}
 
-		// undefined & null
-		auto operator()(undefined_tag /*tag*/, visit_holder /*visit*/, const auto& /*undefined*/) const -> napi::value<undefined_tag> {
-			return napi::value<undefined_tag>::make(environment(), std::monostate{});
-		}
+auto accept_basic_napi_value::operator()(null_tag /*tag*/, visit_holder /*visit*/, std::nullptr_t /*subject*/) const -> value_of<null_tag> {
+	return value_of<null_tag>::from(napi::invoke(napi_get_null, napi_env{*this}));
+}
 
-		auto operator()(null_tag /*tag*/, visit_holder /*visit*/, const auto& /*null*/) const -> napi::value<null_tag> {
-			return napi::value<null_tag>::make(environment(), nullptr);
-		}
+// boolean
+auto accept_basic_napi_value::operator()(boolean_tag /*tag*/, visit_holder /*visit*/, bool subject) const -> value_of<boolean_tag> {
+	return value_of<boolean_tag>::from(napi::invoke(napi_get_boolean, napi_env{*this}, subject));
+}
 
-		// boolean
-		auto operator()(boolean_tag /*tag*/, visit_holder /*visit*/, auto&& subject) const -> napi::value<boolean_tag> {
-			return napi::value<boolean_tag>::make(environment(), bool{std::forward<decltype(subject)>(subject)});
-		}
+// number
+auto accept_basic_napi_value::operator()(number_tag_of<double> /*tag*/, visit_holder /*visit*/, double subject) const -> value_of<number_tag_of<double>> {
+	return value_of<number_tag_of<double>>::from(napi::invoke(napi_create_double, napi_env{*this}, subject));
+}
 
-		// number
-		auto operator()(number_tag /*tag*/, visit_holder visit, auto&& subject) const -> napi::value<number_tag> {
-			return (*this)(number_tag_of<double>{}, visit, std::forward<decltype(subject)>(subject));
-		}
+auto accept_basic_napi_value::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_of<std::int32_t>>::from(napi::invoke(napi_create_int32, napi_env{*this}, subject));
+}
 
-		template <class Numeric>
-		auto operator()(number_tag_of<Numeric> /*tag*/, visit_holder /*visit*/, auto&& subject) const -> napi::value<number_tag> {
-			return napi::value<number_tag>::make(environment(), Numeric{std::forward<decltype(subject)>(subject)});
-		}
+auto accept_basic_napi_value::operator()(number_tag_of<std::uint32_t> /*tag*/, visit_holder /*visit*/, std::uint32_t subject) const -> value_of<number_tag_of<std::uint32_t>> {
+	return value_of<number_tag_of<std::uint32_t>>::from(napi::invoke(napi_create_uint32, napi_env{*this}, subject));
+}
 
-		// bigint
-		auto operator()(bigint_tag /*tag*/, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<napi::value<bigint_tag>> {
-			return (*this)(bigint_tag_of<bigint>{}, visit, std::forward<decltype(subject)>(subject));
-		}
+// string
+auto accept_basic_napi_value::operator()(string_tag_of<char> /*tag*/, visit_holder /*visit*/, std::string_view subject) const
+	-> js::referenceable_value<value_of<string_tag_of<char>>> {
+	auto* value = napi::invoke(napi_create_string_latin1, napi_env{*this}, subject.data(), subject.length());
+	return js::referenceable_value{value_of<string_tag_of<char>>::from(value)};
+}
 
-		auto operator()(bigint_tag_of<bigint> /*tag*/, visit_holder /*visit*/, auto&& subject) const
-			-> js::referenceable_value<napi::value<bigint_tag>> {
-			return js::referenceable_value{napi::value<bigint_tag>::make(environment(), js::bigint{std::forward<decltype(subject)>(subject)})};
-		}
+auto accept_basic_napi_value::operator()(string_tag_of<char8_t> /*tag*/, visit_holder /*visit*/, std::u8string_view subject) const
+	-> js::referenceable_value<value_of<string_tag_of<char8_t>>> {
+	auto* value = napi::invoke(napi_create_string_utf8, napi_env{*this}, reinterpret_cast<const char*>(subject.data()), subject.length());
+	return js::referenceable_value{value_of<string_tag_of<char8_t>>::from(value)};
+}
 
-		auto operator()(bigint_tag_of<bigint> /*tag*/, visit_holder /*visit*/, const js::bigint& subject) const
-			-> js::referenceable_value<napi::value<bigint_tag>> {
-			return js::referenceable_value{napi::value<bigint_tag>::make(environment(), subject)};
-		}
+auto accept_basic_napi_value::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>>> {
+	auto* value = napi::invoke(napi_create_string_utf16, napi_env{*this}, subject.data(), subject.length());
+	return js::referenceable_value{value_of<string_tag_of<char16_t>>::from(value)};
+}
 
-		template <class Numeric>
-		auto operator()(bigint_tag_of<Numeric> /*tag*/, visit_holder /*visit*/, auto&& subject) const
-			-> js::referenceable_value<napi::value<bigint_tag>> {
-			return js::referenceable_value{napi::value<bigint_tag>::make(environment(), Numeric{std::forward<decltype(subject)>(subject)})};
-		}
+// bigint
+auto accept_basic_napi_value::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>>> {
+	auto* value = napi::invoke(napi_create_bigint_int64, napi_env{*this}, subject);
+	return js::referenceable_value{value_of<bigint_tag_of<std::int64_t>>::from(value)};
+}
 
-		// string
-		auto operator()(string_tag /*tag*/, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<napi::value<string_tag>> {
-			return (*this)(string_tag_of<char16_t>{}, visit, std::forward<decltype(subject)>(subject));
-		}
+auto accept_basic_napi_value::operator()(bigint_tag_of<std::uint64_t> /*tag*/, visit_holder /*visit*/, std::uint64_t subject) const
+	-> js::referenceable_value<value_of<bigint_tag_of<std::uint64_t>>> {
+	auto* value = napi::invoke(napi_create_bigint_uint64, napi_env{*this}, subject);
+	return js::referenceable_value{value_of<bigint_tag_of<std::uint64_t>>::from(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<napi::value<string_tag>> {
-			return js::referenceable_value{napi::value<string_tag>::make(environment(), std::basic_string_view<Char>{std::forward<decltype(subject)>(subject)})};
-		}
+auto accept_basic_napi_value::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>>> {
+	auto* value = napi::invoke(napi_create_bigint_words, napi_env{*this}, subject.sign_bit(), subject.size(), subject.data());
+	return js::referenceable_value{value_of<bigint_tag_of<js::bigint>>::from(value)};
+}
 
-		template <class Char>
-		auto operator()(string_tag_of<Char> tag, visit_holder visit, auto&& subject) const
-			-> js::referenceable_value<napi::value<string_tag>> {
-			return (*this)(tag, visit, std::basic_string<Char>{std::forward<decltype(subject)>(subject)});
-		}
+// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+auto accept_basic_napi_value::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 (*this)(tag, visit, static_cast<const js::bigint&>(subject));
+}
 
-		// date
-		auto operator()(date_tag /*tag*/, visit_holder /*visit*/, auto&& subject) const
-			-> js::referenceable_value<napi::value<date_tag>> {
-			return js::referenceable_value{napi::value<date_tag>::make(environment(), js_clock::time_point{std::forward<decltype(subject)>(subject)})};
-		}
+// date
+auto accept_basic_napi_value::operator()(date_tag /*tag*/, visit_holder /*visit*/, js_clock::time_point subject) const
+	-> js::referenceable_value<value_of<date_tag>> {
+	auto value = value_of<date_tag>::from(napi::invoke(napi_create_date, napi_env{*this}, subject.time_since_epoch().count()));
+	return js::referenceable_value{value};
+}
 
-		// function
-		template <class Callback>
-		auto operator()(function_tag /*tag*/, visit_holder /*visit*/, js::free_function<Callback> subject) const -> napi::value<function_tag> {
-			return napi::value<function_tag>::make(environment(), std::forward<decltype(subject)>(subject));
-		}
+// error
+auto accept_basic_napi_value::operator()(error_tag /*tag*/, visit_holder visit, const js::error_value& subject) const
+	-> js::referenceable_value<value_of<error_tag>> {
+	auto* message = napi_value{js::transfer_in<value_of<string_tag>>(subject.message(), environment())};
+	auto* error = [ & ] -> napi_value {
+		switch (subject.name()) {
+			default:
+				return napi::invoke(napi_create_error, napi_env{*this}, napi_value{}, message);
+			case js::error_name::range_error:
+				return napi::invoke(napi_create_range_error, napi_env{*this}, napi_value{}, message);
+			case js::error_name::syntax_error:
+				return napi::invoke(node_api_create_syntax_error, napi_env{*this}, napi_value{}, message);
+			case js::error_name::type_error:
+				return napi::invoke(napi_create_type_error, napi_env{*this}, napi_value{}, message);
+		}
+	}();
+	auto stack = (*this)(string_tag{}, visit, subject.stack());
+	napi::invoke0(napi_set_named_property, napi_env{*this}, error, "stack", *std::move(stack));
+	return js::referenceable_value{value_of<error_tag>::from(error)};
+}
 
-		// error
-		auto operator()(error_tag /*tag*/, visit_holder /*visit*/, const auto& subject) const
-			-> js::referenceable_value<napi::value<error_tag>> {
-			auto* message = napi_value{napi::value<string_tag>::make(environment(), subject.message())};
-			auto error = [ & ]() -> napi_value {
-				switch (subject.name()) {
-					default:
-						return napi::invoke(napi_create_error, napi_env{*this}, napi_value{}, message);
-					case js::error::name_type::range_error:
-						return napi::invoke(napi_create_range_error, napi_env{*this}, napi_value{}, message);
-					case js::error::name_type::syntax_error:
-						return napi::invoke(node_api_create_syntax_error, napi_env{*this}, napi_value{}, message);
-					case js::error::name_type::type_error:
-						return napi::invoke(napi_create_type_error, napi_env{*this}, napi_value{}, message);
-				}
-			}();
-			return js::referenceable_value{napi::value<error_tag>::from(error)};
-		}
+// data blocks (array buffer, shared array buffer)
+auto accept_basic_napi_value::operator()(array_buffer_tag /*tag*/, visit_holder /*visit*/, const js::array_buffer& subject) const
+	-> js::referenceable_value<value_of<array_buffer_tag>> {
+	// You could avoid the extra copy for `js::data_block&&` here w/ v8 API. Napi requires the copy
+	// though.
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	void* bytes;
+	auto* result = napi::invoke(napi_create_arraybuffer, napi_env{*this}, subject.size(), &bytes);
+	// nb: `std::memcpy` *technically* results in undefined behavior on block size 0
+	// (and also) it maybe causes an infinite loop with musl
+	// https://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0
+	std::ranges::copy(std::span<const std::byte>{subject}, static_cast<std::byte*>(bytes));
+	auto value = value_of<array_buffer_tag>::from(result);
+	return js::referenceable_value{value};
+}
 
-		// vectors
-		auto operator()(this const auto& self, vector_tag /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<napi::value<vector_tag>, decltype(self), decltype(visit), decltype(subject)> {
-			return {
-				napi::value<vector_tag>::from(napi::invoke(napi_create_array_with_length, napi_env{self}, subject.size())),
-				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](napi::value<vector_tag> array, auto& self, auto& visit, auto /*&&*/ subject) -> void {
-					int ii = 0;
-					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
-					for (auto&& subject : util::forward_range(std::forward<decltype(range)>(range))) {
-						auto* element = napi_value{visit(std::forward<decltype(subject)>(subject), self)};
-						napi::invoke0(napi_set_element, napi_env{self}, napi_value{array}, ii++, element);
-					}
+auto accept_basic_napi_value::operator()(shared_array_buffer_tag /*tag*/, visit_holder /*visit*/, js::shared_array_buffer&& subject) const
+	-> js::referenceable_value<value_of<shared_array_buffer_tag>> {
+	auto backing_store = [ & ]() -> auto {
+		auto byte_length = subject.size();
+		// v8 does not call the deleter `byte_length` is zero. So the heap-allocated shared_ptr trick
+		// does not work in that case.
+		if (byte_length == 0) {
+			return v8::SharedArrayBuffer::NewBackingStore(nullptr, 0, nullptr, nullptr);
+		} else {
+			auto holder = std::make_unique<js::shared_array_buffer::shared_pointer_type>(std::move(subject).acquire_ownership());
+			auto backing_store = v8::SharedArrayBuffer::NewBackingStore(
+				holder->get(),
+				byte_length,
+				[](void* /*data*/, std::size_t /*length*/, void* param) -> void {
+					delete static_cast<js::shared_array_buffer::shared_pointer_type*>(param);
 				},
-			};
-		}
-
-		template <std::size_t Size>
-		auto operator()(this const auto& self, tuple_tag<Size> /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<napi::value<vector_tag>, decltype(self), decltype(visit), decltype(subject)> {
-			return {
-				napi::value<vector_tag>::from(napi::invoke(napi_create_array_with_length, napi_env{self}, Size)),
-				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](napi::value<vector_tag> array, auto& self, auto& visit, auto /*&&*/ tuple) -> void {
-					const auto [... indices ] = util::sequence<Size>;
-					(..., [ & ]() -> void {
-						// nb: This is forwarded to *each* visitor. The visitor should be aware and only lvalue
-						// reference members one at a time.
-						auto* element = napi_value{visit(indices, std::forward<decltype(tuple)>(tuple), self)};
-						napi::invoke0(napi_set_element, napi_env{self}, napi_value{array}, indices, element);
-					}());
-				}
-			};
-		}
-
-		// arrays & dictionaries
-		auto operator()(this const auto& self, list_tag /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<napi::value<list_tag>, decltype(self), decltype(visit), decltype(subject)> {
-			return {
-				napi::value<list_tag>::from(napi::invoke(napi_create_array, napi_env{self})),
-				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](napi::value<list_tag> array, auto& self, auto& visit, auto /*&&*/ subject) -> void {
-					self.accept_entry_pair_vector(visit, array, std::forward<decltype(subject)>(subject));
-				}
-			};
-		}
-
-		auto operator()(this const auto& self, dictionary_tag /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<napi::value<dictionary_tag>, decltype(self), decltype(visit), decltype(subject)> {
-			return {
-				napi::value<dictionary_tag>::from(napi::invoke(napi_create_object, napi_env{self})),
-				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](napi::value<dictionary_tag> object, auto& self, auto& visit, auto /*&&*/ subject) -> void {
-					self.accept_entry_pair_vector(visit, object, std::forward<decltype(subject)>(subject));
-				}
-			};
-		}
-
-		auto accept_entry_pair_vector(this const auto& self, auto& visit, value<object_tag> target, auto&& subject) -> void {
-			std::vector<napi_property_descriptor> properties;
-			auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
-			properties.reserve(std::size(range));
-			for (auto&& [ key, value ] : util::forward_range(std::forward<decltype(range)>(range))) {
-				properties.emplace_back(napi_property_descriptor{
-					.utf8name{},
-					.name = napi_value{visit.first(std::forward<decltype(key)>(key), self)},
-
-					.method{},
-					.getter{},
-					.setter{},
-					.value = napi_value{visit.second(std::forward<decltype(value)>(value), self)},
-
-					// NOLINTNEXTLINE(hicpp-signed-bitwise)
-					.attributes = static_cast<napi_property_attributes>(napi_writable | napi_enumerable | napi_configurable),
-					.data{},
-				});
-			}
-			napi::invoke0(napi_define_properties, napi_env{self}, napi_value{target}, properties.size(), properties.data());
-		}
-
-		// structs
-		template <std::size_t Size>
-		auto operator()(this const auto& self, struct_tag<Size> /*tag*/, auto& visit, auto&& subject)
-			-> js::deferred_receiver<napi::value<dictionary_tag>, decltype(self), decltype(visit), decltype(subject)> {
-			return {
-				napi::value<dictionary_tag>::from(napi::invoke(napi_create_object, napi_env{self})),
-				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
-				[](napi::value<dictionary_tag> object, auto& self, auto& visit, auto /*&&*/ subject) -> void {
-					self.template accept_entry_pair_struct<Size>(visit, object, std::forward<decltype(subject)>(subject));
-				}
-			};
-		}
-
-		template <std::size_t Size>
-		auto accept_entry_pair_struct(this const auto& self, auto& visit, value<object_tag> target, auto&& subject) -> void {
-			// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-			std::array<napi_property_descriptor, Size> properties;
-			const auto [... indices ] = util::sequence<Size>;
-			(..., [ & ]() -> void {
-				// nb: This is forwarded to *each* visitor. The visitor should be aware and only lvalue
-				// reference members one at a time.
-				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);
-				// NOLINTNEXTLINE(modernize-type-traits)
-				properties.at(indices) = {
-					.utf8name{},
-					.name = entry.first,
-
-					.method{},
-					.getter{},
-					.setter{},
-					.value = entry.second,
-
-					// NOLINTNEXTLINE(hicpp-signed-bitwise)
-					.attributes = static_cast<napi_property_attributes>(napi_writable | napi_enumerable | napi_configurable),
-					.data{},
-				};
-			}());
-			napi::invoke0(napi_define_properties, napi_env{self}, napi_value{target}, properties.size(), properties.data());
-		}
-
-		// no required types
-		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
-};
-
-// Plain napi_value acceptor
-template <>
-struct accept_property_subject<napi_value> : std::type_identity<napi_value> {};
-
-template <class Meta>
-struct accept<Meta, napi_value> : accept_napi_value_with<Meta> {
-		using accept_type = accept_napi_value_with<Meta>;
-		using accept_type::accept_type;
-};
-
-// Tagged `napi::value<T>` acceptor
-template <>
-struct accept_property_subject<napi::value<value_tag>> : std::type_identity<napi_value> {};
-
-template <class Meta>
-struct accept<Meta, napi::value<value_tag>> : accept_napi_value_with<Meta> {
-		using accept_type = accept_napi_value_with<Meta>;
-		using accept_type::accept_type;
-};
-
-// Forwarded `napi::value<T>` acceptor
-template <class Tag>
-struct accept<void, js::forward<napi::value<Tag>, Tag>> {
-		auto operator()(Tag /*tag*/, visit_holder /*visit*/, napi::value<Tag> value) const -> js::forward<napi::value<Tag>, Tag> {
-			return js::forward{napi::value<Tag>{value}, Tag{}};
-		}
-
-		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
-};
-
-// Object key lookup via napi
-template <class Meta, auto Key, class Type>
-struct accept_property_value<Meta, Key, Type, napi_value> {
-	public:
-		explicit constexpr accept_property_value(auto* transfer) :
-				first{transfer},
-				second{transfer} {}
-
-		auto operator()(dictionary_tag /*tag*/, auto& visit, const auto& object) const -> Type {
-			if (auto local = first(std::type_identity<void>{}, visit.first); object.has(local)) {
-				return visit.second(object.get(local), second);
-			} else {
-				return second(undefined_in_tag{}, visit.second, std::monostate{});
-			}
-		}
-
-	private:
-		mutable visit_key_literal<Key, napi_value> first;
-		accept_value<Meta, Type> second;
-};
-
-// `value<object_tag>{}.assign(...)` implementation
-struct object_assign_delegate {
-	public:
-		explicit object_assign_delegate(value<object_tag> object) : object_{object} {}
-		auto operator*() const { return object_; }
-
-	private:
-		value<object_tag> object_;
-};
-
-template <class Meta>
-struct accept<Meta, object_assign_delegate> {
-	public:
-		accept(auto* transfer, auto& env, object_assign_delegate object) :
-				accept_{transfer, env},
-				object_{object} {}
-
-		template <std::size_t Size>
-		auto operator()(this const auto& self, tuple_tag<Size> /*tag*/, auto& visit, auto&& subject) -> object_assign_delegate {
-			self.accept_.template accept_entry_pair_struct<Size>(visit, *self.object_, std::forward<decltype(subject)>(subject));
-			return self.object_;
-		}
-
-		consteval static auto types(auto recursive) { return accept<Meta, napi_value>::types(recursive); }
-
-	private:
-		accept_value<Meta, napi_value> accept_;
-		object_assign_delegate object_;
-};
+				holder.get()
+			);
+			std::ignore = holder.release();
+			return backing_store;
+		}
+	}();
+	auto shared_array_buffer = v8::SharedArrayBuffer::New(v8::Isolate::GetCurrent(), std::move(backing_store));
+	auto value = value_of<shared_array_buffer_tag>::from(std::bit_cast<napi_value>(shared_array_buffer));
+	return js::referenceable_value{value};
+}
 
-auto value_for_object::assign(this value<object_tag> self, auto_environment auto& env, auto source) -> void {
-	js::transfer_in<object_assign_delegate>(std::move(source), env, object_assign_delegate{self});
+auto accept_basic_napi_value::operator()(shared_array_buffer_tag tag, visit_holder visit, const js::shared_array_buffer& subject) const
+	-> js::referenceable_value<value_of<shared_array_buffer_tag>> {
+	return (*this)(tag, visit, js::shared_array_buffer{subject});
 }
 
-} // namespace js
+} // namespace js::napi