@auto_js/napi 0.0.7 → 0.0.8

package/CMakeLists.txt

@@ -18,7 +18,6 @@ target_sources(${napi_js}
 		api/uv_dlib.cc
 		api/uv_scheduler.cc
 		support/environment.cc
-		support/host_shim.cc
 		support/host.cc
 		support/initialize.cc
 		transfer/accept.cc
@@ -69,3 +68,15 @@ target_sources(${napi_js}
 		value/record.h.cc
 		value/value.cc
 )
+
+# Enable "delay load" for win32 otherwise the dll will attempt to load node.exe from PATH as a
+# shared library and then start invoking functions from it.
+if(WIN32)
+	set(napi_js_delay_load ${napi_js}_delay_load)
+	add_library(${napi_js_delay_load} STATIC)
+	set_target_properties(${napi_js_delay_load} PROPERTIES CXX_VISIBILITY_PRESET default)
+	target_sources(${napi_js_delay_load} PUBLIC support/win32_delay_load_hook.cc)
+	target_link_libraries(${napi_js_delay_load} PUBLIC delayimp.lib)
+	target_link_libraries(${napi_js} PUBLIC ${napi_js_delay_load})
+	target_link_options(${napi_js_delay_load} PUBLIC "-Wl,/DELAYLOAD:node.exe")
+endif()

package/api/finalizer.cc

@@ -7,15 +7,14 @@ namespace js::napi {
 
 // Generic finalizer for basic `std::unique_ptr<T>`
 template <class Env, class Type, class Deleter>
-auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Deleter>* unique) {
+auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Deleter> unique) {
 	if constexpr (std::is_empty_v<Deleter>) {
 		// Finalizer uses a default-constructed deleter
 		auto finalize = [](Env /*env*/, void* data, void* /*hint*/) -> void {
 			Deleter deleter{};
 			deleter(static_cast<Type*>(data));
 		};
-		auto release = [ unique ] { unique->release(); };
-		return std::tuple{finalize, nullptr, release};
+		return std::tuple{finalize, nullptr, std::move(unique)};
 	} else {
 		static_assert(std::is_trivially_destructible_v<Deleter>);
 		static_assert(sizeof(Deleter) == sizeof(void*));
@@ -23,28 +22,26 @@ auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Dele
 		auto finalize = [](Env /*env*/, void* data, void* hint) -> void {
 			std::bit_cast<Deleter>(hint)(static_cast<Type*>(data));
 		};
-		auto release = [ unique ] { unique->release(); };
-		return std::tuple{finalize, std::bit_cast<void*>(unique->get_deleter()), release};
+		return std::tuple{finalize, std::bit_cast<void*>(unique.get_deleter()), std::move(unique)};
 	}
 }
 
 // Generic finalizer for `std::shared_ptr<T>`
 template <class Env, class Type>
-auto make_finalizer(std::type_identity<Env> /*type*/, std::shared_ptr<Type>* shared) {
+auto make_finalizer(std::type_identity<Env> /*type*/, std::shared_ptr<Type> shared) {
 	// `shared_ptr<T>*` is passed as the finalizer hint
 	using shared_ptr_type = std::shared_ptr<Type>;
-	auto* ptr = shared->get();
-	auto ptr_ptr = std::make_unique<shared_ptr_type>(std::move(*shared));
+	auto* ptr = shared.get();
+	auto ptr_ptr = std::make_unique<shared_ptr_type>(std::move(shared));
 	auto finalize = [](Env /*env*/, void* /*data*/, void* hint) -> void {
 		delete static_cast<shared_ptr_type*>(hint);
 	};
-	auto release = [ ptr_ptr = std::move(ptr_ptr) ] mutable { ptr_ptr.release(); };
-	return std::tuple{finalize, ptr_ptr.get(), std::move(release)};
+	return std::tuple{finalize, ptr_ptr.get(), std::move(ptr_ptr)};
 }
 
 // Apply a finalizer to the given smart pointer type
 template <class Pointer, class Apply>
-auto apply_finalizer(Pointer unique, Apply apply) -> decltype(auto) {
+auto apply_finalizer(Pointer smart_ptr, Apply apply) -> decltype(auto) {
 	using element_type = Pointer::element_type;
 	constexpr auto napi_env_type = []() consteval -> auto {
 		if constexpr (std::invocable<Apply, element_type*, node_api_basic_finalize, void*>) {
@@ -54,11 +51,12 @@ auto apply_finalizer(Pointer unique, Apply apply) -> decltype(auto) {
 			return type<napi_env>;
 		}
 	}();
-	auto [ finalize, hint, release ] = make_finalizer(napi_env_type, &unique);
+	auto* pointer = smart_ptr.get();
+	auto [ finalize, hint, releasable ] = make_finalizer(napi_env_type, std::move(smart_ptr));
 	auto result = util::regular_return{[ & ] -> decltype(auto) {
-		return apply(unique.get(), finalize, hint);
+		return apply(pointer, finalize, hint);
 	}}();
-	release();
+	releasable.release();
 	return *std::move(result);
 }
 

package/api/napi_scheduler.cc

@@ -10,11 +10,11 @@ napi_scheduler::napi_scheduler(napi_env env) :
 	fn_.unref(env);
 }
 
-napi_scheduler::operator bool() const {
+napi_scheduler::operator bool() const noexcept {
 	return bool{fn_};
 }
 
-auto napi_scheduler::close(threadsafe_function_type::close_callback close) -> void {
+auto napi_scheduler::close(threadsafe_function_type::close_callback close) noexcept -> void {
 	fn_.close(close);
 }
 
@@ -32,7 +32,7 @@ auto napi_scheduler::increment_ref(node_api_basic_env env) const -> void {
 	}
 }
 
-auto napi_scheduler::storage::operator()(napi_env env, napi_value value, task_type& task) -> void {
+auto napi_scheduler::storage::operator()(napi_env env, napi_value value, task_type& task) noexcept -> void {
 	task(env, value);
 }
 

package/api/napi_scheduler.h.cc

@@ -10,21 +10,22 @@ namespace js::napi {
 export class napi_scheduler {
 	private:
 		struct storage;
-		using task_type = util::move_only_function<auto(napi_env, napi_value)->void>;
+		using task_type = util::move_only_function<auto(napi_env, napi_value) noexcept -> void>;
 		using threadsafe_function_type = threadsafe_function_of<storage, task_type>;
 
 	public:
+		napi_scheduler() = default;
 		explicit napi_scheduler(napi_env env);
-		auto operator()(auto task, auto&&... args) const -> bool;
-		explicit operator bool() const;
-		auto close(threadsafe_function_type::close_callback close) -> void;
+		auto operator()(auto task, auto&&... args) const noexcept -> bool;
+		explicit operator bool() const noexcept;
+		auto close(threadsafe_function_type::close_callback close) noexcept -> void;
 		auto decrement_ref(node_api_basic_env env) const -> void;
 		auto increment_ref(node_api_basic_env env) const -> void;
 
 	private:
 		struct storage {
 				storage() = default;
-				auto operator()(napi_env env, napi_value value, task_type& task) -> void;
+				auto operator()(napi_env env, napi_value value, task_type& task) noexcept -> void;
 				int refs{};
 		};
 
@@ -43,7 +44,7 @@ export class napi_schedulable {
 
 // ---
 
-auto napi_scheduler::operator()(auto task, auto&&... args) const -> bool {
+auto napi_scheduler::operator()(auto task, auto&&... args) const noexcept -> bool {
 	return fn_(
 		[ task = std::move(task),
 			... args = std::forward<decltype(args)>(args) ](

package/api/threadsafe_function.cc

@@ -13,6 +13,7 @@ class threadsafe_function_of : util::non_copyable {
 	public:
 		using close_callback = util::function_ref<auto()->void>;
 
+		threadsafe_function_of() = default;
 		explicit threadsafe_function_of(auto& env, napi_value value, auto&&... args);
 		threadsafe_function_of(const threadsafe_function_of&);
 		threadsafe_function_of(threadsafe_function_of&&) noexcept;
@@ -20,12 +21,12 @@ class threadsafe_function_of : util::non_copyable {
 		auto operator=(const threadsafe_function_of&) -> threadsafe_function_of& = delete;
 		auto operator=(threadsafe_function_of&&) -> threadsafe_function_of& = delete;
 
-		auto close(close_callback callback) -> void;
+		auto close(close_callback callback) noexcept -> void;
 		auto ref(node_api_basic_env env) const -> void;
 		auto unref(node_api_basic_env env) const -> void;
-		auto operator()(Message message) const -> bool;
-		auto operator*() const -> Context& { return get(); }
-		explicit operator bool() const { return tsfn_ != nullptr; }
+		auto operator()(Message message) const noexcept -> bool;
+		auto operator*() const noexcept -> Context& { return get(); }
+		explicit operator bool() const noexcept { return tsfn_ != nullptr; }
 
 	private:
 		struct storage : Context {
@@ -36,11 +37,11 @@ class threadsafe_function_of : util::non_copyable {
 			private:
 				close_callback close_hook_{[] -> void {}};
 		};
-		auto get() const -> storage&;
+		auto get() const noexcept -> storage&;
 
 		constexpr static auto trivial_message =
 			std::is_trivially_destructible_v<Message> && sizeof(Message) <= sizeof(void*);
-		mutable napi_threadsafe_function tsfn_;
+		mutable napi_threadsafe_function tsfn_{};
 };
 
 // ---
@@ -98,7 +99,7 @@ threadsafe_function_of<Context, Message>::~threadsafe_function_of() {
 }
 
 template <class Context, class Message>
-auto threadsafe_function_of<Context, Message>::close(close_callback callback) -> void {
+auto threadsafe_function_of<Context, Message>::close(close_callback callback) noexcept -> void {
 	get().close_hook_ = callback;
 	napi::invoke0_noexcept(napi_release_threadsafe_function, std::exchange(tsfn_, nullptr), napi_tsfn_abort);
 }
@@ -114,7 +115,7 @@ auto threadsafe_function_of<Context, Message>::unref(node_api_basic_env env) con
 }
 
 template <class Context, class Message>
-auto threadsafe_function_of<Context, Message>::operator()(Message message) const -> bool {
+auto threadsafe_function_of<Context, Message>::operator()(Message message) const noexcept -> bool {
 	auto check = [ & ](napi_status status) {
 		switch (status) {
 			case napi_ok:
@@ -147,7 +148,7 @@ auto threadsafe_function_of<Context, Message>::operator()(Message message) const
 }
 
 template <class Context, class Message>
-auto threadsafe_function_of<Context, Message>::get() const -> storage& {
+auto threadsafe_function_of<Context, Message>::get() const noexcept -> storage& {
 	auto* context = napi::invoke_noexcept(napi_get_threadsafe_function_context, tsfn_);
 	return *reinterpret_cast<storage*>(context);
 }

package/api/uv_dlib.cc

@@ -1,13 +1,14 @@
 module napi_js;
 import :api.uv_dlib;
+import :support.host;
 import util;
 
 namespace js::napi {
 
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 uv_dlib::uv_dlib(const std::string& filename) {
-	if (uv_dlopen(filename.c_str(), &lib_) != 0) {
-		throw js::runtime_error{util::transcode_string<char16_t>(std::string_view{uv_dlerror(&lib_)})};
+	if (host_uv_dlopen(filename.c_str(), &lib_) != 0) {
+		throw js::runtime_error{util::transcode_string<char16_t>(std::string_view{host_uv_dlerror(&lib_)})};
 	}
 }
 
@@ -20,7 +21,7 @@ auto uv_dlib::operator=(uv_dlib&& right) noexcept -> uv_dlib& {
 
 uv_dlib::~uv_dlib() {
 	if (lib_.handle != nullptr) {
-		uv_dlclose(&lib_);
+		host_uv_dlclose(&lib_);
 	}
 }
 

package/handle/reference.cc

@@ -14,7 +14,7 @@ class reference_handle : util::non_copyable {
 				env_{env},
 				ref_{napi::invoke(napi_create_reference, env, value, 1)} {}
 
-		[[nodiscard]] auto env() const -> napi_env {
+		[[nodiscard]] auto env() const -> node_api_basic_env {
 			return env_;
 		}
 
@@ -64,7 +64,7 @@ class reference_handle : util::non_copyable {
 		explicit operator bool() const { return ref_ != nullptr; }
 
 	private:
-		napi_env env_{};
+		node_api_basic_env env_{};
 		napi_ref ref_{};
 };
 

package/handle/remote.cc

@@ -23,6 +23,7 @@ class remote : protected reference_handle {
 	public:
 		using unique_remote = std::unique_ptr<remote, util::function_constant<expire>>;
 
+		remote() = default;
 		remote(private_constructor /*private*/, const environment& env, value_of<Tag> value, napi_scheduler scheduler) :
 				reference_handle{napi_env{env}, napi_value{value}},
 				scheduler_{std::move(scheduler)} {}

package/handle/types.cc

@@ -63,6 +63,16 @@ struct value_specialization<boolean_tag> : value_defaults<boolean_tag> {
 		using bound_type = class bound_value_for_boolean;
 };
 
+template <>
+struct value_specialization<false_tag> : value_defaults<false_tag> {
+		using bound_type = class bound_value_for_false;
+};
+
+template <>
+struct value_specialization<true_tag> : value_defaults<true_tag> {
+		using bound_type = class bound_value_for_true;
+};
+
 template <>
 struct value_specialization<number_tag> : value_defaults<number_tag> {
 		using bound_type = class bound_value_for_number;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "author": "https://github.com/laverdet/",
   "description": "Automatic JavaScript to N-API bindings",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/napi",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/js": "^0.0.7",
-    "@auto_js/napi_exports": "^0.0.7",
-    "@auto_js/v8_exports": "^0.0.5"
+    "@auto_js/js": "^0.0.8",
+    "@auto_js/napi_exports": "^0.0.8",
+    "@auto_js/v8_exports": "^0.0.6"
   },
   "repository": {
     "type": "git",

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();
+}
+
+auto v8_is_undefined(napi_env /*env*/, napi_value value) -> bool {
+	return std::bit_cast<v8::Local<v8::Value>>(value)->IsUndefined();
+}
 
-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 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_number_int32 =
-	[](value_of<number_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_fast_is_string_one_byte =
-	[](value_of<string_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);
+}
 
-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_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,56 @@ 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, value_of<object_tag> value) -> bool {
+	return napi::invoke(napi_is_arraybuffer, env, value);
+}
+
+auto napi_is_data_block_array_buffer(napi_env env, value_of<data_block_tag> value) -> bool {
+	return napi_is_object_array_buffer(env, value);
+}
+
+auto bun_is_data_block_array_buffer(napi_env env, value_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, value_of<object_tag> value) -> bool {
+	if (napi::invoke(napi_is_arraybuffer, env, value)) {
+		return bun_is_data_block_array_buffer(env, value_of<data_block_tag>::from(value));
+	} else {
+		return false;
+	}
+}
+
+// Optional value inspectors.
+auto v8_is_number_int32(value_of<number_tag> value) -> std::optional<bool> {
+	return std::bit_cast<v8::Local<v8::Number>>(value)->IsInt32();
+};
+
+auto v8_is_string_one_byte(value_of<string_tag> value) -> std::optional<bool> {
+	return std::bit_cast<v8::Local<v8::String>>(value)->IsOneByte();
 }
 
-// '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 node_api_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 bun_maybe_is_shared_array_buffer(napi_env env, value_of<object_tag> value) -> std::optional<bool> {
+	if (napi::invoke(napi_is_arraybuffer, env, value)) {
+		return !bun_is_data_block_array_buffer(env, value_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) -> 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.
@@ -93,31 +142,28 @@ constexpr auto v8_make_shared_array_buffer =
 	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"};
+auto v8_shared_array_buffer_get_byte_length(value_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(value_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(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>> {
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+auto v8_make_sab_typed_array_of(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 {}; },
@@ -138,12 +184,26 @@ constexpr auto v8_make_sab_typed_array_of =
 };
 
 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 +228,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 +288,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<value_of<data_view_tag>>;
+				make_sab_typed_array_of<double> = unknown_sab_throw<value_of<typed_array_tag_of<double>>>;
+				make_sab_typed_array_of<float> = unknown_sab_throw<value_of<typed_array_tag_of<float>>>;
+				make_sab_typed_array_of<js::float16_t> = unknown_sab_throw<value_of<typed_array_tag_of<js::float16_t>>>;
+				make_sab_typed_array_of<js::uint8_clamped_t> = unknown_sab_throw<value_of<typed_array_tag_of<js::uint8_clamped_t>>>;
+				make_sab_typed_array_of<std::int16_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int16_t>>>;
+				make_sab_typed_array_of<std::int32_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int32_t>>>;
+				make_sab_typed_array_of<std::int64_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int64_t>>>;
+				make_sab_typed_array_of<std::int8_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::int8_t>>>;
+				make_sab_typed_array_of<std::uint16_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint16_t>>>;
+				make_sab_typed_array_of<std::uint32_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint32_t>>>;
+				make_sab_typed_array_of<std::uint64_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint64_t>>>;
+				make_sab_typed_array_of<std::uint8_t> = unknown_sab_throw<value_of<typed_array_tag_of<std::uint8_t>>>;
+				make_shared_array_buffer = unknown_sab_throw<value_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

@@ -7,25 +7,36 @@ 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
+// Bug fixes
+auto (*is_object_array_buffer)(napi_env env, value_of<object_tag> value) -> bool = nullptr;
+auto (*is_data_block_array_buffer)(napi_env env, value_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)(value_of<number_tag> value) -> std::optional<bool> = nullptr;
+auto (*maybe_is_string_latin1)(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;
+
+// 'SharedArrayBuffer' functions
 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;
+auto (*shared_array_buffer_get_byte_length)(value_of<shared_array_buffer_tag> buffer) -> std::size_t = nullptr;
+// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+auto (*shared_array_buffer_get_backing_store)(value_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;
@@ -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/promise.cc

@@ -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_,

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;
+	}
+}};

package/transfer/visit.cc

@@ -134,7 +134,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 		template <class Accept>
 		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (maybe_fast_is_number_int32(subject).value_or(false)) {
+			if (maybe_is_number_int32(subject).value_or(false)) {
 				return immediate(value_of<number_tag_of<std::int32_t>>::from(subject), accept);
 			} else {
 				return immediate(value_of<number_tag_of<double>>::from(subject), accept);
@@ -153,85 +153,94 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 			// Check the reference map, and lookup type via napi
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
 				// This is the pure-napi implementation
-				auto slow_path = [ & ]() -> accept_target_t<Accept> {
-					auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
-					switch (type_of) {
-						case napi_undefined:
-							return (*this)(value_of<undefined_tag>::from(subject), accept);
-						case napi_null:
-							return (*this)(value_of<null_tag>::from(subject), accept);
-						case napi_boolean:
-							return (*this)(value_of<boolean_tag>::from(subject), accept);
-						case napi_number:
-							return (*this)(value_of<number_tag>::from(subject), accept);
-						case napi_string:
-							return immediate(value_of<string_tag>::from(subject), accept);
-						case napi_symbol:
-							return immediate(value_of<symbol_tag>::from(subject), accept);
-						case napi_object:
-							return immediate(value_of<object_tag>::from(subject), accept);
-						case napi_function:
-							return immediate(value_of<function_tag>::from(subject), accept);
-						case napi_external:
-							return immediate(value_of<external_tag>::from(subject), accept);
-						case napi_bigint:
-							return immediate(value_of<bigint_tag>::from(subject), accept);
-					}
-					std::unreachable();
+				auto slow_path = util::overloaded{
+					[ & ]() -> accept_target_t<Accept> {
+						auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
+						switch (type_of) {
+							case napi_undefined:
+								return (*this)(value_of<undefined_tag>::from(subject), accept);
+							case napi_null:
+								return (*this)(value_of<null_tag>::from(subject), accept);
+							case napi_boolean:
+								return (*this)(value_of<boolean_tag>::from(subject), accept);
+							case napi_number:
+								return (*this)(value_of<number_tag>::from(subject), accept);
+							case napi_string:
+								return immediate(value_of<string_tag>::from(subject), accept);
+							case napi_symbol:
+								return immediate(value_of<symbol_tag>::from(subject), accept);
+							case napi_object:
+								return immediate(value_of<object_tag>::from(subject), accept);
+							case napi_function:
+								return immediate(value_of<function_tag>::from(subject), accept);
+							case napi_external:
+								return immediate(value_of<external_tag>::from(subject), accept);
+							case napi_bigint:
+								return immediate(value_of<bigint_tag>::from(subject), accept);
+						}
+						std::unreachable();
+					},
+
+					[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
 				};
 
-				if (has_fast_is_functions) {
-					return util::template_traverse(
-						accept_tags_of_v<Accept>,
-						util::overloaded{
-							// Fast paths
-							[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_undefined(subject) ? (*this)(value_of<undefined_tag>::from(subject), accept) : next();
-							},
-							[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_null(subject) ? (*this)(value_of<null_tag>::from(subject), accept) : next();
-							},
-							[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_boolean(subject) ? (*this)(value_of<boolean_tag>::from(subject), accept) : next();
-							},
-							[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_number(subject) ? (*this)(value_of<number_tag>::from(subject), accept) : next();
-							},
-							[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_string(subject) ? immediate(value_of<string_tag>::from(subject), accept) : next();
-							},
-							[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_bigint(subject) ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
-							},
-							[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(value_of<date_tag>::from(subject), accept) : next();
-							},
-							[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_array(subject) ? immediate(value_of<list_tag>::from(subject), accept) : next();
-							},
-							[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
-								// checks. We don't really want to accept those types here, I don't think..
-								return fast_is_object(subject) ? immediate(value_of<object_tag>::from(subject), accept) : next();
-							},
-							[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-								return fast_is_function(subject) ? immediate(value_of<function_tag>::from(subject), accept) : next();
-							},
-
-							// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
-							// differentiate between.
-							[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-							[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-
-							// Unknown tag
-							[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-
-							// Slow path
-							slow_path,
+				// Universal fast checks
+				auto fast_path = util::overloaded{
+					[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_undefined(napi_env{*this}, subject) ? (*this)(value_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)(value_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)(value_of<false_tag>::from(subject), accept);
+						} else if (fast_is_true(napi_env{*this}, subject)) {
+							return (*this)(value_of<true_tag>::from(subject), accept);
+						} else {
+							return next();
 						}
-					);
+					},
+				};
+
+				// Extended fast checks
+				auto extended_fast_path = util::overloaded{
+					[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_number(subject) ? (*this)(value_of<number_tag>::from(subject), accept) : next();
+					},
+					[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_string(subject) ? immediate(value_of<string_tag>::from(subject), accept) : next();
+					},
+					[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_bigint(subject) ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
+					},
+					[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(value_of<date_tag>::from(subject), accept) : next();
+					},
+					[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_array(subject) ? immediate(value_of<list_tag>::from(subject), accept) : next();
+					},
+					[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
+						// checks. We don't really want to accept those types here, I don't think..
+						return fast_is_object(subject) ? immediate(value_of<object_tag>::from(subject), accept) : next();
+					},
+					[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+						return fast_is_function(subject) ? immediate(value_of<function_tag>::from(subject), accept) : next();
+					},
+
+					// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
+					// differentiate between.
+					[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+					[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+				};
+
+				if (has_extended_fast_is_functions) {
+					auto traverse = util::overloaded{fast_path, extended_fast_path, slow_path};
+					return util::template_traverse(accept_tags_of_v<Accept>, traverse);
 				} else {
-					return slow_path();
+					auto traverse = util::overloaded{fast_path, slow_path};
+					return util::template_traverse(accept_tags_of_v<Accept>, traverse);
 				}
 			});
 		}
@@ -272,7 +281,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// strings
 		template <class Accept>
 		auto immediate(value_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (maybe_fast_is_string_one_byte(subject).value_or(false)) {
+			if (maybe_is_string_latin1(subject).value_or(false)) {
 				return accept_tagged(value_of<string_tag_of<char>>::from(subject), accept);
 			} else {
 				return accept_tagged(value_of<string_tag_of<char16_t>>::from(subject), accept);
@@ -298,7 +307,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 				return immediate(value_of<data_view_tag>::from(subject), accept);
 			} else if (maybe_is_shared_array_buffer(env_.get(), subject).value_or(false)) {
 				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
-			} else if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
+			} else if (is_object_array_buffer(env_.get(), subject)) {
 				return immediate(value_of<array_buffer_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_promise, napi_env{*this}, subject)) {
 				return immediate(value_of<promise_tag>::from(subject), accept);
@@ -316,7 +325,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// data blocks
 		template <class Accept>
 		auto immediate(value_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
+			if (is_data_block_array_buffer(env_.get(), subject)) {
 				return immediate(value_of<array_buffer_tag>::from(subject), accept);
 			} else {
 				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);

package/value/array_buffer.cc

@@ -24,11 +24,9 @@ bound_value_for_array_buffer::operator js::array_buffer() const {
 
 // `bound_value_for_shared_array_buffer`
 bound_value_for_shared_array_buffer::operator js::shared_array_buffer() const {
-	auto local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{*this});
-	auto backing_store = local->GetBackingStore();
-	auto* data = reinterpret_cast<std::byte*>(backing_store->Data());
-	auto data_shared_ptr = std::shared_ptr<js::shared_array_buffer::array_type>{std::move(backing_store), data};
-	return js::shared_array_buffer{local->ByteLength(), std::move(data_shared_ptr)};
+	auto byte_length = shared_array_buffer_get_byte_length(value_of{*this});
+	auto backing_store = shared_array_buffer_get_backing_store(value_of{*this});
+	return js::shared_array_buffer{byte_length, std::move(backing_store)};
 }
 
 // `value_for_typed_array`

package/value/primitive.h.cc

@@ -13,6 +13,19 @@ class bound_value_for_boolean : public bound_value_next<boolean_tag> {
 		using bound_value_next<boolean_tag>::bound_value_next;
 		[[nodiscard]] explicit operator bool() const;
 };
+
+class bound_value_for_false : public bound_value_next<false_tag> {
+	public:
+		using bound_value_next<false_tag>::bound_value_next;
+		[[nodiscard]] constexpr explicit operator bool() const { return false; }
+};
+
+class bound_value_for_true : public bound_value_next<true_tag> {
+	public:
+		using bound_value_next<true_tag>::bound_value_next;
+		[[nodiscard]] constexpr explicit operator bool() const { return true; }
+};
+
 // number
 class bound_value_for_number : public bound_value_next<number_tag> {
 	public:

package/support/host_shim.cc

@@ -1,42 +0,0 @@
-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)
-}