@auto_js/v8 0.0.7 → 0.0.9

package/CMakeLists.txt

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

package/_module.cc

@@ -24,6 +24,7 @@ export import :evaluation.script;
 export import :isolated.agent;
 export import :isolated.clock;
 export import :isolated.cluster;
+export import :isolated.memory_policy;
 export import :isolated.platform;
 export import :platform.delegate;
 export import :platform.foreground_runner;

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,5 +1,5 @@
 module;
-#include <v8/version.h>
+#include <v8_js/version.h>
 export module v8_js:collected_handle;
 import :lock;
 import std;

package/handle/value_of.cc

@@ -9,9 +9,9 @@ namespace js::iv8 {
 template <class Tag>
 struct value_specialization;
 
-// nb: This corresponds to `js::napi::bound_value_of<T>`. `v8::Local<T>` is more like
-// `js::napi::value_of<T>`.
-template <class Tag>
+// nb: This corresponds to `js::napi::value_of<T>`. `v8::Local<T>` is more like
+// `js::napi::local_of<T>`.
+export template <class Tag>
 class value_of : public value_specialization<Tag>::type {
 	public:
 		using value_specialization<Tag>::type::type;
@@ -50,9 +50,13 @@ struct value_specialization<date_tag> : std::type_identity<class value_for_date>
 template <>
 struct value_specialization<external_tag> : std::type_identity<class value_for_external> {};
 
+// TODO: value_for_record
 template <>
 struct value_specialization<object_tag> : std::type_identity<class value_for_object> {};
 
+template <>
+struct value_specialization<list_tag> : std::type_identity<class value_for_object> {};
+
 template <>
 struct value_specialization<array_buffer_tag> : std::type_identity<class value_for_array_buffer> {};
 

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,28 @@ 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()},
+		memory_policy_{std::move(params.memory_policy)},
 		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);
+		v8::Isolate::CreateParams params;
+		auto memory_params = memory_policy_->make_create_params();
+		params.constraints = memory_params.constraints;
+		params.array_buffer_allocator_shared = std::move(memory_params.allocator);
+		return params;
+	});
+	auto* isolate = executor_.isolate();
+	isolate->SetCaptureStackTraceForUncaughtExceptions(true);
+	memory_policy_->initialize(isolate);
 }
 
 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 +105,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 +127,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 +140,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 +150,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,8 @@ module;
 export module v8_js:isolated.agent;
 import :collected_handle;
 import :isolated.clock;
+import :isolated.executor;
+import :isolated.memory_policy;
 import :platform.foreground_runner;
 import :remote;
 import std;
@@ -17,6 +19,7 @@ class agent_host_of;
 
 // `agent_host` behavior parameters
 export struct behavior_params {
+		memory_policy::covariant memory_policy;
 		clock::any_clock clock;
 		std::optional<double> random_seed;
 };
@@ -67,15 +70,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 +131,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 +143,12 @@ 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_;
+		isolated::memory_policy::covariant memory_policy_;
 
 		// Order doesn't really matter
 		bool should_give_seed_{};
@@ -157,8 +160,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 +199,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/isolated/memory_policy.cc

