@nocobase/plugin-workflow-javascript 2.1.0-beta.11 → 2.1.0-beta.13

package/dist/node_modules/isolated-vm/src/isolate/environment.cc

@@ -0,0 +1,626 @@
+#include "environment.h"
+#include "allocator.h"
+#include "inspector.h"
+#include "isolate/cpu_profile_manager.h"
+#include "isolate/generic/error.h"
+#include "platform_delegate.h"
+#include "runnable.h"
+#include "external_copy/external_copy.h"
+#include "scheduler.h"
+#include "lib/suspend.h"
+#include <algorithm>
+#include <chrono>
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include "v8-platform.h"
+#include "v8.h"
+
+#if USE_CLOCK_THREAD_CPUTIME_ID
+#include <time.h>
+#endif
+
+#if defined __APPLE__
+#include <pthread.h>
+static auto GetStackBase() -> void* {
+	pthread_t self = pthread_self();
+	return (void*)((char*)pthread_get_stackaddr_np(self) - pthread_get_stacksize_np(self));
+}
+#elif defined __OpenBSD__
+#include <pthread_np.h>
+static auto GetStackBase() -> void* {
+        pthread_t self = pthread_self();
+        stack_t ss;
+        void* base = nullptr;
+        if (pthread_stackseg_np(self, &ss) == 0) {
+                base = (void*)((char*)ss.ss_sp - ss.ss_size);
+        }
+	return base;
+#elif defined __FreeBSD__
+#include <pthread_np.h>
+static auto GetStackBase() -> void* {
+  pthread_t self = pthread_self();
+  pthread_attr_t attrs;
+  void* base = nullptr;
+  if (pthread_attr_init(&attrs) == 0) {
+    pthread_attr_get_np(self, &attrs);
+    size_t size;
+    pthread_attr_getstack(&attrs, &base, &size);
+    pthread_attr_destroy(&attrs);
+  }
+  return base;
+}
+#elif defined __unix__
+static auto GetStackBase() -> void* {
+	pthread_t self = pthread_self();
+	pthread_attr_t attrs;
+	pthread_getattr_np(self, &attrs);
+	void* base;
+	size_t size;
+	pthread_attr_getstack(&attrs, &base, &size);
+	return base;
+}
+#else
+static void* GetStackBase() {
+	return nullptr;
+}
+#endif
+
+using namespace v8;
+using std::shared_ptr;
+using std::unique_ptr;
+
+namespace ivm {
+
+std::atomic<size_t> detail::IsolateSpecificSize{0};
+thread_suspend_handle::initialize suspend_init{};
+
+namespace {
+	std::mutex isolate_allocator_mutex{};
+} // anonymous namespace
+
+/**
+ * HeapCheck implementation
+ */
+IsolateEnvironment::HeapCheck::HeapCheck(IsolateEnvironment& env, bool force) :
+		env{env}, extra_size_before{env.extra_allocated_memory}, force{force} {
+}
+
+void IsolateEnvironment::HeapCheck::Epilogue() {
+	if (!env.nodejs_isolate && (force || env.extra_allocated_memory != extra_size_before)) {
+		Isolate* isolate = env.GetIsolate();
+		HeapStatistics heap;
+		isolate->GetHeapStatistics(&heap);
+		if (heap.used_heap_size() + env.extra_allocated_memory > env.memory_limit) {
+			isolate->LowMemoryNotification();
+			isolate->GetHeapStatistics(&heap);
+			if (heap.used_heap_size() + env.extra_allocated_memory > env.memory_limit) {
+				env.hit_memory_limit = true;
+				env.Terminate();
+				throw FatalRuntimeError("Isolate was disposed during execution due to memory limit");
+			}
+		}
+	}
+}
+
+/**
+ * IsolateEnvironment implementation
+ */
+void IsolateEnvironment::OOMErrorCallback(const char* location, bool is_heap_oom) {
+	if (RaiseCatastrophicError(IsolateEnvironment::GetCurrent().error_handler, "Catastrophic out-of-memory error")) {
+		while (true) {
+			using namespace std::chrono_literals;
+			std::this_thread::sleep_for(100s);
+		}
+	}
+	fprintf(stderr, "%s\nis_heap_oom = %d\n\n\n", location, static_cast<int>(is_heap_oom));
+	HeapStatistics heap;
+	Isolate::GetCurrent()->GetHeapStatistics(&heap);
+	fprintf(stderr,
+		"<--- Heap statistics --->\n"
+		"total_heap_size = %zd\n"
+		"total_heap_size_executable = %zd\n"
+		"total_physical_size = %zd\n"
+		"total_available_size = %zd\n"
+		"used_heap_size = %zd\n"
+		"heap_size_limit = %zd\n"
+		"malloced_memory = %zd\n"
+		"peak_malloced_memory = %zd\n"
+		"does_zap_garbage = %zd\n",
+		heap.total_heap_size(),
+		heap.total_heap_size_executable(),
+		heap.total_physical_size(),
+		heap.total_available_size(),
+		heap.used_heap_size(),
+		heap.heap_size_limit(),
+		heap.malloced_memory(),
+		heap.peak_malloced_memory(),
+		heap.does_zap_garbage()
+	);
+	abort();
+}
+
+void IsolateEnvironment::PromiseRejectCallback(PromiseRejectMessage rejection) {
+	auto& that = IsolateEnvironment::GetCurrent();
+	assert(that.isolate == Isolate::GetCurrent());
+	// TODO: Revisit this in version 4.x?
+	auto event = rejection.GetEvent();
+	if (event == kPromiseRejectWithNoHandler) {
+		that.unhandled_promise_rejections.emplace_back(that.isolate, rejection.GetPromise());
+		that.unhandled_promise_rejections.back().SetWeak();
+	} else if (event == kPromiseHandlerAddedAfterReject) {
+		that.PromiseWasHandled(rejection.GetPromise());
+	}
+}
+
+void IsolateEnvironment::PromiseWasHandled(v8::Local<v8::Promise> promise) {
+	for (auto& handle : unhandled_promise_rejections) {
+		if (handle == promise) {
+			handle.Reset();
+		}
+	}
+}
+
+auto IsolateEnvironment::CodeGenCallback(Local<Context> /*context*/, Local<Value> source) -> ModifyCodeGenerationFromStringsResult {
+	auto& that = IsolateEnvironment::GetCurrent();
+	// This heuristic could be improved by looking up how much `timeout` this isolate has left and
+	// returning early in some cases
+	ModifyCodeGenerationFromStringsResult result;
+	if (source->IsString() && static_cast<size_t>(source.As<String>()->Length()) > static_cast<size_t>(that.memory_limit / 8)) {
+		return result;
+	}
+	result.codegen_allowed = true;
+	return result;
+}
+
+auto IsolateEnvironment::CodeGenCallback2(Local<Context> context, Local<Value> source, bool) -> ModifyCodeGenerationFromStringsResult {
+	return CodeGenCallback(context, source);
+}
+
+void IsolateEnvironment::MarkSweepCompactEpilogue(Isolate* isolate, GCType /*gc_type*/, GCCallbackFlags gc_flags, void* data) {
+	auto* that = static_cast<IsolateEnvironment*>(data);
+	HeapStatistics heap;
+	that->isolate->GetHeapStatistics(&heap);
+	size_t total_memory = heap.used_heap_size() + that->extra_allocated_memory;
+	size_t memory_limit = that->memory_limit + that->misc_memory_size;
+	if (total_memory > memory_limit) {
+		if ((gc_flags & (GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage | GCCallbackFlags::kGCCallbackFlagForced)) == 0) {
+			// Force full garbage collection
+			that->RequestMemoryPressureNotification(MemoryPressureLevel::kCritical);
+		} else {
+			that->Terminate();
+			that->hit_memory_limit = true;
+		}
+	} else if ((gc_flags & GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage) == 0) {
+		if (that->did_adjust_heap_limit) {
+			// There is also `AutomaticallyRestoreInitialHeapLimit` introduced in v8 7.3.411 / 93283bf04
+			// but it seems less effective than this ratcheting strategy.
+			isolate->RemoveNearHeapLimitCallback(NearHeapLimitCallback, that->memory_limit);
+			isolate->AddNearHeapLimitCallback(NearHeapLimitCallback, data);
+			HeapStatistics heap;
+			that->isolate->GetHeapStatistics(&heap);
+			if (heap.heap_size_limit() == that->initial_heap_size_limit) {
+				that->did_adjust_heap_limit = false;
+			}
+		}
+		if (total_memory + total_memory / 4 > memory_limit) {
+			// Send "moderate" pressure at 80%
+			that->RequestMemoryPressureNotification(MemoryPressureLevel::kModerate);
+		} else {
+			that->RequestMemoryPressureNotification(MemoryPressureLevel::kNone);
+		}
+		return;
+	}
+}
+
+auto IsolateEnvironment::NearHeapLimitCallback(void* data, size_t current_heap_limit, size_t /*initial_heap_limit*/) -> size_t {
+	// This callback will temporarily give the v8 vm up to an extra 1 GB of memory to prevent the
+	// application from crashing.
+	auto* that = static_cast<IsolateEnvironment*>(data);
+	that->did_adjust_heap_limit = true;
+	HeapStatistics heap;
+	that->isolate->GetHeapStatistics(&heap);
+	if (heap.used_heap_size() + that->extra_allocated_memory > that->memory_limit + that->misc_memory_size) {
+		that->RequestMemoryPressureNotification(MemoryPressureLevel::kCritical, true);
+	} else {
+		that->RequestMemoryPressureNotification(MemoryPressureLevel::kModerate, true);
+	}
+	return current_heap_limit + 1024 * 1024 * 1024;
+}
+
+void IsolateEnvironment::RequestMemoryPressureNotification(MemoryPressureLevel memory_pressure, bool as_interrupt) {
+	this->memory_pressure = memory_pressure;
+	if (as_interrupt) {
+		if (memory_pressure > last_memory_pressure) {
+			isolate->RequestInterrupt(MemoryPressureInterrupt, static_cast<void*>(this));
+		}
+	} else {
+		CheckMemoryPressure();
+		if (memory_pressure == MemoryPressureLevel::kCritical) {
+			// Reentrant GC doesn't trigger callbacks
+			MarkSweepCompactEpilogue(isolate, GCType::kGCTypeMarkSweepCompact, GCCallbackFlags::kGCCallbackFlagForced, reinterpret_cast<void*>(this));
+		}
+	}
+}
+
+void IsolateEnvironment::MemoryPressureInterrupt(Isolate* /*isolate*/, void* data) {
+	static_cast<IsolateEnvironment*>(data)->CheckMemoryPressure();
+}
+
+void IsolateEnvironment::CheckMemoryPressure() {
+	if (memory_pressure != last_memory_pressure) {
+		if (memory_pressure > last_memory_pressure) {
+			isolate->MemoryPressureNotification(memory_pressure);
+		}
+		last_memory_pressure = memory_pressure;
+	}
+}
+
+void IsolateEnvironment::AsyncEntry() {
+	Executor::Lock lock(*this);
+	if (!nodejs_isolate) {
+		// Set v8 stack limit on non-default isolate. This is only needed on non-default threads while
+		// on OS X because it allocates just 512kb for each pthread stack, instead of 2mb on other
+		// systems. 512kb is lower than the default v8 stack size so JS stack overflows result in
+		// segfaults.
+		thread_local void* stack_base = GetStackBase();
+		if (stack_base != nullptr) {
+			// Add 24kb of padding for native code to run
+			isolate->SetStackLimit(reinterpret_cast<uintptr_t>(reinterpret_cast<char*>(stack_base) + 1024 * 24));
+		}
+	}
+
+	while (true) {
+		std::queue<unique_ptr<Runnable>> tasks;
+		std::queue<unique_ptr<Runnable>> handle_tasks;
+		std::queue<unique_ptr<Runnable>> interrupts;
+		{
+			// Grab current tasks
+			auto lock = scheduler->Lock();
+			tasks = ExchangeDefault(lock->tasks);
+			handle_tasks = ExchangeDefault(lock->handle_tasks);
+			interrupts = ExchangeDefault(lock->interrupts);
+			if (tasks.empty() && handle_tasks.empty() && interrupts.empty()) {
+				lock->DoneRunning();
+				return;
+			}
+		}
+
+		// Execute interrupt tasks
+		while (!interrupts.empty()) {
+			interrupts.front()->Run();
+			interrupts.pop();
+		}
+
+		// Execute handle tasks
+		while (!handle_tasks.empty()) {
+			handle_tasks.front()->Run();
+			handle_tasks.pop();
+		}
+
+		// Execute tasks
+		while (!tasks.empty()) {
+			tasks.front()->Run();
+			tasks.pop();
+			if (terminated) {
+				return;
+			}
+			CheckMemoryPressure();
+		}
+	}
+}
+
+template <std::queue<std::unique_ptr<Runnable>> Scheduler::*Tasks>
+void IsolateEnvironment::InterruptEntryImplementation() {
+	// Executor::Lock is already acquired
+	while (true) {
+		auto interrupts = [&]() {
+			return ExchangeDefault((*scheduler->Lock()).*Tasks);
+		}();
+		if (interrupts.empty()) {
+			return;
+		}
+		do {
+			interrupts.front()->Run();
+			interrupts.pop();
+		} while (!interrupts.empty());
+	}
+}
+
+void IsolateEnvironment::InterruptEntryAsync() {
+	return InterruptEntryImplementation<&Scheduler::interrupts>();
+}
+
+void IsolateEnvironment::InterruptEntrySync() {
+	return InterruptEntryImplementation<&Scheduler::sync_interrupts>();
+}
+
+IsolateEnvironment::IsolateEnvironment() :
+	owned_isolates{std::make_unique<OwnedIsolates>()},
+	scheduler{in_place<UvScheduler>{}, *this},
+	executor{*this},
+	nodejs_isolate{true} {}
+
+
+IsolateEnvironment::IsolateEnvironment(UvScheduler& default_scheduler) :
+	scheduler{in_place<IsolatedScheduler>{}, *this, default_scheduler},
+	executor{*this} {}
+
+void IsolateEnvironment::IsolateCtor(Isolate* isolate, Local<Context> context) {
+	this->isolate = isolate;
+	default_context.Reset(isolate, context);
+}
+
+void IsolateEnvironment::IsolateCtor(size_t memory_limit_in_mb, shared_ptr<v8::BackingStore> snapshot_blob, size_t snapshot_length) {
+	memory_limit = memory_limit_in_mb * 1024 * 1024;
+	allocator_ptr = std::make_shared<LimitedAllocator>(*this, memory_limit);
+	snapshot_blob_ptr = std::move(snapshot_blob);
+
+	// Calculate resource constraints
+	ResourceConstraints rc;
+	size_t young_space_in_kb = (size_t)std::pow(2, std::min(sizeof(void*) >= 8 ? 4.0 : 3.0, memory_limit_in_mb / 128.0) + 10);
+	size_t old_generation_size_in_mb = memory_limit_in_mb;
+	// TODO: Give `ConfigureDefaultsFromHeapSize` a try
+	rc.set_max_young_generation_size_in_bytes(young_space_in_kb * 1024);
+	rc.set_max_old_generation_size_in_bytes(old_generation_size_in_mb * 1024 * 1024);
+
+	// Build isolate from create params
+	Isolate::CreateParams create_params;
+	create_params.constraints = rc;
+	create_params.array_buffer_allocator_shared = allocator_ptr;
+	if (snapshot_blob_ptr) {
+		create_params.snapshot_blob = &startup_data;
+		startup_data.data = reinterpret_cast<char*>(snapshot_blob_ptr->Data());
+		startup_data.raw_size = snapshot_length;
+	}
+	task_runner = std::make_shared<IsolateTaskRunner>(holder.lock()->GetIsolate());
+	{
+		std::lock_guard allocator_lock{isolate_allocator_mutex};
+		isolate = Isolate::Allocate();
+		PlatformDelegate::RegisterIsolate(isolate, &*scheduler);
+	}
+	Isolate::Initialize(isolate, create_params);
+
+	// Various callbacks
+	isolate->SetOOMErrorHandler(OOMErrorCallback);
+	isolate->SetPromiseRejectCallback(PromiseRejectCallback);
+	isolate->SetModifyCodeGenerationFromStringsCallback(CodeGenCallback2);
+
+	// Add GC callbacks
+	isolate->AddGCEpilogueCallback(MarkSweepCompactEpilogue, static_cast<void*>(this), GCType::kGCTypeMarkSweepCompact);
+	isolate->AddNearHeapLimitCallback(NearHeapLimitCallback, static_cast<void*>(this));
+
+	// Heap statistics crushes down lots of different memory spaces into a single number. We note the
+	// difference between the requested old space and v8's calculated heap size.
+	HeapStatistics heap;
+	isolate->GetHeapStatistics(&heap);
+	initial_heap_size_limit = heap.heap_size_limit();
+	misc_memory_size = heap.heap_size_limit() - memory_limit_in_mb * 1024 * 1024;
+
+	// Create a default context for the library to use if needed
+	{
+		Locker locker(isolate);
+		HandleScope handle_scope(isolate);
+		default_context.Reset(isolate, NewContext());
+	}
+
+	// There is no asynchronous Isolate ctor so we should throw away thread specifics in case
+	// the client always uses async methods
+	isolate->DiscardThreadSpecificMetadata();
+
+	// Save reference to this isolate in the default isolate
+	Executor::GetDefaultEnvironment().owned_isolates->write()->insert({ dispose_wait, holder });
+}
+
+IsolateEnvironment::~IsolateEnvironment() {
+	if (nodejs_isolate) {
+		// Throw away all owned isolates when the root one dies
+		auto isolates = *owned_isolates->read(); // copy
+		for (const auto& handle : isolates) {
+			auto ref = handle.holder.lock();
+			if (ref) {
+				ref->Dispose();
+			}
+		}
+		for (const auto& handle : isolates) {
+			handle.dispose_wait->Join();
+		}
+	} else {
+		{
+			// Grab local pointer to inspector agent with scheduler lock active
+			auto agent_ptr = [&]() {
+				auto lock = scheduler->Lock();
+				return std::move(inspector_agent);
+			}();
+			// Now activate executor lock and invoke inspector agent's dtor
+			Executor::Lock lock{*this};
+			agent_ptr.reset();
+			// Kill all weak persistents
+			for (auto it = weak_persistents.begin(); it != weak_persistents.end(); ) {
+				void(*fn)(void*) = it->second.first;
+				void* param = it->second.second;
+				++it;
+				fn(param);
+			}
+			assert(weak_persistents.empty());
+			unhandled_promise_rejections.clear();
+			// Destroy outstanding tasks. Do this here while the executor lock is up.
+			auto scheduler_lock = scheduler->Lock();
+			ExchangeDefault(scheduler_lock->interrupts);
+			ExchangeDefault(scheduler_lock->sync_interrupts);
+			ExchangeDefault(scheduler_lock->handle_tasks);
+			ExchangeDefault(scheduler_lock->tasks);
+		}
+		{
+			std::lock_guard allocator_lock{isolate_allocator_mutex};
+			{
+				// Dispose() will call destructors for external strings and array buffers, so this lock sets the
+				// "current" isolate for those C++ dtors to function correctly without locking v8
+				Executor::Scope lock{*this};
+				isolate->Dispose();
+			}
+			// Unregister from Platform
+			PlatformDelegate::UnregisterIsolate(isolate);
+		}
+		// Unreference from default isolate
+		executor.default_executor.env.owned_isolates->write()->erase({ dispose_wait, holder });
+	}
+	// Send notification that this isolate is totally disposed
+	dispose_wait->IsolateDidDispose();
+}
+
+static void DeserializeInternalFieldsCallback(Local<Object> /*holder*/, int /*index*/, StartupData /*payload*/, void* /*data*/) {
+}
+
+auto IsolateEnvironment::NewContext() -> Local<Context> {
+	auto context =
+	Context::New(isolate, nullptr, {}, {}, &DeserializeInternalFieldsCallback);
+	context->AllowCodeGenerationFromStrings(false);
+	// TODO (but I'm not going to do it): This causes a DCHECK failure in debug builds. Tested nodejs
+	// v14.17.3 & v16.5.1.
+	// context->SetErrorMessageForCodeGenerationFromStrings(StringTable::Get().codeGenerationError);
+	return context;
+}
+
+auto IsolateEnvironment::TaskEpilogue() -> std::unique_ptr<ExternalCopy> {
+	isolate->PerformMicrotaskCheckpoint();
+	CheckMemoryPressure();
+	if (hit_memory_limit) {
+		throw FatalRuntimeError("Isolate was disposed during execution due to memory limit");
+	}
+	auto rejected_promises = std::exchange(unhandled_promise_rejections, {});
+	for (auto& handle : rejected_promises) {
+		if (!handle.IsEmpty()) {
+			Context::Scope context_scope{DefaultContext()};
+			return ExternalCopy::CopyThrownValue(Deref(handle)->Result());
+		}
+	}
+	return {};
+}
+
+auto IsolateEnvironment::GetLimitedAllocator() const -> LimitedAllocator* {
+	if (nodejs_isolate) {
+		return nullptr;
+	} else {
+		return static_cast<LimitedAllocator*>(allocator_ptr.get());
+	}
+}
+
+void IsolateEnvironment::EnableInspectorAgent() {
+	inspector_agent = std::make_unique<InspectorAgent>(*this);
+}
+
+auto IsolateEnvironment::GetInspectorAgent() const -> InspectorAgent* {
+	return inspector_agent.get();
+}
+
+auto IsolateEnvironment::GetCpuProfileManager() -> CpuProfileManager* {
+	if (!cpu_profile_manager) {
+		cpu_profile_manager = std::make_shared<CpuProfileManager>();
+	}
+	return cpu_profile_manager.get();
+}
+
+auto IsolateEnvironment::GetCpuTime() -> std::chrono::nanoseconds {
+	std::lock_guard<std::mutex> lock(executor.timer_mutex);
+	std::chrono::nanoseconds time = executor.cpu_time;
+	if (executor.cpu_timer != nullptr) {
+		time += executor.cpu_timer->Delta(lock);
+	}
+	return time;
+}
+
+auto IsolateEnvironment::GetWallTime() -> std::chrono::nanoseconds {
+	std::lock_guard<std::mutex> lock(executor.timer_mutex);
+	std::chrono::nanoseconds time = executor.wall_time;
+	if (executor.wall_timer != nullptr) {
+		time += executor.wall_timer->Delta(lock);
+	}
+	return time;
+}
+
+void IsolateEnvironment::Terminate() {
+	assert(!nodejs_isolate);
+	terminated = true;
+
+	// Destroy inspector session
+	{
+		auto lock = scheduler->Lock();
+		lock->CancelAsync();
+		if (inspector_agent) {
+			inspector_agent->Terminate();
+		}
+	}
+
+	// Request interrupt to ensure execution is interrupted in race conditions
+	isolate->RequestInterrupt([](Isolate* isolate, void* /* param */) {
+		isolate->AddBeforeCallEnteredCallback([](Isolate* isolate) {
+			isolate->TerminateExecution();
+		});
+		isolate->TerminateExecution();
+	}, nullptr);
+
+	// Throw away Holder reference
+	auto ref = holder.lock();
+	if (ref) {
+		ref->isolate.write()->reset();
+	}
+}
+
+void IsolateEnvironment::AddWeakCallback(Persistent<Value>* handle, void(*fn)(void*), void* param) {
+	if (nodejs_isolate) {
+		return;
+	}
+	auto it = weak_persistents.find(handle);
+	if (it != weak_persistents.end()) {
+		throw std::logic_error("Weak callback already added");
+	}
+	weak_persistents.insert(std::make_pair(handle, std::make_pair(fn, param)));
+}
+
+void IsolateEnvironment::RemoveWeakCallback(Persistent<Value>* handle) {
+	if (nodejs_isolate) {
+		return;
+	}
+	auto it = weak_persistents.find(handle);
+	if (it == weak_persistents.end()) {
+		throw std::logic_error("Weak callback doesn't exist");
+	}
+	weak_persistents.erase(it);
+}
+
+void AdjustRemotes(int delta) {
+	IsolateEnvironment::GetCurrent().AdjustRemotes(delta);
+}
+
+auto RaiseCatastrophicError(RemoteHandle<Function>& handler, const char* message) -> bool {
+	if (!handler) {
+		return false;
+	}
+
+	class ErrorTask : public Task {
+		public:
+			explicit ErrorTask(const char* message, RemoteHandle<Function> handler) :
+				message{message}, handler{std::move(handler)} {}
+
+			void Run() final {
+				auto* isolate = Isolate::GetCurrent();
+				auto context = isolate->GetCurrentContext();
+				auto fn = handler.Deref();
+				Local<Value> argv[] = { HandleCast<Local<String>>(message) };
+				Unmaybe(fn->Call(context, Undefined(isolate), 1, argv));
+			}
+
+		private:
+			const char* message;
+			RemoteHandle<Function> handler;
+	};
+	handler.GetIsolateHolder()->ScheduleTask(std::make_unique<ErrorTask>(message, handler), false, true);
+	return true;
+}
+
+} // namespace ivm