@auto_js/napi 0.0.7 → 0.0.9

package/support/host.cc

@@ -6,31 +6,45 @@ 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 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); };
 
-constexpr auto indirect_handle_address =
-	[](napi_value value) noexcept -> void* { return *reinterpret_cast<void**>(value); };
+// Fast functions which are supported on all platforms
+// nb: Bun exports these v8 functions, but they crash with the `std::bit_cast<v8::Local<T>>` trick.
+auto v8_is_false(napi_env /*env*/, napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsFalse();
+}
 
-// 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(); };
+auto v8_is_null(napi_env /*env*/, napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsNull();
+}
 
-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(); };
+auto v8_is_true(napi_env /*env*/, napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsTrue();
+}
 
-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); };
+auto v8_is_undefined(napi_env /*env*/, napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsUndefined();
+}
 
-constexpr auto unknown_maybe_fast_is_number_int32 =
-	[](value_of<number_tag> /*value*/) -> std::optional<bool> { return std::nullopt; };
+auto napi_fast_is_false(napi_env env, napi_value value) -> bool {
+	return value == napi::invoke(napi_get_boolean, env, false);
+}
 
-constexpr auto unknown_maybe_fast_is_string_one_byte =
-	[](value_of<string_tag> /*value*/) -> std::optional<bool> { return std::nullopt; };
+auto napi_fast_is_null(napi_env env, napi_value value) -> bool {
+	return value == napi::invoke(napi_get_null, env);
+}
 
-constexpr auto unknown_maybe_is_shared_array_buffer =
-	[](napi_env /*env*/, value_of<object_tag> /*value*/) -> std::optional<bool> { return std::nullopt; };
+auto napi_fast_is_true(napi_env env, napi_value value) -> bool {
+	return value == napi::invoke(napi_get_boolean, env, true);
+}
+
+auto napi_fast_is_undefined(napi_env env, napi_value value) -> bool {
+	return value == napi::invoke(napi_get_undefined, env);
+}
 
+// Extended fast functions
+// nb: Bun exports these v8 functions, but they crash with the `std::bit_cast<v8::Local<T>>` trick.
 auto fast_is_array(napi_value value) -> bool {
 	return std::bit_cast<v8::Local<v8::Value>>(value)->IsArray();
 }
@@ -39,18 +53,10 @@ 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();
 }
@@ -63,13 +69,60 @@ 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();
+// Bug fixes
+auto napi_is_object_array_buffer(napi_env env, local_of<object_tag> value) -> bool {
+	return napi::invoke(napi_is_arraybuffer, env, value);
+}
+
+auto napi_is_data_block_array_buffer(napi_env env, local_of<data_block_tag> value) -> bool {
+	return napi_is_object_array_buffer(env, value);
+}
+
+auto bun_is_data_block_array_buffer(napi_env env, local_of<data_block_tag> value) -> bool {
+	// https://github.com/oven-sh/bun/issues/32624
+	auto* string = napi::invoke(napi_coerce_to_string, env, value);
+	auto length = napi::invoke(napi_get_value_string_latin1, env, string, nullptr, 0);
+	// '[object ArrayBuffer]'
+	return length == 20;
+}
+
+auto bun_is_object_array_buffer(napi_env env, local_of<object_tag> value) -> bool {
+	if (napi::invoke(napi_is_arraybuffer, env, value)) {
+		return bun_is_data_block_array_buffer(env, local_of<data_block_tag>::from(value));
+	} else {
+		return false;
+	}
 }
 