@@ -0,0 +1,49 @@
+module v8_js;
+import :isolated.memory_policy;
+
+namespace js::iv8::isolated {
+
+// memory_policy::none
+auto memory_policy::none::make_create_params() -> create_params {
+	return {
+		.allocator = std::shared_ptr<v8::ArrayBuffer::Allocator>(v8::ArrayBuffer::Allocator::NewDefaultAllocator()),
+		.constraints = {}
+	};
+}
+
+// memory_policy::limited
+auto memory_policy::limited::initialize(v8::Isolate* isolate) -> void {
+	isolate->AddNearHeapLimitCallback(
+		// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+		[](void* data, std::size_t current_heap_limit, std::size_t initial_heap_limit) -> std::size_t {
+			auto& self = *static_cast<memory_policy::limited*>(data);
+			return self.near_heap_limit_callback(current_heap_limit, initial_heap_limit);
+		},
+		this
+	);
+}
+
+auto memory_policy::limited::make_create_params() -> create_params {
+	v8::ResourceConstraints constraints{};
+	constraints.ConfigureDefaultsFromHeapSize(0, memory_limit_);
+	return {
+		.allocator = std::shared_ptr<v8::ArrayBuffer::Allocator>(v8::ArrayBuffer::Allocator::NewDefaultAllocator()),
+		.constraints = constraints,
+	};
+}
+
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+auto memory_policy::limited::near_heap_limit_callback(std::size_t current_heap_limit, std::size_t /*initial_heap_limit*/) const -> std::size_t {
+	auto* isolate = v8::Isolate::GetCurrent();
+	v8::HeapStatistics heap;
+	isolate->GetHeapStatistics(&heap);
+
+	if (current_heap_limit > memory_limit_) {
+		auto& executor = agent_host::get_current(isolate).executor();
+		executor.terminate();
+	}
+	// Increase heap limit 64mb at a time
+	return current_heap_limit + (64 << 20);
+}
+
+} // namespace js::iv8::isolated

package/isolated/memory_policy.h.cc

@@ -0,0 +1,48 @@
+export module v8_js:isolated.memory_policy;
+import std;
+import util;
+import v8;
+
+namespace js::iv8::isolated {
+
+export class memory_policy {
+	protected:
+		~memory_policy() = default;
+
+	public:
+		struct create_params;
+
+		// NOLINTNEXTLINE(cppcoreguidelines-virtual-class-destructor)
+		class none;
+		// NOLINTNEXTLINE(cppcoreguidelines-virtual-class-destructor)
+		class limited;
+
+		virtual auto initialize(v8::Isolate* isolate) -> void = 0;
+		virtual auto make_create_params() -> create_params = 0;
+		// virtual auto check_soft_limit(v8::Isolate* isolate) -> bool = 0;
+		using covariant = util::covariant_value<memory_policy, none, limited>;
+};
+
+struct memory_policy::create_params {
+		std::shared_ptr<v8::ArrayBuffer::Allocator> allocator;
+		v8::ResourceConstraints constraints;
+};
+
+class memory_policy::none final : public memory_policy {
+	public:
+		auto initialize(v8::Isolate* isolate) -> void override {};
+		auto make_create_params() -> create_params override;
+};
+
+class memory_policy::limited final : public memory_policy {
+	public:
+		explicit limited(std::size_t memory_limit_bytes) : memory_limit_{memory_limit_bytes} {}
+		auto initialize(v8::Isolate* isolate) -> void override;
+		auto make_create_params() -> create_params override;
+
+	private:
+		std::size_t memory_limit_;
+		[[nodiscard]] auto near_heap_limit_callback(std::size_t current_heap_limit, std::size_t initial_heap_limit) const -> std::size_t;
+};
+
+} // namespace js::iv8::isolated

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@auto_js/v8",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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.7",
-    "@auto_js/v8_exports": "^0.0.5"
+    "@auto_js/js": "^0.0.9",
+    "@auto_js/v8_exports": "^0.0.7"
   },
   "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,5 +1,5 @@
 module;
-#include <v8/version.h>
+#include <v8_js/version.h>
 export module v8_js:callback_storage;
 import :collected_handle;
 import :unmaybe;

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/accept.h.cc

@@ -1,5 +1,6 @@
 export module v8_js:accept;
 import :callback_storage;
+import :handle.value;
 import :hash;
 import :value;
 import auto_js;
@@ -370,6 +371,20 @@ struct accept_v8_property_value {
 		accept_value<Meta, Type> second;
 };
 
+// Forward `value_of<T>`
+template <class Tag>
+struct accept_v8_value_of {
+	public:
+		explicit accept_v8_value_of(auto* /*transfer*/) {}
+
+		auto operator()(Tag /*tag*/, visit_holder /*visit*/, value_of<Tag> subject) const -> value_of<Tag> {
+			return subject;
+		}
+
+		consteval static auto accept_tags_of() { return std::tuple{Tag{}}; }
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+};
+
 // `return_into(...)`
 struct return_into_marker {};
 
