@auto_js/v8 0.0.6 → 0.0.8

package/CMakeLists.txt

@@ -63,6 +63,7 @@ if(v8_js STREQUAL isolated_v8_js)
 			isolated/agent.cc
 			isolated/clock.cc
 			isolated/cluster.cc
+			isolated/executor.cc
 			isolated/platform.cc
 			platform/delegate.cc
 			platform/foreground_runner.cc
@@ -74,8 +75,8 @@ if(v8_js STREQUAL isolated_v8_js)
 			isolated/agent.h.cc
 			isolated/clock.h.cc
 			isolated/cluster.h.cc
+			isolated/executor.h.cc
 			isolated/platform.h.cc
-			platform/allocator.h.cc
 			platform/delegate.h.cc
 			platform/foreground_runner.h.cc
 			platform/scheduler.cc

package/evaluation/script.cc

@@ -20,11 +20,9 @@ auto script::compile(context_lock_witness lock, v8::Local<v8::String> code_strin
 	});
 }
 
-auto script::run(context_lock_witness lock, v8::Local<v8::UnboundScript> script) -> expected_value_type {
-	return invoke_externalized_error_scope(lock, [ & ]() -> js::value_t {
-		auto maybe_result = script->BindToCurrentContext()->Run(lock.context());
-		return js::transfer_out<js::value_t>(unmaybe(maybe_result), lock);
-	});
+auto script::run(context_lock_witness lock, v8::Local<v8::UnboundScript> script) -> v8::Local<v8::Value> {
+	auto maybe_result = script->BindToCurrentContext()->Run(lock.context());
+	return unmaybe(maybe_result);
 }
 
 } // namespace js::iv8

package/evaluation/script.h.cc

