@auto_js/v8 0.0.8 → 0.0.10

package/CMakeLists.txt

@@ -64,6 +64,7 @@ if(v8_js STREQUAL isolated_v8_js)
 			isolated/clock.cc
 			isolated/cluster.cc
 			isolated/executor.cc
+			isolated/memory_policy.cc
 			isolated/platform.cc
 			platform/delegate.cc
 			platform/foreground_runner.cc
@@ -76,6 +77,7 @@ if(v8_js STREQUAL isolated_v8_js)
 			isolated/clock.h.cc
 			isolated/cluster.h.cc
 			isolated/executor.h.cc
+			isolated/memory_policy.h.cc
 			isolated/platform.h.cc
 			platform/delegate.h.cc
 			platform/foreground_runner.h.cc

package/_module.cc

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

package/evaluation/module.cc

@@ -11,8 +11,8 @@ import v8;
 
 namespace js::iv8 {
 
-auto module_record::requests(context_lock_witness lock, v8::Local<v8::Module> module) -> std::vector<module_request> {
-	auto requests_array = fixed_array{lock.context(), module->GetModuleRequests()};
+auto module_record::requests(context_lock_witness lock) -> std::vector<module_request> {
+	auto requests_array = fixed_array{lock.context(), GetModuleRequests()};
 	auto requests_view =
 		requests_array |
 		std::views::transform([ & ](v8::Local<v8::Data> value) -> module_request {
@@ -38,7 +38,7 @@ auto module_record::requests(context_lock_witness lock, v8::Local<v8::Module> mo
 	return {std::from_range, std::move(requests_view)};
 }
 
-auto module_record::compile(context_lock_witness lock, v8::Local<v8::String> source_text, iv8::source_origin origin) -> expected_module_type {
+auto module_record::compile(context_lock_witness lock, v8::Local<v8::String> source_text, iv8::source_origin origin) -> v8::MaybeLocal<module_record> {
 	auto location = origin.location.value_or(source_location{});
 	auto maybe_resource_name = js::transfer_in_strict<v8::MaybeLocal<v8::String>>(std::move(origin).name, lock);
 	v8::Local<v8::String> resource_name{};
@@ -56,9 +56,7 @@ auto module_record::compile(context_lock_witness lock, v8::Local<v8::String> sou
 		true,
 	};
 	v8::ScriptCompiler::Source source{source_text, script_origin};
-	return unmaybe_one(lock, [ & ] -> v8::MaybeLocal<v8::Module> {
-		return v8::ScriptCompiler::CompileModule(lock.isolate(), &source);
-	});
+	return v8::ScriptCompiler::CompileModule(lock.isolate(), &source).As<module_record>();
 }
 
 auto module_record::create_synthetic(
@@ -66,12 +64,12 @@ auto module_record::create_synthetic(
 	v8::Local<v8::String> module_name,
 	std::span<const v8::Local<v8::String>> export_names,
 	std::span<const v8::Local<v8::Data>> export_values
-) -> v8::Local<v8::Module> {
+) -> v8::Local<module_record> {
 	thread_local std::span<const v8::Local<v8::String>>* tl_export_names;
 	thread_local std::span<const v8::Local<v8::Data>>* tl_export_values;
 	tl_export_names = &export_names;
 	tl_export_values = &export_values;
-	auto scope_exit = util::scope_exit{[ & ]() {
+	auto scope_exit = util::scope_exit{[ & ] {
 		tl_export_names = nullptr;
 		tl_export_values = nullptr;
 	}};
@@ -79,7 +77,7 @@ auto module_record::create_synthetic(
 	// Make `v8::Module` record with immediate evaluation steps
 	v8::Module::SyntheticModuleEvaluationSteps evaluation_steps =
 		[](v8::Local<v8::Context> context, v8::Local<v8::Module> module) -> v8::MaybeLocal<v8::Value> {
-		auto lock = [ & ]() -> context_lock_witness {
+		auto lock = [ & ] -> context_lock_witness {
 			auto isolate_witness = isolate_lock_witness::make_witness(v8::Isolate::GetCurrent());
 			return context_lock_witness::make_witness(isolate_witness, context);
 		}();
@@ -102,19 +100,19 @@ auto module_record::create_synthetic(
 		return resolver->GetPromise();
 	};
 	auto v8_export_names = v8::MemorySpan<const v8::Local<v8::String>>{export_names.begin(), export_names.end()};
-	auto module_record = v8::Module::CreateSyntheticModule(lock.isolate(), module_name, v8_export_names, evaluation_steps);
+	auto synthetic_module = v8::Module::CreateSyntheticModule(lock.isolate(), module_name, v8_export_names, evaluation_steps);
 
 	// "Link" the module, which is a no-op
 	// auto null_callback = v8::Module::ResolveModuleByIndexCallback{nullptr};
 	auto null_callback = v8::Module::ResolveModuleCallback{nullptr};
-	unmaybe(module_record->InstantiateModule(lock.context(), null_callback));
+	unmaybe(synthetic_module->InstantiateModule(lock.context(), null_callback));
 
 	// `Evaluate` invokes `evaluation_steps` above
-	unmaybe(module_record->Evaluate(lock.context()));
-	return module_record;
+	unmaybe(synthetic_module->Evaluate(lock.context()));
+	return synthetic_module.As<module_record>();
 }
 
-auto module_record::link(context_lock_witness lock, v8::Local<v8::Module> module, module_link_record link_record) -> void {
+auto module_record::link(context_lock_witness lock, module_link_record link_record) -> void {
 	// Initialize link state
 	auto module_specifier_map = std::unordered_map<v8::Local<v8::Module>, unsigned, address_hash>{};
 	auto module_id = 0U;
@@ -146,11 +144,13 @@ auto module_record::link(context_lock_witness lock, v8::Local<v8::Module> module
 			return (*linker_ptr)(referrer, module_request_index);
 		}
 	};
-	unmaybe(module->InstantiateModule(lock.context(), v8_callback));
+	// nb: It is strange that we need js here.
+	auto allow_js = v8::Isolate::AllowJavascriptExecutionScope{lock.isolate()};
+	unmaybe(InstantiateModule(lock.context(), v8_callback));
 	linker_ptr = nullptr;
 }
 
-auto module_record::link(context_lock_witness lock, v8::Local<v8::Module> module) -> void {
+auto module_record::link(context_lock_witness lock) -> void {
 	// Probably a synthetic module
 	auto v8_callback = v8::Module::ResolveModuleByIndexCallback{
 		[](
@@ -161,12 +161,15 @@ auto module_record::link(context_lock_witness lock, v8::Local<v8::Module> module
 			std::terminate();
 		}
 	};
-	unmaybe(module->InstantiateModule(lock.context(), v8_callback));
+	unmaybe(InstantiateModule(lock.context(), v8_callback));
 }
 
-auto module_record::evaluate(context_lock_witness lock, v8::Local<v8::Module> module) -> expected_value_type {
-	auto promise = unmaybe(module->Evaluate(lock.context())).As<v8::Promise>();
-	if (module->IsGraphAsync()) {
+auto module_record::evaluate(context_lock_witness lock) -> expected_value_type {
+	auto promise = [ & ] -> auto {
+		auto allow_js = v8::Isolate::AllowJavascriptExecutionScope{lock.isolate()};
+		return unmaybe(Evaluate(lock.context())).As<v8::Promise>();
+	}();
+	if (IsGraphAsync()) {
 		throw std::runtime_error{"Module is async"};
 	}
 	if (promise->State() == v8::Promise::kRejected) {

package/evaluation/module.h.cc

@@ -45,53 +45,52 @@ export struct module_link_record {
 };
 
 // `v8::Module` utilities
-export class module_record {
+export class module_record : public v8::Module {
 	public:
-		using expected_module_type = std::expected<v8::Local<v8::Module>, js::error_value>;
 		using expected_value_type = std::expected<std::monostate, js::error_value>;
 
-		static auto evaluate(context_lock_witness lock, v8::Local<v8::Module> module) -> expected_value_type;
-		static auto link(context_lock_witness lock, v8::Local<v8::Module> module, module_link_record link_record) -> void;
-		static auto link(context_lock_witness lock, v8::Local<v8::Module> module) -> void;
-		static auto requests(context_lock_witness lock, v8::Local<v8::Module> module) -> std::vector<module_request>;
+		auto evaluate(context_lock_witness lock) -> expected_value_type;
+		auto link(context_lock_witness lock, module_link_record link_record) -> void;
+		auto link(context_lock_witness lock) -> void;
+		auto requests(context_lock_witness lock) -> std::vector<module_request>;
 
-		static auto compile(context_lock_witness lock, auto source_text, iv8::source_origin origin) -> expected_module_type;
+		static auto compile(context_lock_witness lock, auto source_text, iv8::source_origin origin) -> v8::MaybeLocal<module_record>;
 
 		template <class... Types>
-		static auto create_synthetic(context_lock_witness lock, auto origin, std::tuple<std::in_place_t, Types...> module_interface) -> v8::Local<v8::Module>;
+		static auto create_synthetic(context_lock_witness lock, auto origin, std::tuple<std::in_place_t, Types...> module_interface) -> v8::Local<module_record>;
 
 		template <class... Types>
-		static auto create_synthetic(context_lock_witness lock, auto origin, std::tuple<Types...> module_interface) -> v8::Local<v8::Module>;
+		static auto create_synthetic(context_lock_witness lock, auto origin, std::tuple<Types...> module_interface) -> v8::Local<module_record>;
 
 		template <class Type>
-		static auto create_synthetic(context_lock_witness lock, auto origin, std::vector<Type> module_interface) -> v8::Local<v8::Module>;
+		static auto create_synthetic(context_lock_witness lock, auto origin, std::vector<Type> module_interface) -> v8::Local<module_record>;
 
 		static auto create_synthetic(
 			context_lock_witness lock,
 			v8::Local<v8::String> module_name,
 			std::span<const v8::Local<v8::String>> export_names,
 			std::span<const v8::Local<v8::Data>> export_values
-		) -> v8::Local<v8::Module>;
+		) -> v8::Local<module_record>;
 
 	private:
-		static auto compile(context_lock_witness lock, v8::Local<v8::String> source_text, iv8::source_origin origin) -> expected_module_type;
+		static auto compile(context_lock_witness lock, v8::Local<v8::String> source_text, iv8::source_origin origin) -> v8::MaybeLocal<module_record>;
 };
 
 // ---
 
-auto module_record::compile(context_lock_witness lock, auto source_text, iv8::source_origin origin) -> expected_module_type {
+auto module_record::compile(context_lock_witness lock, auto source_text, iv8::source_origin origin) -> v8::MaybeLocal<module_record> {
 	auto local_source_text = js::transfer_in_strict<v8::Local<v8::String>>(std::move(source_text), lock);
 	return compile(lock, local_source_text, std::move(origin));
 }
 
 template <class... Types>
-auto module_record::create_synthetic(context_lock_witness lock, auto origin, std::tuple<std::in_place_t, Types...> module_interface) -> v8::Local<v8::Module> {
-	auto [... ii ] = util::sequence<sizeof...(Types)>;
+auto module_record::create_synthetic(context_lock_witness lock, auto origin, std::tuple<std::in_place_t, Types...> module_interface) -> v8::Local<module_record> {
+	constexpr auto [... ii ] = util::sequence<sizeof...(Types)>;
 	return create_synthetic(lock, origin, std::tuple{std::get<ii + 1>(module_interface)...});
 }
 
 template <class... Types>
-auto module_record::create_synthetic(context_lock_witness lock, auto origin, std::tuple<Types...> module_interface) -> v8::Local<v8::Module> {
+auto module_record::create_synthetic(context_lock_witness lock, auto origin, std::tuple<Types...> module_interface) -> v8::Local<module_record> {
 	const auto& [... entries ] = module_interface;
 	auto origin_local = js::transfer_in_strict<v8::Local<v8::String>>(std::move(origin), lock);
 	auto names = js::transfer_in_strict<std::array<v8::Local<v8::String>, sizeof...(Types)>>(std::tuple{std::get<0>(entries)...}, lock);
@@ -100,7 +99,7 @@ auto module_record::create_synthetic(context_lock_witness lock, auto origin, std
 }
 
 template <class Type>
-auto module_record::create_synthetic(context_lock_witness lock, auto origin, std::vector<Type> module_interface) -> v8::Local<v8::Module> {
+auto module_record::create_synthetic(context_lock_witness lock, auto origin, std::vector<Type> module_interface) -> v8::Local<module_record> {
 	auto origin_local = js::transfer_in_strict<v8::Local<v8::String>>(std::move(origin), lock);
 	auto name_locals = std::vector<v8::Local<v8::String>>{};
 	name_locals.reserve(module_interface.size());

package/evaluation/script.cc

@@ -7,7 +7,7 @@ import v8;
 
 namespace js::iv8 {
 
-auto script::compile(context_lock_witness lock, v8::Local<v8::String> code_string, source_origin source_origin) -> expected_script_type {
+auto script::compile(context_lock_witness lock, v8::Local<v8::String> code_string, source_origin source_origin) -> v8::MaybeLocal<script> {
 	auto location = source_origin.location.value_or(source_location{});
 	auto maybe_resource_name = js::transfer_in_strict<v8::MaybeLocal<v8::String>>(std::move(source_origin).name, lock);
 	v8::Local<v8::String> resource_name{};
@@ -15,14 +15,14 @@ auto script::compile(context_lock_witness lock, v8::Local<v8::String> code_strin
 	std::ignore = maybe_resource_name.ToLocal(&resource_name);
 	v8::ScriptOrigin origin{resource_name, location.line, location.column};
 	v8::ScriptCompiler::Source source{code_string, origin};
-	return unmaybe_one(lock, [ & ] -> v8::MaybeLocal<v8::UnboundScript> {
-		return v8::ScriptCompiler::CompileUnboundScript(lock.isolate(), &source);
-	});
+	auto unbound_script = v8::ScriptCompiler::CompileUnboundScript(lock.isolate(), &source);
+	// nb: `As<script>()` doesn't work because `v8::UnboundScript` doesn't provide a `Cast` function
+	return std::bit_cast<v8::MaybeLocal<script>>(unbound_script);
 }
 
-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);
+auto script::run(context_lock_witness lock) -> v8::Local<v8::Value> {
+	auto allow_js = v8::Isolate::AllowJavascriptExecutionScope{lock.isolate()};
+	return unmaybe(BindToCurrentContext()->Run(lock.context()));
 }
 
 } // namespace js::iv8

package/evaluation/script.h.cc

@@ -7,23 +7,20 @@ import v8;
 
 namespace js::iv8 {
 
-export struct script {
+export class script : public v8::UnboundScript {
 	public:
-		using expected_script_type = std::expected<v8::Local<v8::UnboundScript>, 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) -> v8::Local<v8::Value>;
+		static auto compile(context_lock_witness lock, auto code_string, source_origin source_origin) -> v8::MaybeLocal<script>;
+		auto run(context_lock_witness lock) -> 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;
+		static auto compile(context_lock_witness lock, v8::Local<v8::String> code_string, source_origin source_origin) -> v8::MaybeLocal<script>;
 };
 
 // ---
 
-auto script::compile(context_lock_witness lock, auto code_string, source_origin source_origin) -> expected_script_type {
+auto script::compile(context_lock_witness lock, auto code_string, source_origin source_origin) -> v8::MaybeLocal<script> {
 	auto local_code_string = js::transfer_in_strict<v8::Local<v8::String>>(std::move(code_string), lock);
 	return compile(lock, local_code_string, std::move(source_origin));
 }

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

@@ -75,18 +75,22 @@ agent_host::agent_host(
 	behavior_params params
 ) :
 		storage_{std::move(storage)},
+		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} {
 	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;
+		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;
 	});
-	executor_.isolate()->SetCaptureStackTraceForUncaughtExceptions(true);
+	auto* isolate = executor_.isolate();
+	isolate->SetCaptureStackTraceForUncaughtExceptions(true);
+	memory_policy_->initialize(isolate);
 }
 
 agent_host::~agent_host() {

package/isolated/agent.h.cc

@@ -4,6 +4,7 @@ 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;
@@ -18,6 +19,7 @@ class agent_host_of;
 
 // `agent_host` behavior parameters
 export struct behavior_params {
+		isolated::memory_policy::covariant memory_policy;
 		clock::any_clock clock;
 		std::optional<double> random_seed;
 };
@@ -146,6 +148,7 @@ export class agent_host
 		// Order matters for these members
 		std::shared_ptr<agent_storage> storage_;
 		isolated::executor executor_;
+		isolated::memory_policy::covariant memory_policy_;
 
 		// Order doesn't really matter
 		bool should_give_seed_{};
@@ -198,6 +201,9 @@ auto agent_handle_of<Type>::schedule(Task task, Args... args) const -> void {
 			[](std::stop_token /*stop_token*/, const auto& host, const auto& task, auto&&... args) -> void {
 				auto isolate_lock = isolate_execution_lock{host->executor().isolate()};
 				std::visit([](auto& clock) -> void { clock.begin_tick(); }, host->clock());
+				// By default we disallow code execution except when explicitly annotated
+				auto disallow_js =
+					v8::Isolate::DisallowJavascriptExecutionScope{isolate_lock.isolate(), v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE};
 				task(lock{isolate_lock, static_cast<agent_host_of<Type>&>(*host)}, std::forward<decltype(args)>(args)...);
 			},
 			std::move(host),

package/isolated/cluster.h.cc

@@ -42,7 +42,7 @@ auto cluster::make_agent(auto make_environment, behavior_params params, auto cal
 		) -> auto {
 			auto host = std::make_shared<agent_host_of<environment_type>>(std::move(storage), params);
 			auto isolate_lock = isolate_execution_lock{host->executor().isolate()};
-			host->emplace_environment(util::elide{[ & ]() -> environment_type {
+			host->emplace_environment(util::elide{[ & ] -> environment_type {
 				return make_environment(agent_lock{isolate_lock, *host});
 			}});
 			auto lock = agent_lock_of{isolate_lock, *host};

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 80mb at a time. Experimentally derived.
+	return current_heap_limit + (80 << 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.8",
+  "version": "0.0.10",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/v8",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/v8_exports": "^0.0.6",
-    "@auto_js/js": "^0.0.8"
+    "@auto_js/js": "^0.0.10",
+    "@auto_js/v8_exports": "^0.0.8"
   },
   "repository": {
     "type": "git",

package/platform/delegate.cc

@@ -15,7 +15,7 @@ struct platform_instance_handle {
 util::lockable<platform_instance_handle> shared_platform;
 
 platform_handle::platform_handle(const std::type_info& type, make_type* make) :
-		platform_{util::elide{[ & ]() -> std::shared_ptr<v8::Platform> {
+		platform_{util::elide{[ & ] -> std::shared_ptr<v8::Platform> {
 			auto lock = shared_platform.write();
 			auto acquired_platform = lock->platform.lock();
 			if (acquired_platform) {

package/platform/delegate.h.cc

@@ -83,7 +83,7 @@ export class instrumentation_delegate : virtual public v8::Platform {
 
 template <class Delegate>
 auto platform_handle::acquire() -> platform_handle {
-	constexpr auto make = []() -> std::shared_ptr<v8::Platform> {
+	constexpr auto make = [] -> std::shared_ptr<v8::Platform> {
 		return std::make_shared<Delegate>();
 	};
 	return platform_handle{typeid(Delegate), make};

package/platform/foreground_runner.cc

@@ -35,13 +35,13 @@ auto foreground_runner::terminate() -> void {
 auto foreground_runner::get_for_priority(std::shared_ptr<foreground_runner> self, v8::TaskPriority priority) -> std::shared_ptr<v8::TaskRunner> {
 	return util::template_switch(
 		priority_numeric_from(priority),
-		util::sequence<priority_count>,
+		util::sequence_cw<priority_count>,
 		util::overloaded{
 			[ & ](auto priority) -> std::shared_ptr<v8::TaskRunner> {
 				using priority_runner_of = foreground_runner_of_priority<priority_enum_from(priority)>;
 				return std::static_pointer_cast<priority_runner_of>(std::move(self));
 			},
-			[]() -> std::shared_ptr<v8::TaskRunner> {
+			[] -> std::shared_ptr<v8::TaskRunner> {
 				throw std::logic_error{"Invalid 'foreground_runner' priority"};
 			},
 		}

package/platform/scheduler.cc

@@ -138,7 +138,7 @@ auto scheduler_foreground_thread::controller::run(
 	});
 	const auto any_stop_token = util::composite_stop_token{std::move(stop_token), termination_stop_token};
 	while (!any_stop_token.stop_requested()) {
-		auto [... timeout ] = [ & ]() -> auto {
+		auto [... timeout ] = [ & ] -> auto {
 			if constexpr (requires { typename queue_type::clock_type; }) {
 				return std::tuple{lock->queue.flush(queue_type::clock_type::now())};
 			} else {
@@ -192,7 +192,7 @@ auto scheduler_background_threads::controller::run(
 	});
 	const auto any_stop_token = util::composite_stop_token{std::move(stop_token), termination_stop_token};
 	while (!any_stop_token.stop_requested()) {
-		auto [... timeout ] = [ & ]() -> auto {
+		auto [... timeout ] = [ & ] -> auto {
 			if constexpr (requires { typename queue_type::clock_type; }) {
 				return std::tuple{lock->queue.flush(queue_type::clock_type::now())};
 			} else {

package/platform/task.cc

@@ -43,7 +43,7 @@ class task_of final : public v8::Task {
 
 template <class... Args>
 auto make_task_of(std::invocable<std::stop_token, Args...> auto callback, Args&&... args) -> std::unique_ptr<v8::Task> {
-	auto task = [ & ]() -> auto {
+	auto task = [ & ] -> auto {
 		if constexpr (sizeof...(Args) == 0) {
 			return std::move(callback);
 		} else {

package/support/callback.cc

@@ -29,8 +29,8 @@ constexpr auto make_free_function_with_try_catch =
 	auto bound_function = util::bind{
 		[](callback_type& callback, Lock lock, const v8::FunctionCallbackInfo<v8::Value>& info) noexcept(Nx) -> void {
 			// NOLINTNEXTLINE(cppcoreguidelines-slicing)
-			auto result = invoke_internal_error_scope(lock, [ & ]() -> auto {
-				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+			auto result = invoke_internal_error_scope(lock, [ & ] -> auto {
+				auto run = util::regular_return{[ & ] -> decltype(auto) {
 					return std::apply(
 						callback,
 						std::tuple_cat(
@@ -61,7 +61,7 @@ constexpr auto make_free_function_noexcept =
 	using callback_type = decltype(callback);
 	auto bound_function = util::bind{
 		[](callback_type& callback, Lock lock, const v8::FunctionCallbackInfo<v8::Value>& /*info*/) noexcept -> void {
-			auto run = util::regular_return{[ & ]() -> decltype(auto) {
+			auto run = util::regular_return{[ & ] -> decltype(auto) {
 				return callback(lock);
 			}};
 			return js::transfer_in_strict<v8::Local<v8::Value>>(run().value_or(std::monostate{}), lock);

package/support/callback_storage.cc

@@ -81,7 +81,7 @@ 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 = [ & ]() -> auto {
+			auto data = [ & ] -> auto {
 #if V8_HAS_TAGGED_EXTERNAL
 				return v8::External::New(lock.isolate(), std::bit_cast<void*>(bound), 0);
 #else
@@ -89,7 +89,7 @@ auto make_callback_storage(const auto& lock, auto function) {
 #endif
 			}();
 			const auto callback = v8::FunctionCallback{[](const v8::FunctionCallbackInfo<v8::Value>& info) -> void {
-				auto invoke = [ & ]() -> auto {
+				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));

package/support/error.h.cc

@@ -17,7 +17,7 @@ auto externalize_caught_error(context_lock_witness lock, v8::Local<v8::Value> va
 // Catch `iv8::pending_error` or `js::error`, converting to thrown v8 runtime error.
 [[nodiscard]] auto invoke_internal_error_scope(context_lock_witness lock, auto operation) {
 	using result_type = std::invoke_result_t<decltype(operation)>;
-	using value_type = type_t<[]() {
+	using value_type = type_t<[] {
 		if constexpr (type<result_type> == type<void>) {
 			return type<bool>;
 		} else {

package/transfer/accept.cc

@@ -89,7 +89,7 @@ auto accept_v8_value::operator()(date_tag /*tag*/, visit_holder /*visit*/, js_cl
 auto accept_v8_value::operator()(error_tag /*tag*/, visit_holder /*visit*/, const js::error_value& subject) const
 	-> js::referenceable_value<v8::Local<v8::Object>> {
 	auto message = js::transfer_in<v8::Local<v8::String>>(subject.message(), witness());
-	auto error = v8::Local<v8::Value>{[ & ]() -> v8::Local<v8::Value> {
+	auto error = v8::Local<v8::Value>{[ & ] -> v8::Local<v8::Value> {
 		switch (subject.name()) {
 			// These functions don't need an isolate somehow?
 			default:
@@ -131,7 +131,7 @@ auto accept_v8_value::operator()(array_buffer_tag /*tag*/, visit_holder /*visit*
 auto accept_v8_value::operator()(shared_array_buffer_tag /*tag*/, visit_holder /*visit*/, js::shared_array_buffer&& subject) const
 	-> js::referenceable_value<v8::Local<v8::SharedArrayBuffer>> {
 	auto byte_length = subject.byte_length();
-	auto backing_store = [ & ]() -> auto {
+	auto backing_store = [ & ] -> auto {
 		if (byte_length == 0) {
 			// v8 does not call the deleter if `byte_length` is zero. So the heap-allocated shared_ptr
 			// trick does not work in that case.

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;
@@ -15,10 +16,10 @@ constexpr auto make_free_function(auto function);
 
 // Reference acceptor
 struct reaccept_v8_value {
-		using reference_type = v8::Local<v8::Value>;
+		using reference_type = v8::Local<v8::Data>;
 
 		template <class Type>
-		constexpr auto operator()(std::type_identity<v8::Local<Type>> /*type*/, v8::Local<v8::Value> subject) const -> v8::Local<Type> {
+		constexpr auto operator()(std::type_identity<v8::Local<Type>> /*type*/, v8::Local<v8::Data> subject) const -> v8::Local<Type> {
 			return subject.As<Type>();
 		}
 };
@@ -62,6 +63,12 @@ struct accept_v8_primitive {
 			return (*this)(number_tag_of<double>{}, visit, double{std::forward<decltype(subject)>(subject)});
 		}
 
+		template <class Type>
+		auto operator()(number_tag_of<Type> tag, visit_holder visit, Type subject) const -> v8::Local<tag_to_v8<number_tag_of<Type>>> {
+			auto value = (*this)(tag, visit, std::int32_t{std::forward<decltype(subject)>(subject)});
+			return v8::Local<v8::Int32>{value}.As<tag_to_v8<number_tag_of<Type>>>();
+		}
+
 		template <class Type>
 		auto operator()(number_tag_of<Type> tag, visit_holder visit, auto&& subject) const -> v8::Local<tag_to_v8<number_tag_of<Type>>> {
 			return (*this)(tag, visit, Type{std::forward<decltype(subject)>(subject)});
@@ -166,12 +173,10 @@ struct accept_v8_value : accept_v8_primitive {
 				[](v8::Local<v8::Array> array, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
 					for (auto&& [ key, value ] : util::forward_range(std::forward<decltype(range)>(range))) {
-						auto result = array->Set(
-							self.context_,
-							visit.first(std::forward<decltype(key)>(key), self),
-							visit.second(std::forward<decltype(value)>(value), self)
-						);
-						unmaybe(result);
+						// nb: 'first' must run before 'second'
+						auto name = visit.first(std::forward<decltype(key)>(key), self);
+						auto item = visit.second(std::forward<decltype(value)>(value), self);
+						unmaybe(array->Set(self.context_, name, item));
 					}
 				},
 			};
@@ -202,8 +207,8 @@ struct accept_v8_value : accept_v8_primitive {
 				v8::Array::New(self.isolate(), Size),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
 				[](v8::Local<v8::Array> array, auto& self, auto& visit, auto /*&&*/ tuple) -> void {
-					const auto [... indices ] = util::sequence<Size>;
-					(..., [ & ]() -> void {
+					constexpr auto [... indices ] = util::sequence<Size>;
+					(..., [ & ] -> void {
 						auto element = visit(indices, std::forward<decltype(tuple)>(tuple), self);
 						unmaybe(array->Set(self.context_, indices, element));
 					}());
@@ -220,12 +225,10 @@ struct accept_v8_value : accept_v8_primitive {
 				[](v8::Local<v8::Object> object, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
 					for (auto&& [ key, value ] : util::forward_range(std::forward<decltype(range)>(range))) {
-						auto result = object->Set(
-							self.context_,
-							visit.first(std::forward<decltype(key)>(key), self),
-							visit.second(std::forward<decltype(value)>(value), self)
-						);
-						unmaybe(result);
+						// nb: 'first' must run before 'second'
+						auto name = visit.first(std::forward<decltype(key)>(key), self);
+						auto item = visit.second(std::forward<decltype(value)>(value), self);
+						unmaybe(object->Set(self.context_, name, item));
 					}
 				},
 			};
@@ -280,8 +283,8 @@ struct accept_v8_value : accept_v8_primitive {
 
 		template <std::size_t Size>
 		auto accept_entry_pair_struct(this const auto& self, auto& visit, v8::Local<v8::Object> target, auto&& subject) -> void {
-			const auto [... indices ] = util::sequence<Size>;
-			(..., [ & ]() -> void {
+			constexpr auto [... indices ] = util::sequence<Size>;
+			(..., [ & ] -> void {
 				auto accept_entry = accept_entry_pair<decltype(self), decltype(self)>{self};
 				auto entry = visit(std::integral_constant<std::size_t, indices>{}, std::forward<decltype(subject)>(subject), accept_entry);
 				unmaybe(target->Set(self.context_, entry.first, entry.second));
@@ -292,44 +295,56 @@ struct accept_v8_value : accept_v8_primitive {
 		v8::Local<v8::Context> context_;
 };
 
-// `accept_v8_value` subclass, implementing specialized acceptor with lock type.
+// Lock delegate for `accept_v8_value_with`. In the `context_lock_witness` case, `accept_v8_value`
+// holds that lock by type. If the lock is more specialized we need to hold another reference.
 template <class Lock>
-struct accept_v8_value_with;
+struct accept_v8_value_lock_delegate;
 
 template <>
-struct accept_v8_value_with<context_lock_witness> : accept_v8_value {
+struct accept_v8_value_lock_delegate<context_lock_witness> : accept_v8_value {
 		using accept_v8_value::accept_v8_value;
-		using accept_v8_value::operator();
-		using accept_v8_value::witness;
-
-		// function instantiation
-		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<iv8::Function> {
-			auto [ function, length ] = make_free_function<context_lock_witness>(std::move(subject).callback);
-			auto [ callback, data ] = make_callback_storage(witness(), std::move(function));
-			return unmaybe(v8::Function::New(witness().context(), callback, data, length, v8::ConstructorBehavior::kThrow).template As<iv8::Function>());
-		}
 };
 
 template <class Lock>
-struct accept_v8_value_with : accept_v8_value {
+struct accept_v8_value_lock_delegate : accept_v8_value {
 	public:
-		accept_v8_value_with(auto* transfer, const Lock& lock) :
+		accept_v8_value_lock_delegate(auto* transfer, const Lock& lock) :
 				accept_v8_value{transfer, lock},
 				lock_{lock} {}
 
-		using accept_v8_value::operator();
-
-		// function instantiation
-		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<iv8::Function> {
-			auto [ function, length ] = make_free_function<Lock>(std::move(subject).callback);
-			auto [ callback, data ] = make_callback_storage(lock_.get(), std::move(function));
-			return v8::Function::New(lock_.get().context(), callback, data, length, v8::ConstructorBehavior::kThrow);
-		}
+		[[nodiscard]] auto witness() const -> const Lock& { return lock_; }
 
 	private:
 		std::reference_wrapper<const Lock> lock_;
 };
 
+// `accept_v8_value` subclass, implementing specialized acceptor with lock type.
+template <class Lock>
+struct accept_v8_value_with : accept_v8_value_lock_delegate<Lock> {
+		using accept_v8_value_lock_delegate<Lock>::accept_v8_value_lock_delegate;
+		using accept_v8_value_lock_delegate<Lock>::operator();
+		using accept_v8_value_lock_delegate<Lock>::witness;
+
+		// object template instantiation
+		auto operator()(object_prototype_tag /*tag*/, visit_holder /*visit*/, v8::Local<v8::ObjectTemplate> subject) const -> v8::Local<v8::Object> {
+			return unmaybe(subject->NewInstance(witness().context()));
+		}
+
+		// function instantiation (from template)
+		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, v8::Local<v8::FunctionTemplate> subject) const -> v8::Local<iv8::Function> {
+			auto fn = unmaybe(subject->GetFunction(witness().context()));
+			return v8::Local<v8::Function>{fn}.As<iv8::Function>();
+		}
+
+		// function instantiation (from native type)
+		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<iv8::Function> {
+			auto [ function, length ] = make_free_function<context_lock_witness>(std::move(subject).callback);
+			auto [ callback, data ] = make_callback_storage(witness(), std::move(function));
+			auto fn = unmaybe(v8::Function::New(witness().context(), callback, data, length, v8::ConstructorBehavior::kThrow));
+			return v8::Local<v8::Function>{fn}.As<iv8::Function>();
+		}
+};
+
 // Acceptor with template environment
 template <class Meta, class Lock>
 struct accept_v8_template : accept_v8_primitive {
@@ -338,6 +353,36 @@ struct accept_v8_template : accept_v8_primitive {
 				accept_v8_primitive{transfer, lock},
 				lock_{lock} {}
 
+		// cast primitive to prototype
+		template <std::convertible_to<primitive_tag> Tag>
+		auto operator()(Tag tag, auto& visit, auto&& subject) const -> v8::Local<v8::Template>
+			// refuse on bigint, which requires a context for some reason.
+			requires(!std::convertible_to<Tag, bigint_tag>) {
+			const accept_v8_primitive& accept = *this;
+			auto result = accept(tag, visit, std::forward<decltype(subject)>(subject));
+			auto value = v8::Local<v8::Value>{dispatch_referenceable(result)};
+			// nb: We are smuggling a `v8::Primitive` as a `v8::Template`
+			return std::bit_cast<v8::Local<v8::Template>>(value);
+		}
+
+		// object
+		auto operator()(this const auto& self, dictionary_tag /*tag*/, auto& visit, auto&& subject)
+			-> js::deferred_receiver<v8::Local<v8::ObjectTemplate>, decltype(self), decltype(visit), decltype(subject)> {
+			return {
+				v8::ObjectTemplate::New(self.isolate()),
+				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
+				[](v8::Local<v8::ObjectTemplate> object, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
+					for (auto&& [ key, value ] : util::forward_range(std::forward<decltype(range)>(range))) {
+						// nb: 'first' must run before 'second'
+						auto name = v8::Local<v8::Template>{visit.first(std::forward<decltype(key)>(key), self)};
+						auto item = visit.second(std::forward<decltype(value)>(value), self);
+						object->Set(name.As<v8::Name>(), item);
+					}
+				},
+			};
+		}
+
 		// function template
 		auto operator()(function_prototype_tag /*tag*/, visit_holder /*visit*/, auto subject) const -> v8::Local<v8::FunctionTemplate> {
 			auto [ function, length ] = make_free_function<Lock>(std::move(subject).callback);
@@ -370,6 +415,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 +534,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

@@ -25,7 +25,7 @@ struct visit_property_name {
 
 		template <class Accept>
 		auto operator()(v8::Local<v8::Primitive> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return visit_.get().lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return visit_.get().lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				auto accept_as = [ & ]<class Tag>(Tag tag) -> auto {
 					auto value = value_of{witness(), subject.As<tag_to_v8<Tag>>()};
 					return accept(tag, *this, value);
@@ -80,7 +80,7 @@ struct visit_cached_immediate : Visit {
 		auto operator()(auto subject, const Accept& accept) -> accept_target_t<Accept>
 			// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124954
 			requires requires { this->immediate(subject, accept); } {
-			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				return immediate(subject, accept);
 			});
 		}
@@ -276,7 +276,7 @@ struct visit_value : visit_flat_value<Target> {
 		auto operator()(v8::Local<v8::Value> subject, const Accept& accept) -> accept_target_t<Accept> {
 
 			// Check the reference map, and check type
-			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				return util::template_traverse(
 					accept_tags_of_v<Accept>,
 					util::overloaded{
@@ -313,7 +313,7 @@ struct visit_value : visit_flat_value<Target> {
 						[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
 
 						// Slow path
-						[ & ]() -> accept_target_t<Accept> {
+						[ & ] -> accept_target_t<Accept> {
 							if (subject->IsObject()) {
 								return immediate(subject.As<v8::Object>(), accept);
 							} else {
@@ -327,7 +327,7 @@ struct visit_value : visit_flat_value<Target> {
 
 		template <class Accept>
 		auto operator()(v8::Local<iv8::DataBlock> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				return util::template_traverse(
 					accept_tags_of_v<Accept>,
 					util::overloaded{
@@ -337,7 +337,7 @@ struct visit_value : visit_flat_value<Target> {
 						[ & ](shared_array_buffer_tag /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
 
 						// Slow path
-						[ & ]() -> accept_target_t<Accept> {
+						[ & ] -> accept_target_t<Accept> {
 							return immediate(subject, accept);
 						}
 					}
@@ -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,10 +433,55 @@ 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*/) {}
 
+		template <class Accept>
+		auto operator()(v8::Local<v8::Template> subject, const Accept& accept) const -> accept_target_t<Accept> {
+			if (subject->IsFunctionTemplate()) {
+				return (*this)(subject.As<v8::FunctionTemplate>(), accept);
+			} else if (subject->IsObjectTemplate()) {
+				return (*this)(subject.As<v8::ObjectTemplate>(), accept);
+			} else {
+				return accept_target_t<Accept>{subject};
+			}
+		}
+
 		template <class Accept>
 		auto operator()(v8::Local<v8::FunctionTemplate> subject, const Accept& accept) const -> accept_target_t<Accept> {
 			return accept(function_prototype_tag{}, *this, subject);
@@ -467,6 +512,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/function.cc

@@ -10,11 +10,12 @@ namespace js::iv8 {
 
 template <class Result>
 auto Function::apply(context_lock_witness lock, auto&& args) -> Result {
-	auto result = [ & ]() {
+	auto result = [ & ] {
 		using args_type = std::vector<v8::Local<v8::Value>>;
 		auto handle_scope = v8::EscapableHandleScope{lock.isolate()};
 		auto undefined = js::transfer_in_strict<v8::Local<v8::Value>>(std::monostate{}, lock);
 		auto argv = js::transfer_in_strict<args_type>(std::forward<decltype(args)>(args), lock);
+		auto allow_js = v8::Isolate::AllowJavascriptExecutionScope{lock.isolate()};
 		auto result = unmaybe(v8::Function::Call(lock.context(), undefined, argv.size(), argv.data()));
 		return handle_scope.Escape(result);
 	}();
@@ -23,7 +24,7 @@ auto Function::apply(context_lock_witness lock, auto&& args) -> Result {
 
 template <class Result>
 auto Function::call(context_lock_witness lock, auto&&... args) -> Result {
-	auto result = [ & ]() {
+	auto result = [ & ] {
 		using args_type = std::array<v8::Local<v8::Value>, sizeof...(args) + 1>;
 		auto handle_scope = v8::EscapableHandleScope{lock.isolate()};
 		auto argv = js::transfer_in_strict<args_type>(
@@ -33,6 +34,7 @@ auto Function::call(context_lock_witness lock, auto&&... args) -> Result {
 			),
 			lock
 		);
+		auto allow_js = v8::Isolate::AllowJavascriptExecutionScope{lock.isolate()};
 		return handle_scope.Escape(unmaybe(v8::Function::Call(lock.context(), argv[ 0 ], argv.size() - 1, argv.data() + 1)));
 	}();
 	return js::transfer_out<Result>(result, lock);