-// '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> {
+// Optional value inspectors.
+auto v8_is_number_int32(local_of<number_tag> value) -> std::optional<bool> {
+	return std::bit_cast<v8::Local<v8::Number>>(value)->IsInt32();
+};
+
+auto v8_is_string_one_byte(local_of<string_tag> value) -> std::optional<bool> {
+	return std::bit_cast<v8::Local<v8::String>>(value)->IsOneByte();
+}
+
+auto node_api_maybe_is_shared_array_buffer(napi_env env, local_of<object_tag> value) -> std::optional<bool> {
+	if constexpr (node_api_has_sharedarraybuffer) {
+		return napi::invoke(node_api_is_sharedarraybuffer, env, value);
+	} else {
+		return std::nullopt;
+	}
+}
+
+auto bun_maybe_is_shared_array_buffer(napi_env env, local_of<object_tag> value) -> std::optional<bool> {
+	if (napi::invoke(napi_is_arraybuffer, env, value)) {
+		return !bun_is_data_block_array_buffer(env, local_of<data_block_tag>::from(value));
+	} else {
+		return std::nullopt;
+	}
+}
+
+constexpr auto unknown_maybe_is = [](auto...) -> std::optional<bool> { return std::nullopt; };
+
+// 'SharedArrayBuffer' functions
+auto v8_make_shared_array_buffer(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> local_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.
@@ -90,34 +143,31 @@ constexpr auto v8_make_shared_array_buffer =
 		}
 	}();
 	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));
+	return local_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"};
+auto v8_shared_array_buffer_get_byte_length(local_of<shared_array_buffer_tag> buffer) -> std::size_t {
+	return std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer})->ByteLength();
+};
+
+auto v8_shared_array_buffer_get_backing_store(local_of<shared_array_buffer_tag> buffer) -> std::shared_ptr<std::byte[]> {
+	auto backing_store = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(buffer)->GetBackingStore();
+	auto* data = reinterpret_cast<std::byte*>(backing_store->Data());
+	// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+	return std::shared_ptr<std::byte[]>{std::move(backing_store), data};
 };
 
 // '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> {
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+auto v8_make_sab_data_view(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_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"};
+	return local_of<data_view_tag>::from(std::bit_cast<napi_value>(view_local));
 };
 
 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>> {
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+auto v8_make_sab_typed_array_of(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_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 {}; },
@@ -134,16 +184,30 @@ constexpr auto v8_make_sab_typed_array_of =
 	}(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));