@@ -10,12 +10,12 @@ namespace js::iv8 {
 export struct script {
 	public:
 		using expected_script_type = std::expected<v8::Local<v8::UnboundScript>, js::error_value>;
-		using expected_value_type = std::expected<js::value_t, js::error_value>;
+		using expected_value_type = std::optional<std::expected<js::value_t, js::error_value>>;
 
 		// nb: It is undocumented (and even mentions "context independent"), but the script compiler
 		// actually needs a context because it can throw an error and *that* would need a context.
 		static auto compile(context_lock_witness lock, auto code_string, source_origin source_origin) -> expected_script_type;
-		static auto run(context_lock_witness lock, v8::Local<v8::UnboundScript> script) -> expected_value_type;
+		static auto run(context_lock_witness lock, v8::Local<v8::UnboundScript> script) -> v8::Local<v8::Value>;
 
 	private:
 		static auto compile(context_lock_witness lock, v8::Local<v8::String> code_string, source_origin source_origin) -> expected_script_type;

package/handle/collected_handle.cc

@@ -1,3 +1,5 @@
+module;
+#include <v8_js/version.h>
 export module v8_js:collected_handle;
 import :lock;
 import std;
@@ -64,7 +66,7 @@ auto collected_handle<Value, Type>::reset(const collected_handle_lock& lock, uni
 			[](const v8::WeakCallbackInfo<collected_handle>& data) -> auto {
 				auto* ptr = data.GetParameter();
 				auto unique = ptr->pool_.get().reacquire(ptr);
-				unique->global_.ClearWeak();
+				unique->global_.template ClearWeak<void>();
 			},
 			v8::WeakCallbackType::kParameter
 		);
@@ -74,7 +76,11 @@ auto collected_handle<Value, Type>::reset(const collected_handle_lock& lock, uni
 export template <class Type>
 auto make_collected_external(const collected_handle_lock& lock, auto&&... args) -> v8::Local<v8::External> {
 	auto unique = collected_external_of<Type>::make(lock, std::forward<decltype(args)>(args)...);
+#if V8_HAS_TAGGED_EXTERNAL
+	auto value = v8::External::New(lock.isolate(), unique.get(), 0);
+#else
 	auto value = v8::External::New(lock.isolate(), unique.get());
+#endif
 	collected_handle<v8::External, Type>::reset(lock, std::move(unique), value);
 	return value;
 }
@@ -82,7 +88,12 @@ auto make_collected_external(const collected_handle_lock& lock, auto&&... args)
 export template <class Type>
 auto unwrap_collected_external(v8::Local<v8::External> external) -> Type& {
 	using handle_type = collected_external_of<Type>;
+#if V8_HAS_TAGGED_EXTERNAL
+	// TODO: Use this feature
+	return **static_cast<handle_type*>(external->Value(0));
+#else
 	return **static_cast<handle_type*>(external->Value());
+#endif
 }
 
 } // namespace js::iv8

package/isolated/agent.cc

@@ -2,7 +2,6 @@ module;
 #include <cassert>
 module v8_js;
 import :isolated.agent;
-import :platform.allocator;
 import std;
 
 namespace js::iv8::isolated {
@@ -25,7 +24,7 @@ auto agent_storage::release(std::shared_ptr<agent_storage> storage) -> void {
 agent_handle::agent_handle(std::shared_ptr<agent_host> host) :
 		host_{host} {
 	if (host && host->handle_count_.fetch_add(1, std::memory_order_relaxed) == 0) {
-		*host->self_handle_.write() = std::move(host);
+		host->self_handle_.store(std::move(host), std::memory_order_relaxed);
 	}
 }
 
@@ -46,12 +45,29 @@ agent_handle::~agent_handle() {
 				host->handle_count_.load(std::memory_order_acquire) == 1 ||
 				host->handle_count_.fetch_sub(1, std::memory_order_acq_rel) == 1
 			) {
-				host->self_handle_.write()->reset();
+				host->self_handle_.store(nullptr, std::memory_order_relaxed);
 			}
 		}
 	}
 }
 
+auto agent_handle::dispose(dispose_callback_type after_callback) -> void {
+	if (auto host = host_.lock()) {
+		assert(!host->dispose_callback_);
+		host->dispose_callback_ = std::move(after_callback);
+		host->executor_.terminate();
+		host->self_handle_.store(nullptr, std::memory_order_release);
+	}
+}
+
+auto agent_handle::lock_host() const -> std::shared_ptr<agent_host> {
+	auto host = host_.lock();
+	if (host && host->executor_.is_terminated()) {
+		host.reset();
+	}
+	return host;
+}
+
 // `agent_host`
 agent_host::agent_host(
 	destroy_callback_type destroy_callback,
@@ -59,27 +75,24 @@ agent_host::agent_host(
 	behavior_params params
 ) :
 		storage_{std::move(storage)},
-		// TODO: v8 holds its own reference to this. I will probably need it later for per-isolate
-		// memory diagnostics though?
-		array_buffer_allocator_{std::make_shared<platform::data_block_allocator>()},
-		isolate_{v8::Isolate::Allocate()},
 		clock_{params.clock},
 		destroy_callback_{destroy_callback},
 		reset_handle_callback_{reset_handle_type{util::fn<&agent_host::remote_expiration_callback>, *this}},
 		random_seed_{params.random_seed} {
-	isolate_->SetData(0, this);
-	auto create_params = v8::Isolate::CreateParams{};
-	create_params.array_buffer_allocator_shared = array_buffer_allocator_;
-	v8::Isolate::Initialize(isolate_.get(), create_params);
-
-	isolate_->SetCaptureStackTraceForUncaughtExceptions(true);
+	executor_.initialize([ & ](v8::Isolate* isolate) noexcept -> auto {
+		isolate->SetData(0, this);
+		auto create_params = v8::Isolate::CreateParams{};
+		create_params.array_buffer_allocator_shared =
+			std::shared_ptr<v8::ArrayBuffer::Allocator>(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
+		return create_params;
+	});
+	executor_.isolate()->SetCaptureStackTraceForUncaughtExceptions(true);
 }
 
 agent_host::~agent_host() {
 	// Terminate foreground runner
 	auto& scheduler = storage_->foreground_runner().scheduler();
 	scheduler.terminate();
-	assert(!scheduler.is_this_thread());
 	if (!scheduler.is_this_thread()) {
 		auto thread = scheduler.invoke([](auto& controller) -> auto {
 			return controller.take();
@@ -88,19 +101,20 @@ agent_host::~agent_host() {
 	}
 	// Destroy isolate and remaining handles
 	{
-		auto lock = js::iv8::isolate_destructor_lock{isolate_.get()};
+		auto lock = js::iv8::isolate_destructor_lock{executor_.isolate()};
 		scratch_context_.Reset();
-		scheduler.mutate([ & ](platform::foreground_task_queue& queue) -> void {
-			queue.finalize();
-		});
 		remote_handle_list_.clear(util::slice(lock));
 		autorelease_pool_.clear();
 		destroy_callback_(util::slice(lock));
 	}
 	// Deallocate isolate (before `agent_storage`)
-	isolate_.reset();
+	executor_.reset();
 	// Release storage
 	agent_storage::release(std::move(storage_));
+	// Notify client
+	if (dispose_callback_) {
+		dispose_callback_();
+	}
 }
 
 auto agent_host::make_context() -> v8::Local<v8::Context> {
@@ -109,7 +123,7 @@ auto agent_host::make_context() -> v8::Local<v8::Context> {
 	// the generator is initialized on context creation, so we just control the randomness in that one
 	// case.
 	should_give_seed_ = true;
-	auto context = v8::Context::New(isolate_.get());
+	auto context = v8::Context::New(executor_.isolate());
 	should_give_seed_ = false;
 	return context;
 }
@@ -122,7 +136,7 @@ auto agent_host::make_remote_handle_lock(isolate_lock_witness lock) -> remote_ha
 auto agent_host::remote_expiration_callback(expired_remote_type remote) noexcept -> void {
 	storage_->foreground_runner().schedule_handle_task(
 		[ this, remote = std::move(remote) ](std::stop_token /*stop_token*/) -> void {
-			auto lock = isolate_execution_lock{isolate()};
+			auto lock = isolate_execution_lock{executor_.isolate()};
 			remote->reset(util::slice(lock));
 			remote_handle_list_.erase(*remote);
 		}
@@ -132,11 +146,11 @@ auto agent_host::remote_expiration_callback(expired_remote_type remote) noexcept
 auto agent_host::scratch_context() -> v8::Local<v8::Context> {
 	if (scratch_context_.IsEmpty()) {
 		auto context = make_context();
-		scratch_context_.Reset(isolate_.get(), context);
+		scratch_context_.Reset(executor_.isolate(), context);
 		scratch_context_.SetWeak();
 		return context;
 	} else {
-		return scratch_context_.Get(isolate_.get());
+		return scratch_context_.Get(executor_.isolate());
 	}
 }
 

package/isolated/agent.h.cc

@@ -3,6 +3,7 @@ module;
 export module v8_js:isolated.agent;
 import :collected_handle;
 import :isolated.clock;
+import :isolated.executor;
 import :platform.foreground_runner;
 import :remote;
 import std;
@@ -67,15 +68,18 @@ export class agent_storage {
 export class agent_handle {
 	public:
 		using lock = agent_lock;
+		using dispose_callback_type = util::move_only_function<auto() noexcept -> void>;
 		explicit agent_handle(std::shared_ptr<agent_host> host);
-		agent_handle(const agent_handle& /*handle*/);
+		agent_handle(const agent_handle& handle);
 		agent_handle(agent_handle&&) = default;
 		~agent_handle();
 		auto operator=(const agent_handle&) -> agent_handle& = delete;
 		auto operator=(agent_handle&&) -> agent_handle& = default;
 
+		auto dispose(dispose_callback_type after_callback) -> void;
+
 	protected:
-		[[nodiscard]] auto lock_host() const -> std::shared_ptr<agent_host> { return host_.lock(); }
+		[[nodiscard]] auto lock_host() const -> std::shared_ptr<agent_host>;
 
 	private:
 		std::weak_ptr<agent_host> host_;
@@ -125,7 +129,7 @@ export class agent_host
 
 		auto autorelease_pool() -> util::autorelease_pool& { return autorelease_pool_; }
 		auto clock(this auto& self) -> auto& { return self.clock_.at(0); }
-		auto isolate() -> v8::Isolate* { return isolate_.get(); }
+		auto executor() -> auto& { return executor_; }
 		auto make_context() -> v8::Local<v8::Context>;
 		auto make_remote_handle_lock(isolate_lock_witness lock) -> remote_handle_lock;
 		auto scratch_context() -> v8::Local<v8::Context>;
@@ -137,15 +141,11 @@ export class agent_host
 
 	private:
 		friend class agent_handle;
-		using lockable_handle_type = util::lockable_with<std::shared_ptr<agent_host>, {.shared = true}>;
-
 		auto remote_expiration_callback(expired_remote_type remote) noexcept -> void;
-		static auto dispose_isolate(v8::Isolate* isolate) -> void { isolate->Dispose(); }
 
 		// Order matters for these members
 		std::shared_ptr<agent_storage> storage_;
-		std::shared_ptr<v8::ArrayBuffer::Allocator> array_buffer_allocator_;
-		std::unique_ptr<v8::Isolate, util::function_constant<dispose_isolate>> isolate_;
+		isolated::executor executor_;
 
 		// Order doesn't really matter
 		bool should_give_seed_{};
@@ -157,8 +157,9 @@ export class agent_host
 		//         /gcc-out/../gcc/gcc/cp/class.cc:9510
 		std::array<clock::any_clock, 1> clock_;
 		destroy_callback_type destroy_callback_;
-		lockable_handle_type self_handle_;
+		util::atomic_shared_ptr<agent_host> self_handle_;
 		remote_handle_list remote_handle_list_;
+		agent_handle::dispose_callback_type dispose_callback_;
 		std::array<reset_handle_type, 1> reset_handle_callback_;
 		std::atomic<unsigned> handle_count_;
 		std::optional<double> random_seed_;
@@ -195,7 +196,7 @@ auto agent_handle_of<Type>::schedule(Task task, Args... args) const -> void {
 		auto& scheduler = host->storage()->foreground_runner();
 		scheduler.schedule_client_task(
 			[](std::stop_token /*stop_token*/, const auto& host, const auto& task, auto&&... args) -> void {
-				auto isolate_lock = isolate_execution_lock{host->isolate()};
+				auto isolate_lock = isolate_execution_lock{host->executor().isolate()};
 				std::visit([](auto& clock) -> void { clock.begin_tick(); }, host->clock());
 				task(lock{isolate_lock, static_cast<agent_host_of<Type>&>(*host)}, std::forward<decltype(args)>(args)...);
 			},

package/isolated/cluster.cc

@@ -14,8 +14,9 @@ auto cluster::acquire_agent_storage() -> std::shared_ptr<agent_storage> {
 // NOLINTNEXTLINE(performance-unnecessary-value-param)
 auto cluster::release_agent_storage(std::shared_ptr<agent_storage> storage) -> void {
 	agent_storage_.write()->erase(agent_storage_list_type::s_iterator_to(*storage));
-	// I haven't seen this case yet.
-	assert(!storage->foreground_runner().scheduler().is_this_thread());
+	if (storage->foreground_runner().scheduler().is_this_thread()) {
+		destroy_(std::any{std::move(storage)});
+	}
 }
 
 } // namespace js::iv8::isolated

package/isolated/cluster.h.cc

@@ -8,16 +8,21 @@ namespace js::iv8::isolated {
 
 export class cluster {
 	public:
-		cluster() : platform_{isolated_platform::acquire()} {}
+		using synchronize_destroy = util::function_ref<auto(std::any)->void>;
+
+		explicit cluster(synchronize_destroy destroy) :
+				destroy_{destroy},
+				platform_{isolated_platform::acquire()} {}
+
 		auto make_agent(auto make_environment, behavior_params params, auto callback) -> void;
 		auto release_agent_storage(std::shared_ptr<agent_storage> storage) -> void;
 
 	private:
 		using intrusive_no_size = boost::intrusive::constant_time_size<false>;
 		using agent_storage_list_type = boost::intrusive::list<agent_storage, intrusive_no_size, agent_storage::intrusive_hook>;
-
 		auto acquire_agent_storage() -> std::shared_ptr<agent_storage>;
 
+		synchronize_destroy destroy_;
 		util::lockable<agent_storage_list_type> agent_storage_;
 		platform::platform_handle platform_;
 };
@@ -36,7 +41,7 @@ auto cluster::make_agent(auto make_environment, behavior_params params, auto cal
 			auto callback
 		) -> auto {
 			auto host = std::make_shared<agent_host_of<environment_type>>(std::move(storage), params);
-			auto isolate_lock = isolate_execution_lock{host->isolate()};
+			auto isolate_lock = isolate_execution_lock{host->executor().isolate()};
 			host->emplace_environment(util::elide{[ & ]() -> environment_type {
 				return make_environment(agent_lock{isolate_lock, *host});
 			}});

package/isolated/executor.cc

@@ -0,0 +1,31 @@
+module v8_js;
+import :isolated.agent;
+import :isolated.executor;
+import std;
+
+namespace js::iv8::isolated {
+
+auto executor::reset() -> void {
+	isolate_.reset();
+}
+
+auto executor::terminate() -> void {
+	terminated_.store(true, std::memory_order_release);
+	isolate_->TerminateExecution();
+}
+
+auto executor::is_terminated() const -> bool {
+	return terminated_.load(std::memory_order_acquire);
+}
+
+auto executor::on_before_call_entered(v8::Isolate* isolate) -> void {
+	// Checks for termination right after control has been passed to v8. This catches the case where a
+	// task is slow to start and `TerminateExecution()`, from `terminate()` is invoked on an idle
+	// isolate. In that case the termination is "handled" already.
+	auto& self = agent_host::get_current(isolate).executor();
+	if (self.is_terminated()) {
+		isolate->TerminateExecution();
+	}
+}
+
+} // namespace js::iv8::isolated

package/isolated/executor.h.cc

@@ -0,0 +1,34 @@
+export module v8_js:isolated.executor;
+import std;
+import v8;
+
+namespace js::iv8::isolated {
+
+export class executor { // "En taro adun"
+	public:
+		auto initialize(std::invocable<v8::Isolate*> auto initialize) -> void;
+		auto reset() -> void;
+		auto terminate() -> void;
+
+		[[nodiscard]] auto is_terminated() const -> bool;
+		[[nodiscard]] auto isolate() const -> v8::Isolate* { return isolate_.get(); }
+
+	private:
+		constexpr static auto dispose_isolate = [](v8::Isolate* isolate) -> void { isolate->Dispose(); };
+		static auto on_before_call_entered(v8::Isolate* isolate) -> void;
+
+		std::unique_ptr<v8::Isolate, decltype(dispose_isolate)> isolate_;
+		std::atomic<bool> terminated_;
+};
+
+// ---
+
+auto executor::initialize(std::invocable<v8::Isolate*> auto initialize) -> void {
+	static_assert(std::is_nothrow_invocable_v<decltype(initialize), v8::Isolate*>);
+	isolate_.reset(v8::Isolate::Allocate());
+	auto params = v8::Isolate::CreateParams{initialize(isolate_.get())};
+	v8::Isolate::Initialize(isolate_.get(), params);
+	isolate_->AddBeforeCallEnteredCallback(on_before_call_entered);
+}
+
+} // namespace js::iv8::isolated

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@auto_js/v8",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/v8",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/js": "^0.0.6",
-    "@auto_js/v8_exports": "^0.0.4"
+    "@auto_js/v8_exports": "^0.0.6",
+    "@auto_js/js": "^0.0.8"
   },
   "repository": {
     "type": "git",

package/platform/foreground_runner.cc

@@ -7,10 +7,7 @@ namespace js::iv8::platform {
 // `foreground_task_queue`
 foreground_task_queue::foreground_task_queue(foreground_task_queue&& other) noexcept :
 		tasks_{std::move(other.tasks_)},
-		delayed_tasks_{std::move(other.delayed_tasks_)},
-		finalized_{other.finalized_} {
-	other.finalized_ = true;
-}
+		delayed_tasks_{std::move(other.delayed_tasks_)} {}
 
 auto foreground_task_queue::flush(clock_type::time_point now) -> clock_type::time_point {
 	// nb: As far as I can tell all delayed tasks are posted with `kUserVisible`. I'm not even sure
@@ -18,32 +15,16 @@ auto foreground_task_queue::flush(clock_type::time_point now) -> clock_type::tim
 	return delayed_tasks_.flush(tasks_.at(priority_numeric_from(v8::TaskPriority::kUserVisible)), now);
 }
 
-auto foreground_task_queue::finalize() -> void {
-	finalized_ = true;
-	auto& handle_tasks = tasks_.at(priority_numeric_from(v8::TaskPriority::kUserBlocking));
-	while (!handle_tasks.empty()) {
-		auto& task = tasks_.front();
-		task(std::stop_token{});
-		tasks_.pop();
-	};
-	while (!tasks_.empty()) tasks_.pop();
-	while (!delayed_tasks_.empty()) delayed_tasks_.pop();
-}
-
 auto foreground_task_queue::front() -> task_entry_type& {
 	return std::ranges::find_if_not(tasks_.containers(), &queue_type::empty)->front();
 }
 
 auto foreground_task_queue::push_delayed(delayed_entry_type task) -> void {
-	if (!finalized_) {
-		delayed_tasks_.emplace(std::move(task));
-	}
+	delayed_tasks_.emplace(std::move(task));
 }
 
 auto foreground_task_queue::push(v8::TaskPriority priority, task_entry_type task) -> void {
-	if (!finalized_) {
-		tasks_.emplace(priority_numeric_from(priority), std::move(task));
-	}
+	tasks_.emplace(priority_numeric_from(priority), std::move(task));
 }
 
 // `foreground_runner`

package/platform/foreground_runner.h.cc

@@ -25,7 +25,6 @@ class foreground_task_queue {
 		auto operator=(foreground_task_queue&&) -> foreground_task_queue& = delete;
 
 		[[nodiscard]] auto empty() const -> bool { return tasks_.empty(); }
-		auto finalize() -> void;
 		auto flush(clock_type::time_point now) -> clock_type::time_point;
 		auto front() -> task_entry_type&;
 		auto pop() -> void { tasks_.pop(); }
@@ -35,7 +34,6 @@ class foreground_task_queue {
 	private:
 		util::segmented_priority_queue<queue_type, priority_count> tasks_;
 		delayed_queue_type delayed_tasks_;
-		bool finalized_ = false;
 };
 
 // Foreground task runner. Combines scheduler and task queue.

package/platform/task_runner.cc

@@ -6,7 +6,7 @@ using std::chrono::steady_clock;
 
 // NOTE:
 // There is nothing interesting in this file. The main thing is that `task_runner_of` automatically
-// defines `NonNestableTasksEnabled` (etc) for you based on whether or not `post_non_nestable` (etc)
+// defines `NonNestableTasksEnabled` (etc) -> for you based on whether or not `post_non_nestable` (etc)
 // is defined.
 
 namespace js::iv8::platform {

package/support/callback_storage.cc

@@ -1,3 +1,5 @@
+module;
+#include <v8_js/version.h>
 export module v8_js:callback_storage;
 import :collected_handle;
 import :unmaybe;
@@ -71,7 +73,7 @@ auto make_callback_storage(const auto& lock, auto function) {
 		static_assert(std::is_trivially_destructible_v<bound_type>);
 		if constexpr (std::is_empty_v<bound_type>) {
 			// Constant expression function of 0 size. No data needed at all!
-			auto data = v8::Local<v8::Data>{};
+			auto data = v8::Local<v8::Value>{};
 			const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
 				auto invoke = bound_type{};
 				invoke(info);
@@ -79,9 +81,22 @@ auto make_callback_storage(const auto& lock, auto function) {
 			return std::tuple{callback, data};
 		} else if constexpr (sizeof(bound_type) == sizeof(void*)) {
 			// Trivial function of pointer type. Data() is the function data.
-			auto data = v8::External::New(lock.isolate(), std::bit_cast<void*>(bound));
+			auto data = [ & ]() -> auto {
+#if V8_HAS_TAGGED_EXTERNAL
+				return v8::External::New(lock.isolate(), std::bit_cast<void*>(bound), 0);
+#else
+				return v8::External::New(lock.isolate(), std::bit_cast<void*>(bound));
+#endif
+			}();
 			const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
-				auto invoke = std::bit_cast<bound_type>(info.Data().As<v8::External>()->Value());
+				auto invoke = [ & ]() -> auto {
+#if V8_HAS_TAGGED_EXTERNAL
+					// TODO: Use this feature
+					return std::bit_cast<bound_type>(info.Data().As<v8::External>()->Value(0));
+#else
+					return std::bit_cast<bound_type>(info.Data().As<v8::External>()->Value());
+#endif
+				}();
 				invoke(info);
 			}};
 			return std::tuple{callback, data};

package/support/error.h.cc

@@ -40,24 +40,29 @@ auto externalize_caught_error(context_lock_witness lock, v8::Local<v8::Value> va
 	}
 };
 
-// Catch pending js errors and externalize them as `js::error_value`. `std::expected<T,
-// js::error_value>` is returned.
+// Catch pending js errors and externalize them as `js::error_value`.
+// `std::optional<std::expected<T, js::error_value>>` is returned. The outer optional is nullopt in
+// the case of terminating execution.
 export [[nodiscard]] auto invoke_externalized_error_scope(context_lock_witness lock, auto operation) {
 	using result_type = decltype(operation());
-	using value_type = std::expected<result_type, js::error_value>;
+	using value_type = std::optional<std::expected<result_type, js::error_value>>;
 	const auto try_catch = v8::TryCatch{lock.isolate()};
 	try {
 		if constexpr (type<result_type> == type<void>) {
 			operation();
-			return value_type{std::in_place};
+			return value_type{std::in_place, std::in_place};
 		} else {
-			return value_type{std::in_place, operation()};
+			return value_type{std::in_place, std::in_place, operation()};
 		}
 	} catch (const iv8::pending_error& /*error*/) {
 		assert(try_catch.HasCaught());
-		return value_type{std::unexpect, externalize_caught_error(lock, try_catch)};
+		if (lock.isolate()->IsExecutionTerminating()) {
+			return value_type{std::nullopt};
+		} else {
+			return value_type{std::in_place, std::unexpect, externalize_caught_error(lock, try_catch)};
+		}
 	} catch (const js::error& error) {
-		return value_type{std::unexpect, error};
+		return value_type{std::in_place, std::unexpect, error};
 	}
 }
 

package/transfer/visit.cc

@@ -486,7 +486,7 @@ struct visit<Meta, v8::FunctionCallbackInfo<v8::Value>> : visit<Meta, v8::Local<
 		using visit_type::operator();
 
 		template <class Accept>
-		auto operator()(v8::FunctionCallbackInfo<v8::Value> info, const Accept& accept) -> accept_target_t<Accept> {
+		auto operator()(const v8::FunctionCallbackInfo<v8::Value>& info, const Accept& accept) -> accept_target_t<Accept> {
 			return accept(vector_tag{}, *this, iv8::callback_info{info});
 		}
 };

package/value/fixed_array.cc

@@ -1,3 +1,5 @@
+module;
+#include <v8_js/version.h>
 module v8_js;
 import v8;
 
@@ -25,7 +27,11 @@ fixed_array::iterator::iterator(v8::Local<v8::FixedArray> array, v8::Local<v8::C
 		index_{index} {}
 
 auto fixed_array::iterator::operator*() const -> value_type {
+#if V8_HAS_CONTEXT_FREE_FIXED_ARRAY
+	return array_->Get(index_);
+#else
 	return array_->Get(context_, index_);
+#endif
 }
 
 auto fixed_array::iterator::operator+=(difference_type offset) -> iterator& {

package/value/function.cc

@@ -8,7 +8,7 @@ import v8;
 
 namespace js::iv8 {
 
-template <class Result = std::monostate>
+template <class Result>
 auto Function::apply(context_lock_witness lock, auto&& args) -> Result {
 	auto result = [ & ]() {
 		using args_type = std::vector<v8::Local<v8::Value>>;
@@ -21,7 +21,7 @@ auto Function::apply(context_lock_witness lock, auto&& args) -> Result {
 	return js::transfer_out<Result>(result, lock);
 }
 
-template <class Result = std::monostate>
+template <class Result>
 auto Function::call(context_lock_witness lock, auto&&... args) -> Result {
 	auto result = [ & ]() {
 		using args_type = std::array<v8::Local<v8::Value>, sizeof...(args) + 1>;

package/value/primitive.cc

@@ -1,3 +1,5 @@
+module;
+#include <v8_js/version.h>
 module v8_js;
 import :primitive;
 import std;
@@ -42,7 +44,7 @@ value_for_string::operator std::string() const {
 	string.resize_and_overwrite((*this)->Length(), [ this ](char* data, std::size_t length) -> std::size_t {
 		if (length > 0) {
 			auto* data_uint8 = reinterpret_cast<std::uint8_t*>(data);
-			(*this)->WriteOneByteV2(isolate(), 0, length, data_uint8, v8::String::WriteOptions::NO_NULL_TERMINATION);
+			(*this)->WriteOneByteV2(isolate(), 0, length, data_uint8, v8::String::WriteFlags::kNone);
 		}
 		return length;
 	});
@@ -54,7 +56,7 @@ value_for_string::operator std::u16string() const {
 	string.resize_and_overwrite((*this)->Length(), [ this ](char16_t* data, std::size_t length) -> std::size_t {
 		if (length > 0) {
 			auto* data_uint16 = reinterpret_cast<std::uint16_t*>(data);
-			(*this)->WriteV2(isolate(), 0, length, data_uint16, v8::String::WriteOptions::NO_NULL_TERMINATION);
+			(*this)->WriteV2(isolate(), 0, length, data_uint16, v8::String::WriteFlags::kNone);
 		}
 		return length;
 	});
@@ -68,7 +70,12 @@ value_for_date::operator js_clock::time_point() const {
 
 // `value_for_external`
 value_for_external::operator void*() const {
+#if V8_HAS_TAGGED_EXTERNAL
+	// TODO: Use this feature
+	return (*this)->Value(0);
+#else
 	return (*this)->Value();
+#endif
 }
 
 } // namespace js::iv8

package/platform/allocator.h.cc

@@ -1,22 +0,0 @@
-export module v8_js:platform.allocator;
-import std;
-import v8;
-
-namespace js::iv8::platform {
-
-class data_block_allocator : public v8::ArrayBuffer::Allocator {
-		auto Allocate(std::size_t length) -> void* final {
-			auto* data = AllocateUninitialized(length);
-			std::memset(data, 0, length);
-			return data;
-		};
-
-		auto AllocateUninitialized(std::size_t length) -> void* final { return new std::byte[ length ]; };
-
-		auto GetPageAllocator() -> v8::PageAllocator* final { return nullptr; }
-		void Free(void* data, std::size_t /*length*/) final { delete[] static_cast<std::byte*>(data); };
-
-		[[nodiscard]] auto MaxAllocationSize() const -> std::size_t final { return std::numeric_limits<std::uint32_t>::max(); }
-};
-
-} // namespace js::iv8::platform