@auto_js/napi 0.0.5 → 0.0.7

package/support/host.cc

@@ -0,0 +1,230 @@
+module napi_js;
+import std;
+import v8;
+
+namespace js::napi {
+util::lockable_with<bool, {.shared = true}> host_environment_initialized;
+
+// Addressof operations
+constexpr auto direct_handle_address =
+	[](napi_value value) noexcept -> void* { return value; };
+
+constexpr auto indirect_handle_address =
+	[](napi_value value) noexcept -> void* { return *reinterpret_cast<void**>(value); };
+
+// Value inspection
+constexpr auto v8_maybe_fast_is_number_int32 =
+	[](value_of<number_tag> value) -> std::optional<bool> { return std::bit_cast<v8::Local<v8::Number>>(value)->IsInt32(); };
+
+constexpr auto v8_maybe_fast_is_string_one_byte =
+	[](value_of<string_tag> value) -> std::optional<bool> { return std::bit_cast<v8::Local<v8::String>>(value)->IsOneByte(); };
+
+constexpr auto napi_maybe_is_shared_array_buffer =
+	[](napi_env env, value_of<object_tag> value) -> std::optional<bool> { return napi::invoke(node_api_is_sharedarraybuffer, env, value); };
+
+constexpr auto unknown_maybe_fast_is_number_int32 =
+	[](value_of<number_tag> /*value*/) -> std::optional<bool> { return std::nullopt; };
+
+constexpr auto unknown_maybe_fast_is_string_one_byte =
+	[](value_of<string_tag> /*value*/) -> std::optional<bool> { return std::nullopt; };
+
+constexpr auto unknown_maybe_is_shared_array_buffer =
+	[](napi_env /*env*/, value_of<object_tag> /*value*/) -> std::optional<bool> { return std::nullopt; };
+
+auto fast_is_array(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsArray();
+}
+
+auto fast_is_bigint(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsBigInt();
+}
+
+auto fast_is_boolean(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsBoolean();
+}
+
+auto fast_is_function(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsFunction();
+}
+
+auto fast_is_null(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsNull();
+}
+
+auto fast_is_number(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsNumber();
+}
+
+auto fast_is_object(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsObject();
+}
+
+auto fast_is_string(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsString();
+}
+
+auto fast_is_undefined(napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsUndefined();
+}
+
+// 'SharedArrayBuffer' constructors
+constexpr auto v8_make_shared_array_buffer =
+	[](js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> value_of<shared_array_buffer_tag> {
+	auto backing_store = [ & ]() -> auto {
+		// 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(data));
+			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);
+				},
+				holder.get()
+			);
+			std::ignore = holder.release();
+			return backing_store;
+		}
+	}();
+	auto shared_array_buffer = v8::SharedArrayBuffer::New(v8::Isolate::GetCurrent(), std::move(backing_store));
+	return value_of<shared_array_buffer_tag>::from(std::bit_cast<napi_value>(shared_array_buffer));
+};
+
+constexpr auto unknown_make_shared_array_buffer =
+	// NOLINTNEXTLINE(performance-unnecessary-value-param)
+	[](js::shared_array_buffer::shared_pointer_type /*data*/, std::size_t /*byte_length*/) -> value_of<shared_array_buffer_tag> {
+	throw js::type_error{u"SharedArrayBuffer is not supported in this environment"};
+};
+
+// 'ArrayBufferView' constructors
+constexpr auto v8_make_sab_data_view =
+	// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+	[](value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> {
+	auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
+	auto view_local = v8::DataView::New(buffer_local, byte_offset, length);
+	return value_of<data_view_tag>::from(std::bit_cast<napi_value>(view_local));
+};
+
+constexpr auto unknown_make_sab_data_view =
+	// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+	[](value_of<shared_array_buffer_tag> /*buffer*/, std::size_t /*byte_offset*/, std::size_t /*length*/) -> value_of<data_view_tag> {
+	throw js::type_error{u"SharedArrayBuffer is not supported in this environment"};
+};
+
+template <class Type>
+constexpr auto v8_make_sab_typed_array_of =
+	// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+	[](value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+	using constructor_type = type_t<util::overloaded{
+		[](std::type_identity<double>) -> std::type_identity<v8::Float64Array> { return {}; },
+		[](std::type_identity<float>) -> std::type_identity<v8::Float32Array> { return {}; },
+		[](std::type_identity<js::float16_t>) -> std::type_identity<v8::Float16Array> { return {}; },
+		[](std::type_identity<js::uint8_clamped_t>) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
+		[](std::type_identity<std::int16_t>) -> std::type_identity<v8::Int16Array> { return {}; },
+		[](std::type_identity<std::int32_t>) -> std::type_identity<v8::Int32Array> { return {}; },
+		[](std::type_identity<std::int64_t>) -> std::type_identity<v8::BigInt64Array> { return {}; },
+		[](std::type_identity<std::int8_t>) -> std::type_identity<v8::Int8Array> { return {}; },
+		[](std::type_identity<std::uint16_t>) -> std::type_identity<v8::Uint16Array> { return {}; },
+		[](std::type_identity<std::uint32_t>) -> std::type_identity<v8::Uint32Array> { return {}; },
+		[](std::type_identity<std::uint64_t>) -> std::type_identity<v8::BigUint64Array> { return {}; },
+		[](std::type_identity<std::uint8_t>) -> std::type_identity<v8::Uint8Array> { return {}; },
+	}(type<Type>)>;
+	auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
+	auto view_local = constructor_type::New(buffer_local, byte_offset, length);
+	return value_of<typed_array_tag_of<Type>>::from(std::bit_cast<napi_value>(view_local));
+};
+
+template <class Type>
+constexpr auto unknown_make_sab_typed_array_of =
+	// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+	[](value_of<shared_array_buffer_tag> /*buffer*/, std::size_t /*byte_offset*/, std::size_t /*length*/) -> value_of<typed_array_tag_of<Type>> {
+	throw js::type_error{u"SharedArrayBuffer is not supported in this environment"};
+};
+
+auto initialize_host_environment(napi_env env) -> void {
+	if (!*host_environment_initialized.read()) {
+		if (auto lock = host_environment_initialized.write(); !*lock) {
+			// Detect indirect handles (nodejs, v8 [configurable]) or direct handles (bun, jsc)
+			// See: `v8_enable_direct_handle`
+			auto uses_direct_handles = [ & ] -> bool {
+				auto* array = napi::invoke(napi_create_array_with_length, env, 1);
+				napi::invoke0(napi_set_element, env, array, 0, array);
+				auto* result = napi::invoke(napi_get_element, env, array, 0);
+				if (direct_handle_address(array) == direct_handle_address(result)) {
+					return true;
+				} else if (indirect_handle_address(array) == indirect_handle_address(result)) {
+					return false;
+				} else {
+					throw std::runtime_error{"Exotic napi handle behavior detected"};
+				}
+			}();
+			*lock = true;
+			if (uses_direct_handles) {
+				handle_addressof = direct_handle_address;
+			} else {
+				handle_addressof = indirect_handle_address;
+			}
+
+			// Detect bun via `process.isBun`
+			auto is_bun = [ & ] -> bool {
+				auto* global = napi::invoke(napi_get_global, env);
+				constexpr auto process_cw = util::make_consteval_string_view(util::cw<"process">);
+				auto* process_str = napi::invoke(node_api_create_property_key_latin1, env, process_cw.data(), process_cw.length());
+				auto* process = napi::invoke(napi_get_property, env, global, process_str);
+				if (napi::invoke(napi_typeof, env, process) == napi_object) {
+					constexpr auto is_bun_cw = util::make_consteval_string_view(util::cw<"isBun">);
+					auto* is_bun_str = napi::invoke(node_api_create_property_key_latin1, env, is_bun_cw.data(), is_bun_cw.length());
+					auto* is_bun = napi::invoke(napi_get_property, env, process, is_bun_str);
+					auto* is_bun_bool = napi::invoke(napi_coerce_to_bool, env, is_bun);
+					return napi::invoke(napi_get_value_bool, env, is_bun_bool);
+				} else {
+					return false;
+				}
+			}();
+			if (is_bun) {
+				has_fast_is_functions = false;
+				make_sab_data_view = unknown_make_sab_data_view;
+				make_sab_typed_array_of<double> = unknown_make_sab_typed_array_of<double>;
+				make_sab_typed_array_of<float> = unknown_make_sab_typed_array_of<float>;
+				make_sab_typed_array_of<js::float16_t> = unknown_make_sab_typed_array_of<js::float16_t>;
+				make_sab_typed_array_of<js::uint8_clamped_t> = unknown_make_sab_typed_array_of<js::uint8_clamped_t>;
+				make_sab_typed_array_of<std::int16_t> = unknown_make_sab_typed_array_of<std::int16_t>;
+				make_sab_typed_array_of<std::int32_t> = unknown_make_sab_typed_array_of<std::int32_t>;
+				make_sab_typed_array_of<std::int64_t> = unknown_make_sab_typed_array_of<std::int64_t>;
+				make_sab_typed_array_of<std::int8_t> = unknown_make_sab_typed_array_of<std::int8_t>;
+				make_sab_typed_array_of<std::uint16_t> = unknown_make_sab_typed_array_of<std::uint16_t>;
+				make_sab_typed_array_of<std::uint32_t> = unknown_make_sab_typed_array_of<std::uint32_t>;
+				make_sab_typed_array_of<std::uint64_t> = unknown_make_sab_typed_array_of<std::uint64_t>;
+				make_sab_typed_array_of<std::uint8_t> = unknown_make_sab_typed_array_of<std::uint8_t>;
+				make_shared_array_buffer = unknown_make_shared_array_buffer;
+				maybe_fast_is_number_int32 = unknown_maybe_fast_is_number_int32;
+				maybe_fast_is_string_one_byte = unknown_maybe_fast_is_string_one_byte;
+				maybe_is_shared_array_buffer = unknown_maybe_is_shared_array_buffer;
+			} else {
+				has_fast_is_functions = true;
+				make_sab_data_view = v8_make_sab_data_view;
+				make_sab_typed_array_of<double> = v8_make_sab_typed_array_of<double>;
+				make_sab_typed_array_of<float> = v8_make_sab_typed_array_of<float>;
+				make_sab_typed_array_of<js::float16_t> = v8_make_sab_typed_array_of<js::float16_t>;
+				make_sab_typed_array_of<js::uint8_clamped_t> = v8_make_sab_typed_array_of<js::uint8_clamped_t>;
+				make_sab_typed_array_of<std::int16_t> = v8_make_sab_typed_array_of<std::int16_t>;
+				make_sab_typed_array_of<std::int32_t> = v8_make_sab_typed_array_of<std::int32_t>;
+				make_sab_typed_array_of<std::int64_t> = v8_make_sab_typed_array_of<std::int64_t>;
+				make_sab_typed_array_of<std::int8_t> = v8_make_sab_typed_array_of<std::int8_t>;
+				make_sab_typed_array_of<std::uint16_t> = v8_make_sab_typed_array_of<std::uint16_t>;
+				make_sab_typed_array_of<std::uint32_t> = v8_make_sab_typed_array_of<std::uint32_t>;
+				make_sab_typed_array_of<std::uint64_t> = v8_make_sab_typed_array_of<std::uint64_t>;
+				make_sab_typed_array_of<std::uint8_t> = v8_make_sab_typed_array_of<std::uint8_t>;
+				make_shared_array_buffer = v8_make_shared_array_buffer;
+				maybe_fast_is_number_int32 = v8_maybe_fast_is_number_int32;
+				maybe_fast_is_string_one_byte = v8_maybe_fast_is_string_one_byte;
+				maybe_is_shared_array_buffer = napi_maybe_is_shared_array_buffer;
+			}
+		}
+	}
+}
+
+} // namespace js::napi