+	return local_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>> {
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+constexpr auto unknown_sab_throw = [](auto...) -> Type {
 	throw js::type_error{u"SharedArrayBuffer is not supported in this environment"};
 };
 
+// Dynamic libraries
+constexpr auto node_uv_dlerror =
+	[](const uv_lib_t* lib) -> const char* { return uv_dlerror(lib); };
+constexpr auto node_uv_dlopen =
+	[](const char* filename, uv_lib_t* lib) -> int { return uv_dlopen(filename, lib); };
+constexpr auto node_uv_dlclose =
+	[](uv_lib_t* lib) -> void { uv_dlclose(lib); };
+
+constexpr auto unknown_uv_dlerror =
+	[](const uv_lib_t* /*lib*/) -> const char* { return "Dynamic libraries are not supported in this environment"; };
+constexpr auto unknown_uv_dlopen =
+	[](const char* /*filename*/, uv_lib_t* /*lib*/) -> int { return -1; };
+constexpr auto unknown_uv_dlclose =
+	[](uv_lib_t* /*lib*/) -> void { std::unreachable(); };
+
 auto initialize_host_environment(napi_env env) -> void {
 	if (!*host_environment_initialized.read()) {
 		if (auto lock = host_environment_initialized.write(); !*lock) {
@@ -168,44 +232,53 @@ auto initialize_host_environment(napi_env env) -> void {
 				handle_addressof = indirect_handle_address;
 			}
 
-			// Detect bun via `process.isBun`
-			auto is_bun = [ & ] -> bool {
+			// Get `globalThis.process`
+			auto* process_global = [ & ]() -> napi_value {
 				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);
+					return process;
 				} else {
+					return nullptr;
+				}
+			}();
+
+			// Detect bun via `process.isBun`
+			auto is_bun = process_global == nullptr ? false : [ & ]() -> bool {
+				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_global, 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);
+			}();
+
+			// Detect deno via `process.versions.deno`
+			auto is_deno = process_global == nullptr ? false : [ & ]() -> bool {
+				constexpr auto versions_cw = util::make_consteval_string_view(util::cw<"versions">);
+				auto* versions_str = napi::invoke(node_api_create_property_key_latin1, env, versions_cw.data(), versions_cw.length());
+				auto* versions = napi::invoke(napi_get_property, env, process_global, versions_str);
+				if (napi::invoke(napi_typeof, env, versions) != napi_object) {
 					return false;
 				}
+				constexpr auto deno_cw = util::make_consteval_string_view(util::cw<"deno">);
+				auto* deno_str = napi::invoke(node_api_create_property_key_latin1, env, deno_cw.data(), deno_cw.length());
+				auto* deno = napi::invoke(napi_get_property, env, versions, deno_str);
+				auto* deno_bool = napi::invoke(napi_coerce_to_bool, env, deno);
+				return napi::invoke(napi_get_value_bool, env, deno_bool);
 			}();
-			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;
+
+			auto is_nodejs = !is_bun && !is_deno;
+			if (is_nodejs) {
+				has_extended_fast_is_functions = true;
+				fast_is_false = v8_is_false;
+				fast_is_null = v8_is_null;
+				fast_is_true = v8_is_true;
+				fast_is_undefined = v8_is_undefined;
+				host_uv_dlclose = node_uv_dlclose;
+				host_uv_dlerror = node_uv_dlerror;
+				host_uv_dlopen = node_uv_dlopen;
 				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>;
@@ -219,9 +292,49 @@ auto initialize_host_environment(napi_env env) -> void {
 				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;
+				maybe_is_number_int32 = v8_is_number_int32;
+				maybe_is_shared_array_buffer = node_api_maybe_is_shared_array_buffer;
+				maybe_is_string_latin1 = v8_is_string_one_byte;
+				shared_array_buffer_get_backing_store = v8_shared_array_buffer_get_backing_store;
+				shared_array_buffer_get_byte_length = v8_shared_array_buffer_get_byte_length;
+			} else {
+				has_extended_fast_is_functions = false;
+				fast_is_false = napi_fast_is_false;
+				fast_is_null = napi_fast_is_null;
+				fast_is_true = napi_fast_is_true;
+				fast_is_undefined = napi_fast_is_undefined;
+				host_uv_dlclose = unknown_uv_dlclose;
+				host_uv_dlerror = unknown_uv_dlerror;
+				host_uv_dlopen = unknown_uv_dlopen;
+				make_sab_data_view = unknown_sab_throw<local_of<data_view_tag>>;
+				make_sab_typed_array_of<double> = unknown_sab_throw<local_of<typed_array_tag_of<double>>>;
+				make_sab_typed_array_of<float> = unknown_sab_throw<local_of<typed_array_tag_of<float>>>;
+				make_sab_typed_array_of<js::float16_t> = unknown_sab_throw<local_of<typed_array_tag_of<js::float16_t>>>;
+				make_sab_typed_array_of<js::uint8_clamped_t> = unknown_sab_throw<local_of<typed_array_tag_of<js::uint8_clamped_t>>>;
+				make_sab_typed_array_of<std::int16_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int16_t>>>;
+				make_sab_typed_array_of<std::int32_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int32_t>>>;
+				make_sab_typed_array_of<std::int64_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int64_t>>>;
+				make_sab_typed_array_of<std::int8_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::int8_t>>>;
+				make_sab_typed_array_of<std::uint16_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint16_t>>>;
+				make_sab_typed_array_of<std::uint32_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint32_t>>>;
+				make_sab_typed_array_of<std::uint64_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint64_t>>>;
+				make_sab_typed_array_of<std::uint8_t> = unknown_sab_throw<local_of<typed_array_tag_of<std::uint8_t>>>;
+				make_shared_array_buffer = unknown_sab_throw<local_of<shared_array_buffer_tag>>;
+				maybe_is_number_int32 = unknown_maybe_is;
+				maybe_is_shared_array_buffer = unknown_maybe_is;
+				maybe_is_string_latin1 = unknown_maybe_is;
+				// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+				shared_array_buffer_get_backing_store = unknown_sab_throw<std::shared_ptr<std::byte[]>>;
+				shared_array_buffer_get_byte_length = unknown_sab_throw<std::size_t>;
+			}
+
+			// Bug fixes
+			is_data_block_array_buffer = napi_is_data_block_array_buffer;
+			is_object_array_buffer = napi_is_object_array_buffer;
+			if (is_bun) {
+				is_data_block_array_buffer = bun_is_data_block_array_buffer;
+				is_object_array_buffer = bun_is_object_array_buffer;
+				maybe_is_shared_array_buffer = bun_maybe_is_shared_array_buffer;
 			}
 		}
 	}

package/support/host.h.cc

@@ -1,5 +1,5 @@
 export module napi_js:support.host;
-import :value_handle;
+import :handle.local_of;
 import std;
 
 namespace js::napi {
@@ -7,32 +7,43 @@ 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;
+// Fast functions which are supported on all platforms
+auto (*fast_is_false)(napi_env env, napi_value value) -> bool;
+auto (*fast_is_null)(napi_env env, napi_value value) -> bool;
+auto (*fast_is_true)(napi_env env, napi_value value) -> bool;
+auto (*fast_is_undefined)(napi_env env, napi_value value) -> bool;
 
-// nb: These will crash on Bun
-auto has_fast_is_functions = false;
+// Extended fast functions
+auto has_extended_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;
+// Bug fixes
+auto (*is_object_array_buffer)(napi_env env, local_of<object_tag> value) -> bool = nullptr;
+auto (*is_data_block_array_buffer)(napi_env env, local_of<data_block_tag> value) -> bool = nullptr;
+
+// Optional value inspectors. int32 & latin1 will select optimized representations, and
+// shared_array_buffer is required for support of that value type.
+auto (*maybe_is_number_int32)(local_of<number_tag> value) -> std::optional<bool> = nullptr;
+auto (*maybe_is_string_latin1)(local_of<string_tag> value) -> std::optional<bool> = nullptr;
+auto (*maybe_is_shared_array_buffer)(napi_env env, local_of<object_tag> value) -> std::optional<bool> = nullptr;
+
+// 'SharedArrayBuffer' functions
+auto (*make_shared_array_buffer)(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> local_of<shared_array_buffer_tag> = nullptr;
+auto (*shared_array_buffer_get_byte_length)(local_of<shared_array_buffer_tag> buffer) -> std::size_t = nullptr;
+// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+auto (*shared_array_buffer_get_backing_store)(local_of<shared_array_buffer_tag> buffer) -> std::shared_ptr<std::byte[]> = 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;
+auto (*make_sab_data_view)(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_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>>;
+	auto(local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>>;
 
 template <class Type>
 make_sab_typed_array_constructor<Type>* make_sab_typed_array_of;
@@ -50,6 +61,11 @@ template make_sab_typed_array_constructor<std::uint32_t>* make_sab_typed_array_o
 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>;
 
+// uv dlfcn wrappers
+auto (*host_uv_dlerror)(const uv_lib_t* lib) -> const char*;
+auto (*host_uv_dlopen)(const char* filename, uv_lib_t* lib) -> int;
+auto (*host_uv_dlclose)(uv_lib_t* lib) -> void;
+
 // Once per process, this detects the host environment (nodejs vs bun)
 auto initialize_host_environment(napi_env env) -> void;
 

package/support/initialize.h.cc

@@ -34,8 +34,8 @@ class napi_js_module final : private detail::initialize_require {
 			const auto [... indices ] = util::sequence<sizeof...(Args)>;
 			auto& client_environment = environment::make_and_set_environment<Environment>(env, std::get<indices>(std::move(args_))...);
 			// assign export descriptor to napi-constructor namespace object
-			auto exports_local = value_of<dictionary_tag>::from(exports);
-			exports_local.assign(client_environment, std::move(make_exports_)(client_environment));
+			auto exports_local = local_of<dictionary_tag>::from(exports);
+			exports_local->assign(client_environment, std::move(make_exports_)(client_environment));
 		}
 
 		Make make_exports_;

package/support/promise.cc

@@ -19,7 +19,7 @@ class resolver {
 		resolver(resolver&&) = default;
 		~resolver() {
 			if (scheduler_) {
-				resolve(std::monostate{});
+				resolve(nullptr);
 			}
 		}
 
@@ -42,7 +42,8 @@ class resolver {
 
 		// Fulfill using direct resolution value. Note it still needs try/catch (in `fulfill`) because
 		// the `transfer` operation could fail.
-		auto resolve(auto value) -> void {
+		template <class Type>
+		auto resolve(Type value) noexcept(std::is_nothrow_move_constructible_v<Type>) -> void {
 			using expected_type = std::expected<decltype(value), js::error_value>;
 			schedule(
 				[](Environment& /*env*/, auto value) -> expected_type {
@@ -53,7 +54,7 @@ class resolver {
 		}
 
 		// Fulfill using thrown error.
-		auto reject(js::error_value error) -> void {
+		auto reject(js::error_value error) noexcept -> void {
 			using expected_type = std::expected<std::monostate, js::error_value>;
 			schedule(
 				[](Environment& /*env*/, js::error_value error) -> expected_type {
@@ -64,10 +65,11 @@ class resolver {
 		}
 
 	private:
-		auto schedule(auto operation, auto&&... args) -> void {
+		template <class Operation, class... Args>
+		auto schedule(Operation operation, Args&&... args) noexcept(std::is_nothrow_move_constructible_v<Operation> && (std::is_nothrow_move_constructible_v<Args> && ...)) -> void {
 			auto scheduler = std::move(scheduler_);
 			scheduler(
-				[](napi_env env, napi_value /*nothing*/, napi_deferred deferred, auto operation, auto&&... args) {
+				[](napi_env env, napi_value /*nothing*/, napi_deferred deferred, auto operation, auto&&... args) noexcept {
 					auto& environment = napi::environment::unsafe_get_environment_as<Environment>(env);
 					environment.scheduler().decrement_ref(env);
 					try {
@@ -81,10 +83,10 @@ class resolver {
 						}
 					} catch (const napi::pending_error& /*error*/) {
 						auto* exception = napi::invoke(napi_get_and_clear_last_exception, env);
-						napi::invoke0(napi_reject_deferred, env, deferred, exception);
+						napi::invoke0_noexcept(napi_reject_deferred, env, deferred, exception);
 					} catch (const js::error& error) {
 						auto exception = js::transfer_in_strict<napi_value>(error, environment);
-						napi::invoke0(napi_reject_deferred, env, deferred, exception);
+						napi::invoke0_noexcept(napi_reject_deferred, env, deferred, exception);
 					}
 				},
 				deferred_,
@@ -115,7 +117,7 @@ auto make_promise(Environment& env, auto... dispatch) {
 	auto resolve = resolver{env, deferred, std::move(dispatch)...};
 
 	// `[ promise, resolver ]`
-	return std::tuple{value_of<promise_tag>::from(promise), std::move(resolve)};
+	return std::tuple{local_of<promise_tag>::from(promise), std::move(resolve)};
 }
 
 } // namespace js::napi

package/support/win32_delay_load_hook.cc

@@ -0,0 +1,12 @@
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <delayimp.h>
+import std;
+
+const auto __pfnDliNotifyHook2 = PfnDliHook{[](unsigned event, DelayLoadInfo* info) -> FARPROC {
+	if (event == dliNotePreLoadLibrary && std::string_view{info->szDll} == "node.exe") {
+		return reinterpret_cast<FARPROC>(GetModuleHandle(nullptr));
+	} else {
+		return nullptr;
+	}
+}};