@@ -475,6 +490,12 @@ struct accept<Meta, v8::Local<Type>> : iv8::accept_v8_value_with<typename Meta::
 		using iv8::accept_v8_value_with<typename Meta::accept_context_type>::accept_v8_value_with;
 };
 
+// forward `value_of<T>`
+template <class Meta, class Tag>
+struct accept<Meta, iv8::value_of<Tag>> : iv8::accept_v8_value_of<Tag> {
+		using iv8::accept_v8_value_of<Tag>::accept_v8_value_of;
+};
+
 // templates
 template <class Meta, class Type>
 	requires std::is_convertible_v<Type, v8::Template>

package/transfer/visit.cc

@@ -380,7 +380,7 @@ struct visit_value : visit_flat_value<Target> {
 		template <class Accept>
 		auto immediate(v8::Local<v8::Array> subject, const Accept& accept) -> accept_target_t<Accept> {
 			auto visit_entry = visit_entry_pair<visit_property_name<visit_value>, visit_value&>{*this};
-			return accept(list_tag{}, visit_entry, value_of{witness(), subject.As<v8::Object>()});
+			return accept(list_tag{}, visit_entry, value_of{witness(), subject.As<v8::Array>()});
 		}
 
 		// function template
@@ -433,6 +433,40 @@ struct visit_value : visit_flat_value<Target> {
 		v8::Local<v8::Context> context_;
 };
 
+// Forward `value_of<T>` back to acceptor
+template <class Tag>
+struct visit_v8_value_of {
+	private:
+		using visit_type = visit_value<void>;
+
+	public:
+		constexpr explicit visit_v8_value_of(auto* transfer, context_lock_witness lock) : visit_{transfer, lock} {}
+
+		template <class Accept>
+		constexpr auto operator()(value_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			return accept(Tag{}, visit_, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, object_tag>
+		constexpr auto operator()(value_of<object_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_property_name<visit_type>, visit_type&>{visit_};
+			return accept(object_tag{}, visit_entry, subject);
+		}
+
+		template <class Accept>
+			requires std::is_same_v<Tag, list_tag>
+		constexpr auto operator()(value_of<list_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
+			auto visit_entry = visit_entry_pair<visit_property_name<visit_type>, visit_type&>{visit_};
+			return accept(list_tag{}, visit_entry, subject);
+		}
+
+		consteval static auto types(auto /*recursive*/) { return util::type_pack{}; }
+
+	private:
+		visit_type visit_;
+};
+
 // Template visitor needs no lock. The acceptor will instantiate values.
 struct visit_template {
 		explicit visit_template(auto* /*transfer*/) {}
@@ -467,6 +501,15 @@ struct visit<Meta, v8::Local<Type>> : iv8::visit_value_with<Meta> {
 		using iv8::visit_value_with<Meta>::visit_value_with;
 };
 
+// value_of<T> visitor
+template <class Meta, class Tag>
+struct visit<Meta, iv8::value_of<Tag>> : iv8::visit_v8_value_of<Tag> {
+		using iv8::visit_v8_value_of<Tag>::visit_v8_value_of;
+};
+
+template <class Tag>
+struct visit_subject_for<iv8::value_of<Tag>> : std::type_identity<v8::Local<v8::Value>> {};
+
 // Template visitor
 template <class Meta, class Type>
 	requires std::is_convertible_v<Type, v8::Template>

package/value/fixed_array.cc

@@ -1,5 +1,5 @@
 module;
-#include <v8/version.h>
+#include <v8_js/version.h>
 module v8_js;
 import v8;
 

package/value/primitive.cc

@@ -1,5 +1,5 @@
 module;
-#include <v8/version.h>
+#include <v8_js/version.h>
 module v8_js;
 import :primitive;
 import std;

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