package/support/host.h.cc

@@ -0,0 +1,56 @@
+export module napi_js:support.host;
+import :value_handle;
+import std;
+
+namespace js::napi {
+
+// Addressof operation
+auto (*handle_addressof)(napi_value handle) noexcept -> void* = nullptr;
+
+// Value inspection
+auto (*maybe_fast_is_number_int32)(value_of<number_tag> value) -> std::optional<bool> = nullptr;
+auto (*maybe_fast_is_string_one_byte)(value_of<string_tag> value) -> std::optional<bool> = nullptr;
+auto (*maybe_is_shared_array_buffer)(napi_env env, value_of<object_tag> value) -> std::optional<bool> = nullptr;
+
+// nb: These will crash on Bun
+auto has_fast_is_functions = false;
+auto fast_is_array(napi_value value) -> bool;
+auto fast_is_bigint(napi_value value) -> bool;
+auto fast_is_boolean(napi_value value) -> bool;
+auto fast_is_function(napi_value value) -> bool;
+auto fast_is_null(napi_value value) -> bool;
+auto fast_is_number(napi_value value) -> bool;
+auto fast_is_object(napi_value value) -> bool;
+auto fast_is_string(napi_value value) -> bool;
+auto fast_is_undefined(napi_value value) -> bool;
+
+// 'SharedArrayBuffer' constructor
+auto (*make_shared_array_buffer)(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> value_of<shared_array_buffer_tag> = nullptr;
+
+// 'ArrayBufferView' constructors
+auto (*make_sab_data_view)(value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> = nullptr;
+
+template <class Type>
+using make_sab_typed_array_constructor =
+	auto(value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>>;
+
+template <class Type>
+make_sab_typed_array_constructor<Type>* make_sab_typed_array_of;
+
+template make_sab_typed_array_constructor<double>* make_sab_typed_array_of<double>;
+template make_sab_typed_array_constructor<float>* make_sab_typed_array_of<float>;
+template make_sab_typed_array_constructor<js::float16_t>* make_sab_typed_array_of<js::float16_t>;
+template make_sab_typed_array_constructor<js::uint8_clamped_t>* make_sab_typed_array_of<js::uint8_clamped_t>;
+template make_sab_typed_array_constructor<std::int16_t>* make_sab_typed_array_of<std::int16_t>;
+template make_sab_typed_array_constructor<std::int32_t>* make_sab_typed_array_of<std::int32_t>;
+template make_sab_typed_array_constructor<std::int64_t>* make_sab_typed_array_of<std::int64_t>;
+template make_sab_typed_array_constructor<std::int8_t>* make_sab_typed_array_of<std::int8_t>;
+template make_sab_typed_array_constructor<std::uint16_t>* make_sab_typed_array_of<std::uint16_t>;
+template make_sab_typed_array_constructor<std::uint32_t>* make_sab_typed_array_of<std::uint32_t>;
+template make_sab_typed_array_constructor<std::uint64_t>* make_sab_typed_array_of<std::uint64_t>;
+template make_sab_typed_array_constructor<std::uint8_t>* make_sab_typed_array_of<std::uint8_t>;
+
+// Once per process, this detects the host environment (nodejs vs bun)
+auto initialize_host_environment(napi_env env) -> void;
+
+} // namespace js::napi

package/support/host_shim.cc

@@ -0,0 +1,42 @@
+import std;
+
+// NOLINTBEGIN(bugprone-macro-parentheses)
+#if _WIN64
+// I couldn't get this to work.
+// https://stackoverflow.com/questions/2290587/gcc-style-weak-linking-in-visual-studio
+#define SHIM(NAME)
+#else
+#define SHIM(NAME) \
+	__attribute__((weak)) __attribute__((visibility("default"))) auto NAME = nullptr;
+#endif
+// NOLINTEND(bugprone-macro-parentheses)
+
+extern "C" {
+const void* shim_nullptr = nullptr;
+// NOLINTBEGIN(bugprone-reserved-identifier)
+SHIM(_ZN2v810Int16Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v810Int32Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v810Uint8Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v811Uint16Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v811Uint32Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v812BackingStoreD1Ev)
+SHIM(_ZN2v812Float16Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v812Float32Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v812Float64Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v813BigInt64Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v814BigUint64Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v817SharedArrayBuffer15GetBackingStoreEv)
+SHIM(_ZN2v817SharedArrayBuffer15NewBackingStoreEPvmPFvS1_mS1_ES1_)
+SHIM(_ZN2v817SharedArrayBuffer3NewEPNS_7IsolateENSt3__110shared_ptrINS_12BackingStoreEEE)
+SHIM(_ZN2v817Uint8ClampedArray3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v87Isolate10GetCurrentEv)
+SHIM(_ZN2v88DataView3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZN2v89Int8Array3NewENS_5LocalINS_17SharedArrayBufferEEEmm)
+SHIM(_ZNK2v812BackingStore4DataEv)
+SHIM(_ZNK2v817SharedArrayBuffer10ByteLengthEv)
+SHIM(_ZNK2v85Value7IsInt32Ev)
+SHIM(_ZNK2v85Value8IsNumberEv)
+SHIM(_ZNK2v86String9IsOneByteEv)
+SHIM(node_api_is_sharedarraybuffer)
+// NOLINTEND(bugprone-reserved-identifier)
+}

package/support/promise.cc

@@ -13,7 +13,7 @@ class resolver {
 				deferred_{deferred},
 				scheduler_{env.scheduler()},
 				dispatch_{dispatch} {
-			scheduler_.increment_ref();
+			scheduler_.increment_ref(napi_env{env});
 		}
 		resolver(const resolver&) = delete;
 		resolver(resolver&&) = default;
@@ -67,10 +67,9 @@ class resolver {
 		auto schedule(auto operation, auto&&... args) -> void {
 			auto scheduler = std::move(scheduler_);
 			scheduler(
-				[](napi_env env, napi_deferred deferred, auto operation, auto&&... args) {
+				[](napi_env env, napi_value /*nothing*/, napi_deferred deferred, auto operation, auto&&... args) {
 					auto& environment = napi::environment::unsafe_get_environment_as<Environment>(env);
-					environment.scheduler().decrement_ref();
-					const auto scope = js::napi::handle_scope{env};
+					environment.scheduler().decrement_ref(env);
 					try {
 						auto expected = operation(environment, std::forward<decltype(args)>(args)...);
 						if (expected) {
@@ -88,7 +87,6 @@ class resolver {
 						napi::invoke0(napi_reject_deferred, env, deferred, exception);
 					}
 				},
-				env_,
 				deferred_,
 				std::move(operation),
 				std::forward<decltype(args)>(args)...
@@ -97,7 +95,7 @@ class resolver {
 
 		napi_env env_;
 		napi_deferred deferred_;
-		uv_scheduler scheduler_;
+		napi_scheduler scheduler_;
 		Dispatch dispatch_;
 };
 

package/support/utility.cc

@@ -1,102 +1,27 @@
-module;
-#include "auto_js/no_unique_address.h"
 export module napi_js:utility;
+import :support.host;
 import nodejs;
 import std;
-import util;
 
 namespace js::napi {
 
-// See: `v8_enable_direct_handle`.
-
-// Null handle for both direct and indirect handles
-// Note: 1 -> 0x1'0000'0000
-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));
-
-// Unwrap the v8 address of the napi handle. This points into the v8 heap.
-// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
-struct virtual_handle_address {
-	protected:
-		~virtual_handle_address() = default;
-
-	public:
-		virtual auto operator()(napi_value value) const noexcept -> void* = 0;
-};
-
-struct direct_handle_address final : virtual_handle_address {
-		auto operator()(napi_value value) const noexcept -> void* final {
-			return value;
-		}
-};
-
-struct indirect_handle_address final : virtual_handle_address {
-		auto operator()(napi_value value) const noexcept -> void* final {
-			return *reinterpret_cast<void**>(value);
-		}
-};
-
-// 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(bool uses_direct_handles) :
-				equal_{
-					uses_direct_handles
-						? virtual_equal_type{direct_address_equal{}}
-						: virtual_equal_type{indirect_address_equal{}}
-				} {}
-
+// Equality check for underlying handle. False negatives on primitives.
+struct addressof_equal {
 		auto operator()(napi_value left, napi_value right) const noexcept -> bool {
-			// NOLINTNEXTLINE(bugprone-exception-escape)
-			return (*equal_)(left, right);
+			return handle_addressof(left) == handle_addressof(right);
 		}
-
-	private:
-		virtual_equal_type equal_;
 };
 
 // Address hash for napi value handles.
-template <class Address>
-struct address_hash_of final {
-	public:
+struct addressof_hash : std::hash<void*> {
+		using std::hash<void*>::operator();
 		auto operator()(napi_value value) const noexcept -> std::size_t {
-			return hash_(address_(value));
+			return (*this)(handle_addressof(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>;
+// Unordered map for napi values
+template <class Type>
+using unordered_value_map = std::unordered_map<napi_value, Type, addressof_hash, addressof_equal>;
 
 } // namespace js::napi

package/transfer/accept.cc

@@ -121,28 +121,7 @@ auto accept_basic_napi_value::operator()(array_buffer_tag /*tag*/, visit_holder
 
 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.byte_length();
-		// 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);
-				},
-				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));
+	auto value = make_shared_array_buffer(std::move(subject).acquire_ownership(), subject.byte_length());
 	return js::referenceable_value{value};
 }
 

package/transfer/accept.h.cc

@@ -1,5 +1,5 @@
 export module napi_js:accept;
-import :container;
+import :utility;
 import :value;
 import std;
 import util;