diff --git a/skyrim-platform/src/platform_se/CMakeLists.txt b/skyrim-platform/src/platform_se/CMakeLists.txt
index 0b35a78f5..96b974906 100644
--- a/skyrim-platform/src/platform_se/CMakeLists.txt
+++ b/skyrim-platform/src/platform_se/CMakeLists.txt
@@ -95,6 +95,9 @@ if(NOT "${SKIP_SKYRIM_PLATFORM_BUILDING}")
     target_include_directories(skyrim_platform PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/include)
     target_link_libraries(skyrim_platform PRIVATE papyrus-vm-lib savefile skyrim_plugin_resources ui cef platform_lib viet serialization)
     target_link_libraries(skyrim_platform PRIVATE node-embedder-api)
+
+    find_package(qjs CONFIG REQUIRED)
+    target_link_libraries(skyrim_platform PRIVATE qjs)
     
     find_path(FRIDA_GUM_INCLUDE_DIR NAMES frida-gum.h)
     find_library(FRIDA_GUM_LIBRARY NAMES frida-gum.lib)
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/ConsoleApi.cpp b/skyrim-platform/src/platform_se/skyrim_platform/ConsoleApi.cpp
index aadc21718..e33b7594c 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/ConsoleApi.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/ConsoleApi.cpp
@@ -340,7 +340,7 @@ bool ConsoleComand_Execute(const RE::SCRIPT_PARAMETER* paramInfo,
     }
   };
 
-  SkyrimPlatform::GetSingleton()->PushAndWait(func);
+  SkyrimPlatform::GetSingleton()->RunTask(func);
   if (iterator)
     iterator->second.execute(paramInfo, scriptData, thisObj, containingObj,
                              scriptObj, locals, result, opcodeOffsetPtr);
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.cpp b/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.cpp
index f68d86ede..d1f0d5851 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.cpp
@@ -1,9 +1,9 @@
 #include "EventsApi.h"
 #include "EventManager.h"
 #include "ExceptionPrinter.h"
-#include "Handler.h"
 #include "Hook.h"
 #include "HookPattern.h"
+#include "HooksStorage.h"
 #include "IPC.h"
 #include "InvalidArgumentException.h"
 #include "JsUtils.h"
@@ -112,10 +112,14 @@ namespace {
 Napi::Value CreateHookApi(Napi::Env env, std::shared_ptr<Hook> hookInfo)
 {
   auto hook = Napi::Object::New(env);
+
+  // hooks.sendAnimationEvent.add(sourceCode, [minSelfId], [maxSelfId],
+  // [pattern])
+  // sourceCode: string containing JS with enter(ctx) and/or leave(ctx)
   hook.Set(
     "add",
     Napi::Function::New(env, [hookInfo](const Napi::CallbackInfo& info) {
-      auto handlerObj = NapiHelper::ExtractObject(info[0], "handlerObj");
+      auto source = NapiHelper::ExtractString(info[0], "source");
 
       std::optional<double> minSelfId;
       if (info[1].IsNumber()) {
@@ -133,9 +137,8 @@ Napi::Value CreateHookApi(Napi::Env env, std::shared_ptr<Hook> hookInfo)
         pattern = HookPattern::Parse(s);
       }
 
-      auto handler =
-        std::make_shared<Handler>(handlerObj, minSelfId, maxSelfId, pattern);
-      uint32_t id = hookInfo->AddHandler(handler);
+      uint32_t id =
+        hookInfo->AddScript(source, minSelfId, maxSelfId, std::move(pattern));
 
       return Napi::Number::New(info.Env(), id);
     }));
@@ -144,7 +147,7 @@ Napi::Value CreateHookApi(Napi::Env env, std::shared_ptr<Hook> hookInfo)
     "remove",
     Napi::Function::New(env, [hookInfo](const Napi::CallbackInfo& info) {
       uint32_t toRemove = NapiHelper::ExtractUInt32(info[0], "toRemove");
-      hookInfo->RemoveHandler(toRemove);
+      hookInfo->RemoveScript(toRemove);
       return info.Env().Undefined();
     }));
   return hook;
@@ -160,6 +163,74 @@ Napi::Value EventsApi::GetHooks(Napi::Env env)
   return res;
 }
 
+Napi::Value EventsApi::GetHooksStorage(Napi::Env env)
+{
+  auto obj = Napi::Object::New(env);
+
+  obj.Set("get", Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+    auto key = NapiHelper::ExtractString(info[0], "key");
+    auto val = HooksStorage::GetSingleton().Get(key);
+
+    Napi::Env env = info.Env();
+    if (std::holds_alternative<std::monostate>(val)) {
+      return env.Undefined();
+    }
+    if (std::holds_alternative<bool>(val)) {
+      return static_cast<Napi::Value>(
+        Napi::Boolean::New(env, std::get<bool>(val)));
+    }
+    if (std::holds_alternative<double>(val)) {
+      return static_cast<Napi::Value>(
+        Napi::Number::New(env, std::get<double>(val)));
+    }
+    if (std::holds_alternative<std::string>(val)) {
+      return static_cast<Napi::Value>(
+        Napi::String::New(env, std::get<std::string>(val)));
+    }
+    return env.Undefined();
+  }));
+
+  obj.Set("set", Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+    auto key = NapiHelper::ExtractString(info[0], "key");
+    Napi::Value val = info[1];
+
+    if (val.IsBoolean()) {
+      HooksStorage::GetSingleton().Set(key, val.As<Napi::Boolean>().Value());
+    } else if (val.IsNumber()) {
+      HooksStorage::GetSingleton().Set(key,
+                                       val.As<Napi::Number>().DoubleValue());
+    } else if (val.IsString()) {
+      HooksStorage::GetSingleton().Set(
+        key, val.As<Napi::String>().Utf8Value());
+    } else {
+      HooksStorage::GetSingleton().Set(key, std::monostate{});
+    }
+
+    return info.Env().Undefined();
+  }));
+
+  obj.Set("has", Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+    auto key = NapiHelper::ExtractString(info[0], "key");
+    return Napi::Boolean::New(info.Env(),
+                              HooksStorage::GetSingleton().Has(key));
+  }));
+
+  obj.Set(
+    "erase", Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+      auto key = NapiHelper::ExtractString(info[0], "key");
+      HooksStorage::GetSingleton().Erase(key);
+      return info.Env().Undefined();
+    }));
+
+  obj.Set(
+    "clear", Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+      HooksStorage::GetSingleton().Clear();
+      return info.Env().Undefined();
+    }));
+
+  return obj;
+}
+
 namespace {
 Napi::Value Subscribe(const Napi::CallbackInfo& info, bool runOnce = false)
 {
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.h b/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.h
index b20c7a367..a5a102bf4 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/EventsApi.h
@@ -21,6 +21,7 @@ void SendPapyrusEventEnter(uint32_t selfId,
 void SendPapyrusEventLeave() noexcept;
 
 Napi::Value GetHooks(Napi::Env env);
+Napi::Value GetHooksStorage(Napi::Env env);
 
 inline void Register(Napi::Env env, Napi::Object& exports)
 {
@@ -29,6 +30,7 @@ inline void Register(Napi::Env env, Napi::Object& exports)
   exports.Set("once",
               Napi::Function::New(env, NapiHelper::WrapCppExceptions(Once)));
   exports.Set("hooks", GetHooks(env));
+  exports.Set("hooksStorage", GetHooksStorage(env));
   exports.Set(
     "sendIpcMessage",
     Napi::Function::New(env, NapiHelper::WrapCppExceptions(SendIpcMessage)));
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/Handler.h b/skyrim-platform/src/platform_se/skyrim_platform/Handler.h
index d86df0407..a8f5520fe 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/Handler.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/Handler.h
@@ -1,13 +1,6 @@
 #pragma once
 #include "HookPattern.h"
 
-// HandlerInfoPerThread structure is unique for each thread
-struct HandlerInfoPerThread
-{
-  std::shared_ptr<Napi::Reference<Napi::Object>> storage, context;
-  bool matchesCondition = false;
-};
-
 class Handler
 {
 public:
@@ -19,8 +12,6 @@ class Handler
 
   bool Matches(uint32_t selfId, const std::string& eventName);
 
-  std::unordered_map<DWORD, HandlerInfoPerThread> perThread;
-
   // Shared between threads
   const Napi::Reference<Napi::Function> enter, leave;
   const std::optional<HookPattern> pattern;
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/Hook.cpp b/skyrim-platform/src/platform_se/skyrim_platform/Hook.cpp
index 6fa4378fd..99e372132 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/Hook.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/Hook.cpp
@@ -1,30 +1,85 @@
 #include "Hook.h"
-#include "Handler.h"
-#include "SkyrimPlatform.h"
+#include "ScopedTask.h"
+#include <spdlog/spdlog.h>
+#include <Windows.h>
+
+std::mutex Hook::g_invocationsMutex;
+std::map<DWORD, std::vector<Hook::InvocationInfo>> Hook::g_invocations;
+
+bool HookScriptEntry::Matches(uint32_t selfId,
+                               const std::string& eventName) const
+{
+  if (minSelfId.has_value() && selfId < minSelfId.value()) {
+    return false;
+  }
+  if (maxSelfId.has_value() && selfId > maxSelfId.value()) {
+    return false;
+  }
+  if (pattern.has_value()) {
+    switch (pattern->type) {
+      case HookPatternType::Exact:
+        return eventName == pattern->str;
+      case HookPatternType::StartsWith:
+        return eventName.size() >= pattern->str.size() &&
+          !memcmp(eventName.data(), pattern->str.data(), pattern->str.size());
+      case HookPatternType::EndsWith:
+        return eventName.size() >= pattern->str.size() &&
+          !memcmp(eventName.data() + (eventName.size() - pattern->str.size()),
+                  pattern->str.data(), pattern->str.size());
+    }
+  }
+  return true;
+}
 
 Hook::Hook(std::string hookName_, std::string eventNameVariableName_,
            std::optional<std::string> succeededVariableName_)
-  : hookName(hookName_)
-  , eventNameVariableName(eventNameVariableName_)
-  , succeededVariableName(succeededVariableName_)
+  : hookName(std::move(hookName_))
+  , eventNameVariableName(std::move(eventNameVariableName_))
+  , succeededVariableName(std::move(succeededVariableName_))
 {
 }
 
-uint32_t Hook::AddHandler(const std::shared_ptr<Handler>& handler)
+uint32_t Hook::AddScript(const std::string& source,
+                         std::optional<double> minSelfId,
+                         std::optional<double> maxSelfId,
+                         std::optional<HookPattern> pattern)
 {
   if (addRemoveBlocker) {
     throw std::runtime_error("Trying to add hook inside hook context");
   }
-  handlers.emplace(hCounter, handler);
-  return hCounter++;
+
+  std::string error;
+  uint32_t qjsId = qjsEngine->Compile(source, hookName + "_hook", error);
+
+  if (qjsId == 0) {
+    throw std::runtime_error("Hook script compilation failed: " + error);
+  }
+
+  uint32_t handleId = nextHandlerId++;
+
+  HookScriptEntry entry;
+  entry.qjsScriptId = qjsId;
+  entry.pattern = std::move(pattern);
+  entry.minSelfId = minSelfId;
+  entry.maxSelfId = maxSelfId;
+  scripts[handleId] = std::move(entry);
+
+  return handleId;
 }
 
-void Hook::RemoveHandler(const uint32_t& id)
+void Hook::RemoveScript(uint32_t id)
 {
   if (addRemoveBlocker) {
     throw std::runtime_error("Trying to remove hook inside hook context");
   }
-  handlers.erase(id);
+
+  auto it = scripts.find(id);
+  if (it == scripts.end()) {
+    return;
+  }
+
+  qjsEngine->RemoveScript(it->second.qjsScriptId);
+  scripts.erase(it);
 }
 
 std::string Hook::GetName() const
@@ -35,155 +90,54 @@ std::string Hook::GetName() const
 void Hook::Enter(uint32_t selfId, std::string& eventName)
 {
   addRemoveBlocker++;
-  DWORD owningThread = GetCurrentThreadId();
-
-  if (hookName == "sendPapyrusEvent") {
-    // If there are no handlers, do not do g_taskQueue
-    bool anyMatch = false;
-    for (auto& hp : handlers) {
-      auto* h = hp.second.get();
-      if (h->Matches(selfId, eventName)) {
-        anyMatch = true;
-        break;
-      }
-    }
-    if (!anyMatch) {
-      return;
-    }
+  Viet::ScopedTask<Hook> t([](Hook& hook) { hook.addRemoveBlocker--; }, *this);
 
-    return SkyrimPlatform::GetSingleton()->AddUpdateTask(
-      [this, owningThread, selfId, eventName](Napi::Env env) {
-        std::string s = eventName;
-        HandleEnter(owningThread, selfId, s, env);
-      });
-  }
+  InvocationInfo invInfo;
 
-  auto f = [&](Napi::Env env) {
-    try {
-      if (inProgressThreads.count(owningThread))
-        throw std::runtime_error("'" + hookName + "' is already processing");
-      inProgressThreads.insert(owningThread);
-      HandleEnter(owningThread, selfId, eventName, env);
-    } catch (std::exception& e) {
-      auto err = std::string(e.what()) + " (while performing enter on '" +
-        hookName + "')";
-      SkyrimPlatform::GetSingleton()->AddUpdateTask(
-        [err](Napi::Env) { throw std::runtime_error(err); });
-    }
-  };
-  SkyrimPlatform::GetSingleton()->PushAndWait(f);
-  addRemoveBlocker--;
-}
-
-void Hook::Leave(bool succeeded)
-{
-  addRemoveBlocker++;
-  DWORD owningThread = GetCurrentThreadId();
-
-  if (hookName == "sendPapyrusEvent") {
-    return;
-  }
-
-  auto f = [&](Napi::Env env) {
-    try {
-      if (!inProgressThreads.count(owningThread))
-        throw std::runtime_error("'" + hookName + "' is not processing");
-      inProgressThreads.erase(owningThread);
-      HandleLeave(owningThread, succeeded, env);
-
-    } catch (std::exception& e) {
-      std::string what = e.what();
-      SkyrimPlatform::GetSingleton()->AddUpdateTask([what](Napi::Env) {
-        throw std::runtime_error(what + " (in SendAnimationEventLeave)");
-      });
+  // Collect matching scripts and run enter
+  for (auto& [handleId, entry] : scripts) {
+    if (!entry.Matches(selfId, eventName)) {
+      continue;
     }
-  };
-  SkyrimPlatform::GetSingleton()->PushAndWait(f);
-  addRemoveBlocker--;
-}
+    invInfo.matchedScriptIds.push_back(entry.qjsScriptId);
 
-void Hook::HandleEnter(DWORD owningThread, uint32_t selfId,
-                       std::string& eventName, const Napi::Env& env)
-{
-  for (auto& hp : handlers) {
-    Handler* h = hp.second.get();
-    auto& perThread = h->perThread[owningThread];
-
-    perThread.matchesCondition = h->Matches(selfId, eventName);
-    if (!perThread.matchesCondition) {
+    auto result = qjsEngine->RunEnter(entry.qjsScriptId, selfId, eventName);
+    if (!result.ok) {
+      spdlog::error("Hook '{}' enter error: {}", hookName, result.error);
       continue;
     }
-
-    PrepareContext(perThread, env);
-    ClearContextStorage(perThread, env);
-
-    perThread.context->Value().As<Napi::Object>().Set(
-      "selfId", Napi::Number::New(env, static_cast<double>(selfId)));
-    perThread.context->Value().As<Napi::Object>().Set(
-      eventNameVariableName, Napi::String::New(env, eventName));
-    h->enter.Value().As<Napi::Function>().Call(env.Undefined(),
-                                               { perThread.context->Value() });
-
-    // Retrieve the updated eventName from the context
-    Napi::Value updatedEventName =
-      perThread.context->Value().As<Napi::Object>().Get(eventNameVariableName);
-    eventName = updatedEventName.As<Napi::String>().Utf8Value();
+    eventName = result.eventName;
   }
-}
 
-void Hook::PrepareContext(HandlerInfoPerThread& h, const Napi::Env& env)
-{
-  if (!h.context) {
-    auto object = Napi::Object::New(env);
-    h.context.reset(new Napi::Reference<Napi::Object>(
-      Napi::Persistent<Napi::Object>(object)));
-  }
-
-  Napi::Value standardMap = env.Global().Get("Map");
-
-  if (!h.storage) {
-    Napi::Object mapInstance = standardMap.As<Napi::Function>().New({});
-    h.storage.reset(
-      new Napi::Reference<Napi::Object>(Napi::Persistent(mapInstance)));
-    h.context->Value().As<Napi::Object>().Set("storage", h.storage->Value());
+  // Push invocation info for Leave to use
+  const DWORD threadId = GetCurrentThreadId();
+  {
+    std::lock_guard l(g_invocationsMutex);
+    g_invocations[threadId].push_back(std::move(invInfo));
   }
 }
 
-void Hook::ClearContextStorage(HandlerInfoPerThread& h, Napi::Env env)
-{
-  if (!h.storage) {
-    return;
-  }
-
-  Napi::Object global = env.Global();
-  Napi::Object standardMap = global.Get("Map").As<Napi::Object>();
-  Napi::Function clear = standardMap.Get("prototype")
-                           .As<Napi::Object>()
-                           .Get("clear")
-                           .As<Napi::Function>();
-
-  clear.Call(h.storage->Value(), {});
-}
-
-void Hook::HandleLeave(DWORD owningThread, bool succeeded, Napi::Env env)
+void Hook::Leave(bool succeeded)
 {
-  for (auto& hp : handlers) {
-    Handler* h = hp.second.get();
-    auto& perThread = h->perThread.at(owningThread);
-
-    if (!perThread.matchesCondition) {
-      continue;
+  addRemoveBlocker++;
+  Viet::ScopedTask<Hook> t([](Hook& hook) { hook.addRemoveBlocker--; }, *this);
+
+  const DWORD threadId = GetCurrentThreadId();
+  InvocationInfo invInfo;
+  {
+    std::lock_guard l(g_invocationsMutex);
+    auto& stack = g_invocations[threadId];
+    if (stack.empty()) {
+      return;
     }
+    invInfo = std::move(stack.back());
+    stack.pop_back();
+  }
 
-    PrepareContext(perThread, env);
-
-    if (succeededVariableName.has_value()) {
-      perThread.context->Value().As<Napi::Object>().Set(
-        succeededVariableName.value(), Napi::Boolean::New(env, succeeded));
+  for (uint32_t scriptId : invInfo.matchedScriptIds) {
+    auto result = qjsEngine->RunLeave(scriptId, succeeded);
+    if (!result.ok) {
+      spdlog::error("Hook '{}' leave error: {}", hookName, result.error);
     }
-
-    h->leave.Value().As<Napi::Function>().Call(env.Undefined(),
-                                               { perThread.context->Value() });
-    h->perThread.erase(owningThread);
   }
 }
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/Hook.h b/skyrim-platform/src/platform_se/skyrim_platform/Hook.h
index 74ce1ce77..817c99006 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/Hook.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/Hook.h
@@ -1,7 +1,24 @@
 #pragma once
+#include "HookPattern.h"
+#include "QuickJSHookEngine.h"
+#include <atomic>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
 
-class Handler;
-struct HandlerInfoPerThread;
+// Represents a single registered hook script with optional filtering
+struct HookScriptEntry
+{
+  uint32_t qjsScriptId = 0; // ID in QuickJSHookEngine
+  std::optional<HookPattern> pattern;
+  std::optional<double> minSelfId;
+  std::optional<double> maxSelfId;
+
+  bool Matches(uint32_t selfId, const std::string& eventName) const;
+};
 
 class Hook
 {
@@ -9,36 +26,41 @@ class Hook
   Hook(std::string hookName_, std::string eventNameVariableName_,
        std::optional<std::string> succeededVariableName_);
 
-  // javascript thread only
-  uint32_t AddHandler(const std::shared_ptr<Handler>& handler);
-  void RemoveHandler(const uint32_t& id);
+  // Add a hook by providing JavaScript source code.
+  // The source must define enter(ctx) and/or leave(ctx) functions.
+  // Returns a handle ID that can be used to remove the hook.
+  uint32_t AddScript(const std::string& source,
+                     std::optional<double> minSelfId,
+                     std::optional<double> maxSelfId,
+                     std::optional<HookPattern> pattern);
 
-  // Thread-safe, but it isn't too useful actually
-  std::string GetName() const;
+  void RemoveScript(uint32_t id);
 
-  // Hooks are set on game functions that are being called from multiple
-  // threads. So Enter/Leave methods are thread-safe, but all private methods
-  // are for Chakra thread only
+  std::string GetName() const;
 
+  // Thread-safe entry/exit points called from game hooks
   void Enter(uint32_t selfId, std::string& eventName);
-
   void Leave(bool succeeded);
 
 private:
-  void HandleEnter(DWORD owningThread, uint32_t selfId, std::string& eventName,
-                   const Napi::Env& env);
-
-  void PrepareContext(HandlerInfoPerThread& h, const Napi::Env& env);
-
-  void ClearContextStorage(HandlerInfoPerThread& h, Napi::Env env);
-
-  void HandleLeave(DWORD owningThread, bool succeeded, Napi::Env env);
-
   const std::string hookName;
   const std::string eventNameVariableName;
   const std::optional<std::string> succeededVariableName;
-  std::set<DWORD> inProgressThreads;
-  std::map<uint32_t, std::shared_ptr<Handler>> handlers;
-  uint32_t hCounter = 0;
+
+  // QuickJS engine owns all compiled hook scripts for this hook
+  std::unique_ptr<QuickJSHookEngine> qjsEngine;
+
+  std::map<uint32_t, HookScriptEntry> scripts;
+  uint32_t nextHandlerId = 0;
+
+  // Prevent add/remove while executing hooks
   std::atomic<int> addRemoveBlocker = 0;
+
+  // Per-thread invocation tracking for nested Enter/Leave pairs
+  static std::mutex g_invocationsMutex;
+  struct InvocationInfo
+  {
+    std::vector<uint32_t> matchedScriptIds;
+  };
+  static std::map<DWORD, std::vector<InvocationInfo>> g_invocations;
 };
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/HooksStorage.cpp b/skyrim-platform/src/platform_se/skyrim_platform/HooksStorage.cpp
new file mode 100644
index 000000000..f55309bd3
--- /dev/null
+++ b/skyrim-platform/src/platform_se/skyrim_platform/HooksStorage.cpp
@@ -0,0 +1,47 @@
+#include "HooksStorage.h"
+
+HooksStorage& HooksStorage::GetSingleton()
+{
+  static HooksStorage instance;
+  return instance;
+}
+
+void HooksStorage::Set(const std::string& key, Value value)
+{
+  std::lock_guard lock(mtx);
+  data[key] = std::move(value);
+}
+
+HooksStorage::Value HooksStorage::Get(const std::string& key) const
+{
+  std::lock_guard lock(mtx);
+  auto it = data.find(key);
+  if (it == data.end()) {
+    return std::monostate{};
+  }
+  return it->second;
+}
+
+bool HooksStorage::Has(const std::string& key) const
+{
+  std::lock_guard lock(mtx);
+  return data.count(key) > 0;
+}
+
+void HooksStorage::Erase(const std::string& key)
+{
+  std::lock_guard lock(mtx);
+  data.erase(key);
+}
+
+void HooksStorage::Clear()
+{
+  std::lock_guard lock(mtx);
+  data.clear();
+}
+
+std::map<std::string, HooksStorage::Value> HooksStorage::Snapshot() const
+{
+  std::lock_guard lock(mtx);
+  return data;
+}
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/HooksStorage.h b/skyrim-platform/src/platform_se/skyrim_platform/HooksStorage.h
new file mode 100644
index 000000000..be347f067
--- /dev/null
+++ b/skyrim-platform/src/platform_se/skyrim_platform/HooksStorage.h
@@ -0,0 +1,30 @@
+#pragma once
+#include <map>
+#include <mutex>
+#include <string>
+#include <variant>
+
+// Thread-safe key-value storage shared between Node.js and QuickJS contexts.
+// Values are stored as C++ variants; both runtimes get/set through the same
+// mutex-protected map.
+class HooksStorage
+{
+public:
+  using Value = std::variant<std::monostate, bool, double, std::string>;
+
+  static HooksStorage& GetSingleton();
+
+  void Set(const std::string& key, Value value);
+  Value Get(const std::string& key) const;
+  bool Has(const std::string& key) const;
+  void Erase(const std::string& key);
+  void Clear();
+
+  // Snapshot all keys for enumeration (avoids holding the lock during
+  // iteration on the JS side)
+  std::map<std::string, Value> Snapshot() const;
+
+private:
+  mutable std::mutex mtx;
+  std::map<std::string, Value> data;
+};
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.cpp b/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.cpp
index e6734b8b7..3f728d4a7 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.cpp
@@ -1,7 +1,39 @@
 #include "JsEngine.h"
 #include <spdlog/spdlog.h>
+#include <stack>
+#include <v8.h>
 
 #include "NodeInstance.h"
+#include "ScopedTask.h"
+
+namespace {
+enum V8ScriptId : uint16_t
+{
+  V8SCRIPT_INIT_SKYRIM_PLATFORM,
+  V8SCRIPT_CALL_PREPARED_FUNCTION,
+};
+
+constexpr auto kInitSkyrimPlatformScript = R"(
+    try {
+      const nodeProcess = require('node:process');
+      const module = { exports: {} };
+
+      nodeProcess.dlopen(module, 'Data/Platform/Distribution/RuntimeDependencies/SkyrimPlatformImpl.dll');
+
+      globalThis.skyrimPlatformNativeAddon = module.exports;
+    } catch (e) { 
+      reportError(e.toString());
+    }
+  )";
+
+constexpr auto kCallPreparedFunctionSсript = R"(
+    try {
+      skyrimPlatformNativeAddon.callPreparedFunction();
+    } catch (e) { 
+      reportError(e.toString());
+    }
+  )";
+}
 
 struct JsEngine::Impl
 {
@@ -9,12 +41,16 @@ struct JsEngine::Impl
 
   std::vector<char*> argv;
   int argc = 0;
-
   char nodejsArgv0[5] = "node";
 
   std::unique_ptr<NodeInstance> nodeInstance;
+  std::stack<std::function<void(Napi::Env)>> preparedFunctionsStack;
+  int depth = 0;
+  std::optional<Napi::Env> retrievedEnv;
+
+  v8::Isolate* isolate = nullptr;
 
-  std::function<void(Napi::Env)> preparedFunction;
+  std::recursive_mutex m;
 };
 
 JsEngine* JsEngine::GetSingleton()
@@ -29,30 +65,39 @@ JsEngine::~JsEngine()
   delete pImpl;
 }
 
-void JsEngine::AcquireEnvAndCall(const std::function<void(Napi::Env)>& f)
+void JsEngine::AcquireEnvAndCall(const std::function<void(Napi::Env)>& f,
+                                 const char* comment)
 {
-  // spdlog::info("JsEngine::AcquireEnvAndCall()");
+  std::lock_guard<std::recursive_mutex> lock(pImpl->m);
 
-  if (!pImpl->nodeInstance) {
-    spdlog::error("JsEngine::AcquireEnvAndCall() - NodeInstance is nullptr");
+  if (!pImpl->isolate) {
+    spdlog::error("JsEngine::AcquireEnvAndCall() - V8 Isolate is nullptr");
     return;
   }
 
-  // napi_env env = reinterpret_cast<napi_env>(pImpl->env);
-  // Napi::Env cppEnv = Napi::Env(env);
-  // f(cppEnv);
+  v8::Locker locker(pImpl->isolate);
 
-  pImpl->preparedFunction = f;
+  Viet::ScopedTask<int> task([](int& depth) { depth--; }, pImpl->depth);
+  pImpl->depth++;
+
+  Viet::ScopedTask<std::stack<std::function<void(Napi::Env)>>> task2(
+    [](auto& preparedFunctionsStack) { preparedFunctionsStack.pop(); },
+    pImpl->preparedFunctionsStack);
+  pImpl->preparedFunctionsStack.push(f);
+
+  if (pImpl->depth > 1) {
+    return f(*pImpl->retrievedEnv);
+  }
+
+  if (!pImpl->nodeInstance) {
+    spdlog::error("JsEngine::AcquireEnvAndCall() - NodeInstance is nullptr");
+    return;
+  }
 
   pImpl->nodeInstance->ClearJavaScriptError();
 
-  int executeScriptResult = pImpl->nodeInstance->ExecuteScript(pImpl->env, R"(
-    try {
-      skyrimPlatformNativeAddon.callPreparedFunction();
-    } catch (e) { 
-      reportError(e.toString())
-    }
-  )");
+  int executeScriptResult = pImpl->nodeInstance->ExecuteScript(
+    pImpl->env, V8SCRIPT_CALL_PREPARED_FUNCTION);
 
   if (executeScriptResult != 0) {
     spdlog::error(
@@ -70,8 +115,6 @@ void JsEngine::AcquireEnvAndCall(const std::function<void(Napi::Env)>& f)
       javaScriptError);
     throw std::runtime_error(javaScriptError);
   }
-
-  // spdlog::info("JsEngine::AcquireEnvAndCall() - Leave");
 }
 
 Napi::Value JsEngine::RunScript(Napi::Env env, const std::string& src,
@@ -89,13 +132,20 @@ void JsEngine::ResetContext(Viet::TaskQueue<Napi::Env>&)
 
 size_t JsEngine::GetMemoryUsage() const
 {
-  spdlog::info("JsEngine::GetMemoryUsage()");
-  // TODO
-  return 0;
+  if (!pImpl->isolate) {
+    return 0;
+  }
+
+  v8::Locker locker(pImpl->isolate);
+  v8::HeapStatistics stats;
+  pImpl->isolate->GetHeapStatistics(&stats);
+  return stats.used_heap_size();
 }
 
 void JsEngine::Tick()
 {
+  std::lock_guard<std::recursive_mutex> lock(pImpl->m);
+
   if (!pImpl->nodeInstance) {
     spdlog::error("JsEngine::Tick() - NodeInstance is nullptr");
     return;
@@ -106,6 +156,12 @@ void JsEngine::Tick()
     return;
   }
 
+  if (!pImpl->isolate) {
+    spdlog::error("JsEngine::Tick() - V8 Isolate is nullptr");
+    return;
+  }
+
+  v8::Locker locker(pImpl->isolate);
   pImpl->nodeInstance->Tick(pImpl->env);
 }
 
@@ -145,24 +201,54 @@ JsEngine::JsEngine()
 
   spdlog::info("JsEngine::JsEngine() - Environment created");
 
-  spdlog::info("JsEngine::JsEngine() - Executing script");
+  pImpl->isolate =
+    static_cast<v8::Isolate*>(pImpl->nodeInstance->GetIsolatePtr(pImpl->env));
+  if (!pImpl->isolate) {
+    spdlog::error("JsEngine::JsEngine() - Failed to get V8 Isolate");
+    pImpl->nodeInstance.reset();
+    return;
+  }
+
+  // Activate v8::Locker mode for this isolate. From this point on, all V8
+  // access must go through v8::Locker. This is required for thread-safe
+  // access to the V8 isolate from multiple threads (e.g. hook callbacks).
+  v8::Locker locker(pImpl->isolate);
+
+  spdlog::info(
+    "JsEngine::JsEngine() - Copmpiling script V8SCRIPT_INIT_SKYRIM_PLATFORM");
 
   pImpl->nodeInstance->ClearJavaScriptError();
 
-  int executeResult = pImpl->nodeInstance->ExecuteScript(pImpl->env, R"(
-    try {
-      const nodeProcess = require('node:process');
-      const module = { exports: {} };
-      //require('./scam_native.node');
-      nodeProcess.dlopen(module, 'Data/Platform/Distribution/RuntimeDependencies/SkyrimPlatformImpl.dll');
+  int compileResult = pImpl->nodeInstance->CompileScript(
+    pImpl->env, kInitSkyrimPlatformScript, V8SCRIPT_INIT_SKYRIM_PLATFORM);
+  if (compileResult != 0) {
+    spdlog::error("JsEngine::JsEngine() - Failed to compile script: {}",
+                  GetError());
+    pImpl->nodeInstance.reset();
+    return;
+  }
 
-      //module.exports.helloAddon();
+  spdlog::info("JsEngine::JsEngine() - Copmpiling script "
+               "V8SCRIPT_CALL_PREPARED_FUNCTION");
 
-      globalThis.skyrimPlatformNativeAddon = module.exports;
-    } catch (e) { 
-      reportError(e.toString())
-    }
-  )");
+  pImpl->nodeInstance->ClearJavaScriptError();
+
+  compileResult = pImpl->nodeInstance->CompileScript(
+    pImpl->env, kCallPreparedFunctionSсript, V8SCRIPT_CALL_PREPARED_FUNCTION);
+  if (compileResult != 0) {
+    spdlog::error("JsEngine::JsEngine() - Failed to compile script: {}",
+                  GetError());
+    pImpl->nodeInstance.reset();
+    return;
+  }
+
+  spdlog::info(
+    "JsEngine::JsEngine() - Executing script V8SCRIPT_INIT_SKYRIM_PLATFORM");
+
+  pImpl->nodeInstance->ClearJavaScriptError();
+
+  int executeResult = pImpl->nodeInstance->ExecuteScript(
+    pImpl->env, V8SCRIPT_INIT_SKYRIM_PLATFORM);
 
   if (executeResult != 0) {
     spdlog::error("JsEngine::JsEngine() - Failed to execute script: {}",
@@ -172,7 +258,10 @@ JsEngine::JsEngine()
   }
 
   std::string javaScriptError = pImpl->nodeInstance->GetJavaScriptError();
-  spdlog::info("JsEngine::JsEngine() - JavaScript error: {}", javaScriptError);
+  if (!javaScriptError.empty()) {
+    spdlog::info("JsEngine::JsEngine() - JavaScript error: {}",
+                 javaScriptError);
+  }
   pImpl->nodeInstance->ClearJavaScriptError();
 
   spdlog::info("JsEngine::JsEngine() - Script executed");
@@ -195,10 +284,9 @@ std::string JsEngine::GetError()
 
 Napi::Value CallPreparedFunction(const Napi::CallbackInfo& info)
 {
-  // spdlog::info("CallPreparedFunction()");
+  JsEngine::GetSingleton()->pImpl->retrievedEnv = info.Env();
 
-  auto f = JsEngine::GetSingleton()->pImpl->preparedFunction;
-  JsEngine::GetSingleton()->pImpl->preparedFunction = nullptr;
+  auto f = JsEngine::GetSingleton()->pImpl->preparedFunctionsStack.top();
 
   if (f) {
     f(info.Env());
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.h b/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.h
index 6d02994f6..ba193f916 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/JsEngine.h
@@ -25,7 +25,10 @@ class JsEngine
 
   ~JsEngine();
 
-  void AcquireEnvAndCall(const std::function<void(Napi::Env)>& f);
+  // TODO: consider optimizing std::function out by using a C style callback
+  // and a void* context
+  void AcquireEnvAndCall(const std::function<void(Napi::Env)>& f,
+                         const char* comment);
   Napi::Value RunScript(Napi::Env env, const std::string& src,
                         const std::string&);
   void ResetContext(Viet::TaskQueue<Napi::Env>&);
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.cpp b/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.cpp
index 835bb2488..2515d7bd3 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.cpp
@@ -48,9 +48,9 @@ void RegisterReportError(Isolate* isolate, Local<Context> context)
 
 struct NodeInstance::Impl
 {
-  std::map<void*, std::shared_ptr<Isolate::CreateParams>> createParamsMap;
   std::map<void*, Isolate*> isolatesMap;
   std::map<void*, v8::Persistent<v8::Context>> contextsMap;
+  std::vector<std::unique_ptr<v8::Persistent<v8::Script>>> compiledScripts;
   std::unique_ptr<MultiIsolatePlatform> platform;
   std::string error;
 };
@@ -96,29 +96,14 @@ int NodeInstance::Init(int argc, char** argv)
 
 int NodeInstance::CreateEnvironment(int argc, char** argv, void** outEnv)
 {
-  // Create a v8::Platform instance. `MultiIsolatePlatform::Create()` is a way
-  // to create a v8::Platform instance that Node.js can use when creating
-  // Worker threads. When no `MultiIsolatePlatform` instance is present,
-  // Worker threads are disabled.
   pImpl->platform = MultiIsolatePlatform::Create(4);
   V8::InitializePlatform(pImpl->platform.get());
   V8::Initialize();
 
-  // Setup V8 isolate and context
-  // auto create_params = std::make_shared<Isolate::CreateParams>();
-  // create_params->array_buffer_allocator =
-  //   v8::ArrayBuffer::Allocator::NewDefaultAllocator();
-  // Isolate* isolate = Isolate::New(*create_params);
-  Isolate* isolate = Isolate::Allocate();
-  pImpl->platform->RegisterIsolate(isolate, uv_default_loop());
-  auto create_params = std::make_shared<Isolate::CreateParams>();
-
   std::shared_ptr<node::ArrayBufferAllocator> allocator =
     node::ArrayBufferAllocator::Create();
-  isolate = NewIsolate(allocator, uv_default_loop(), pImpl->platform.get());
-
-  // register the isolate with the platform
-  // platform->RegisterIsolate(isolate, uv_default_loop());
+  Isolate* isolate =
+    NewIsolate(allocator, uv_default_loop(), pImpl->platform.get());
 
   {
     // Setup scope and context
@@ -145,7 +130,6 @@ int NodeInstance::CreateEnvironment(int argc, char** argv, void** outEnv)
                           "+ '/'); globalThis.require = publicRequire;",
                           nullptr);
 
-    pImpl->createParamsMap[env] = create_params;
     pImpl->contextsMap[env].Reset(isolate,
                                   context); // Promote to Persistent and store
     pImpl->isolatesMap[env] = isolate;
@@ -179,17 +163,6 @@ int NodeInstance::DestroyEnvironment(void* env)
     isolate = nullptr;  // Null out the reference to avoid dangling pointers
   }
 
-  // Step 3: Optionally close the libuv loop if you're using one
-  // For example:
-  // uv_loop_close(uv_default_loop());  // Only if you created your own loop
-
-  auto create_params = pImpl->createParamsMap[env];
-
-  if (create_params) {
-    delete create_params->array_buffer_allocator;
-  }
-
-  pImpl->createParamsMap.erase(env);
   pImpl->contextsMap.erase(env);
   pImpl->isolatesMap.erase(env);
 
@@ -218,15 +191,11 @@ int NodeInstance::Tick(void* env)
   return 0; // Success
 }
 
-int NodeInstance::ExecuteScript(void* env, const char* script)
+int NodeInstance::CompileScript(void* env, const char* script,
+                                uint16_t scriptId)
 {
-  if (!env) {
-    pImpl->error = "No env";
-    return -1;
-  }
-
-  if (!script) {
-    pImpl->error = "No script";
+  if (!env || !script) {
+    pImpl->error = "Invalid arguments";
     return -1;
   }
 
@@ -243,21 +212,60 @@ int NodeInstance::ExecuteScript(void* env, const char* script)
   Local<Context> context = contextPersistent.Get(isolate);
   Context::Scope context_scope(context);
 
+  TryCatch try_catch(isolate);
+
   Local<String> source = String::NewFromUtf8(isolate, script).ToLocalChecked();
   Local<Script> compiled_script;
 
-  // Use TryCatch to handle any exceptions that might occur
-  TryCatch try_catch(isolate);
-
   if (!Script::Compile(context, source).ToLocal(&compiled_script)) {
     String::Utf8Value error(isolate, try_catch.Exception());
     pImpl->error = *error ? *error : "Unknown compilation error";
     return -1;
   }
 
-  Local<Value> result;
+  if (pImpl->compiledScripts.size() <= scriptId) {
+    pImpl->compiledScripts.resize(scriptId + 1);
+  }
+  pImpl->compiledScripts[scriptId] =
+    std::make_unique<v8::Persistent<v8::Script>>();
+  pImpl->compiledScripts[scriptId]->Reset(isolate, compiled_script);
+
+  pImpl->error = "Success";
+  return 0;
+}
 
-  if (!compiled_script->Run(context).ToLocal(&result)) {
+int NodeInstance::ExecuteScript(void* env, uint16_t scriptId)
+{
+  if (!env) {
+    pImpl->error = "Invalid arguments";
+    return -1;
+  }
+
+  Isolate* isolate = pImpl->isolatesMap[env];
+  if (!isolate) {
+    pImpl->error = "No isolate";
+    return -1;
+  }
+
+  if (pImpl->compiledScripts.size() <= static_cast<size_t>(scriptId) ||
+      !pImpl->compiledScripts[scriptId]) {
+    pImpl->error = "Script with id " + std::to_string(scriptId) + " not found";
+    return -1;
+  }
+
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+
+  auto& contextPersistent = pImpl->contextsMap[env];
+  Local<Context> context = contextPersistent.Get(isolate);
+  Context::Scope context_scope(context);
+
+  TryCatch try_catch(isolate);
+
+  Local<Script> compiledScript =
+    pImpl->compiledScripts[scriptId]->Get(isolate);
+
+  if (compiledScript->Run(context).IsEmpty()) {
     String::Utf8Value error(isolate, try_catch.Exception());
     pImpl->error = *error ? *error : "Unknown runtime error";
     return -1;
@@ -267,6 +275,11 @@ int NodeInstance::ExecuteScript(void* env, const char* script)
   return 0;
 }
 
+void* NodeInstance::GetIsolatePtr(void* env)
+{
+  return static_cast<void*>(pImpl->isolatesMap[env]);
+}
+
 uint64_t NodeInstance::GetError(char* buffer, uint64_t bufferSize)
 {
   constexpr size_t kNullTerminatorLengthInBytes = 1;
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.h b/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.h
index 06fb7c501..06541b40d 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/NodeInstance.h
@@ -13,15 +13,15 @@ class NodeInstance
   int CreateEnvironment(int argc, char** argv, void** outEnv);
   int DestroyEnvironment(void* env);
   int Tick(void* env);
-  int ExecuteScript(void* env, const char* script);
+  int CompileScript(void* env, const char* script, uint16_t scriptId);
+  int ExecuteScript(void* env, uint16_t scriptId);
+  void* GetIsolatePtr(void* env);
   uint64_t GetError(char* buffer, uint64_t bufferSize);
 
   const char* GetJavaScriptError();
   void ClearJavaScriptError();
 
 private:
-  int NodeMain(int argc, char** argv);
-
   struct Impl;
   std::shared_ptr<Impl> pImpl;
 };
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/QuickJSHookEngine.cpp b/skyrim-platform/src/platform_se/skyrim_platform/QuickJSHookEngine.cpp
new file mode 100644
index 000000000..679a353db
--- /dev/null
+++ b/skyrim-platform/src/platform_se/skyrim_platform/QuickJSHookEngine.cpp
@@ -0,0 +1,379 @@
+#include "QuickJSHookEngine.h"
+#include "HooksStorage.h"
+#include <map>
+#include <quickjs.h>
+#include <spdlog/spdlog.h>
+#include <string>
+
+namespace {
+
+std::string GetQJSError(JSContext* ctx)
+{
+  JSValue exception = JS_GetException(ctx);
+  const char* str = JS_ToCString(ctx, exception);
+  std::string result = str ? str : "(unknown error)";
+  JS_FreeCString(ctx, str);
+
+  // Try to get stack trace
+  if (JS_IsError(exception)) {
+    JSValue stack = JS_GetPropertyStr(ctx, exception, "stack");
+    if (!JS_IsUndefined(stack)) {
+      const char* stackStr = JS_ToCString(ctx, stack);
+      if (stackStr) {
+        result += "\n";
+        result += stackStr;
+        JS_FreeCString(ctx, stackStr);
+      }
+    }
+    JS_FreeValue(ctx, stack);
+  }
+
+  JS_FreeValue(ctx, exception);
+  return result;
+}
+
+// Convert HooksStorage::Value to JSValue
+JSValue StorageValueToJS(JSContext* ctx, const HooksStorage::Value& val)
+{
+  if (std::holds_alternative<std::monostate>(val)) {
+    return JS_UNDEFINED;
+  }
+  if (std::holds_alternative<bool>(val)) {
+    return JS_NewBool(ctx, std::get<bool>(val));
+  }
+  if (std::holds_alternative<double>(val)) {
+    return JS_NewFloat64(ctx, std::get<double>(val));
+  }
+  if (std::holds_alternative<std::string>(val)) {
+    const auto& s = std::get<std::string>(val);
+    return JS_NewStringLen(ctx, s.c_str(), s.size());
+  }
+  return JS_UNDEFINED;
+}
+
+// Convert JSValue to HooksStorage::Value
+HooksStorage::Value JSToStorageValue(JSContext* ctx, JSValue val)
+{
+  if (JS_IsBool(val)) {
+    return static_cast<bool>(JS_ToBool(ctx, val));
+  }
+  if (JS_IsNumber(val)) {
+    double d;
+    JS_ToFloat64(ctx, &d, val);
+    return d;
+  }
+  if (JS_IsString(val)) {
+    const char* s = JS_ToCString(ctx, val);
+    std::string result = s ? s : "";
+    JS_FreeCString(ctx, s);
+    return result;
+  }
+  return std::monostate{};
+}
+
+// --- hooksStorage JS bindings ---
+
+JSValue JS_HooksStorage_Get(JSContext* ctx, JSValueConst /*thisVal*/, int argc,
+                            JSValueConst* argv)
+{
+  if (argc < 1) {
+    return JS_UNDEFINED;
+  }
+  const char* key = JS_ToCString(ctx, argv[0]);
+  if (!key) {
+    return JS_UNDEFINED;
+  }
+  auto val = HooksStorage::GetSingleton().Get(key);
+  JS_FreeCString(ctx, key);
+  return StorageValueToJS(ctx, val);
+}
+
+JSValue JS_HooksStorage_Set(JSContext* ctx, JSValueConst /*thisVal*/, int argc,
+                            JSValueConst* argv)
+{
+  if (argc < 2) {
+    return JS_UNDEFINED;
+  }
+  const char* key = JS_ToCString(ctx, argv[0]);
+  if (!key) {
+    return JS_UNDEFINED;
+  }
+  auto val = JSToStorageValue(ctx, argv[1]);
+  HooksStorage::GetSingleton().Set(key, std::move(val));
+  JS_FreeCString(ctx, key);
+  return JS_UNDEFINED;
+}
+
+JSValue JS_HooksStorage_Has(JSContext* ctx, JSValueConst /*thisVal*/, int argc,
+                            JSValueConst* argv)
+{
+  if (argc < 1) {
+    return JS_FALSE;
+  }
+  const char* key = JS_ToCString(ctx, argv[0]);
+  if (!key) {
+    return JS_FALSE;
+  }
+  bool has = HooksStorage::GetSingleton().Has(key);
+  JS_FreeCString(ctx, key);
+  return JS_NewBool(ctx, has);
+}
+
+JSValue JS_HooksStorage_Erase(JSContext* ctx, JSValueConst /*thisVal*/,
+                              int argc, JSValueConst* argv)
+{
+  if (argc < 1) {
+    return JS_UNDEFINED;
+  }
+  const char* key = JS_ToCString(ctx, argv[0]);
+  if (!key) {
+    return JS_UNDEFINED;
+  }
+  HooksStorage::GetSingleton().Erase(key);
+  JS_FreeCString(ctx, key);
+  return JS_UNDEFINED;
+}
+
+JSValue JS_HooksStorage_Clear(JSContext* ctx, JSValueConst /*thisVal*/,
+                              int /*argc*/, JSValueConst* /*argv*/)
+{
+  HooksStorage::GetSingleton().Clear();
+  return JS_UNDEFINED;
+}
+
+void InstallHooksStorageBindings(JSContext* ctx)
+{
+  JSValue global = JS_GetGlobalObject(ctx);
+
+  JSValue storage = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, storage, "get",
+                    JS_NewCFunction(ctx, JS_HooksStorage_Get, "get", 1));
+  JS_SetPropertyStr(ctx, storage, "set",
+                    JS_NewCFunction(ctx, JS_HooksStorage_Set, "set", 2));
+  JS_SetPropertyStr(ctx, storage, "has",
+                    JS_NewCFunction(ctx, JS_HooksStorage_Has, "has", 1));
+  JS_SetPropertyStr(ctx, storage, "erase",
+                    JS_NewCFunction(ctx, JS_HooksStorage_Erase, "erase", 1));
+  JS_SetPropertyStr(ctx, storage, "clear",
+                    JS_NewCFunction(ctx, JS_HooksStorage_Clear, "clear", 0));
+
+  JS_SetPropertyStr(ctx, global, "hooksStorage", storage);
+  JS_FreeValue(ctx, global);
+}
+
+} // anonymous namespace
+
+struct QuickJSHookEngine::Impl
+{
+  JSRuntime* rt = nullptr;
+  JSContext* ctx = nullptr;
+
+  struct CompiledScript
+  {
+    // We store compiled bytecode so we don't re-parse every call
+    bool hasEnter = false;
+    bool hasLeave = false;
+  };
+
+  std::map<uint32_t, CompiledScript> scripts;
+  uint32_t nextId = 1;
+};
+
+QuickJSHookEngine::QuickJSHookEngine()
+  : pImpl(std::make_unique<Impl>())
+{
+  pImpl->rt = JS_NewRuntime();
+  pImpl->ctx = JS_NewContext(pImpl->rt);
+
+  InstallHooksStorageBindings(pImpl->ctx);
+}
+
+QuickJSHookEngine::~QuickJSHookEngine()
+{
+  if (pImpl->ctx) {
+    JS_FreeContext(pImpl->ctx);
+  }
+  if (pImpl->rt) {
+    JS_FreeRuntime(pImpl->rt);
+  }
+}
+
+uint32_t QuickJSHookEngine::Compile(const std::string& source,
+                                    const std::string& filename,
+                                    std::string& outError)
+{
+  // We wrap the user source so that enter() and leave() are defined as
+  // properties on a per-script namespace object. The user script should define
+  // function enter(ctx) { ... } and/or function leave(ctx) { ... }.
+  //
+  // We store them as global __hook_N_enter / __hook_N_leave.
+  uint32_t id = pImpl->nextId++;
+  std::string prefix = "__hook_" + std::to_string(id);
+
+  // Wrap in an IIFE that captures enter/leave into globals
+  std::string wrapped = "(function() {\n" + source +
+    "\nif (typeof enter === 'function') globalThis." + prefix +
+    "_enter = enter;\n"
+    "if (typeof leave === 'function') globalThis." +
+    prefix +
+    "_leave = leave;\n"
+    "})();\n";
+
+  JSValue result = JS_Eval(pImpl->ctx, wrapped.c_str(), wrapped.size(),
+                           filename.c_str(), JS_EVAL_TYPE_GLOBAL);
+
+  if (JS_IsException(result)) {
+    outError = GetQJSError(pImpl->ctx);
+    JS_FreeValue(pImpl->ctx, result);
+    pImpl->nextId--; // reclaim the ID
+    return 0;
+  }
+  JS_FreeValue(pImpl->ctx, result);
+
+  // Check which functions were defined
+  Impl::CompiledScript cs;
+  JSValue global = JS_GetGlobalObject(pImpl->ctx);
+
+  JSValue enterFn =
+    JS_GetPropertyStr(pImpl->ctx, global, (prefix + "_enter").c_str());
+  cs.hasEnter = JS_IsFunction(pImpl->ctx, enterFn);
+  JS_FreeValue(pImpl->ctx, enterFn);
+
+  JSValue leaveFn =
+    JS_GetPropertyStr(pImpl->ctx, global, (prefix + "_leave").c_str());
+  cs.hasLeave = JS_IsFunction(pImpl->ctx, leaveFn);
+  JS_FreeValue(pImpl->ctx, leaveFn);
+
+  JS_FreeValue(pImpl->ctx, global);
+
+  if (!cs.hasEnter && !cs.hasLeave) {
+    outError = "Script must define at least one of: enter(ctx), leave(ctx)";
+    return 0;
+  }
+
+  pImpl->scripts[id] = cs;
+  return id;
+}
+
+QuickJSHookEngine::EnterResult QuickJSHookEngine::RunEnter(
+  uint32_t scriptId, uint32_t selfId, const std::string& eventName)
+{
+  EnterResult result;
+  result.eventName = eventName;
+
+  auto it = pImpl->scripts.find(scriptId);
+  if (it == pImpl->scripts.end()) {
+    result.error = "Script not found";
+    return result;
+  }
+
+  if (!it->second.hasEnter) {
+    result.ok = true;
+    return result;
+  }
+
+  std::string prefix = "__hook_" + std::to_string(scriptId);
+  JSContext* ctx = pImpl->ctx;
+
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue enterFn =
+    JS_GetPropertyStr(ctx, global, (prefix + "_enter").c_str());
+
+  // Build context object: { selfId, eventName }
+  JSValue ctxObj = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, ctxObj, "selfId",
+                    JS_NewFloat64(ctx, static_cast<double>(selfId)));
+  JS_SetPropertyStr(ctx, ctxObj, "eventName",
+                    JS_NewStringLen(ctx, eventName.c_str(), eventName.size()));
+
+  JSValue ret = JS_Call(ctx, enterFn, JS_UNDEFINED, 1, &ctxObj);
+
+  if (JS_IsException(ret)) {
+    result.error = GetQJSError(ctx);
+  } else {
+    result.ok = true;
+    // Read back eventName from context (script may have modified it)
+    JSValue updatedName = JS_GetPropertyStr(ctx, ctxObj, "eventName");
+    if (JS_IsString(updatedName)) {
+      const char* s = JS_ToCString(ctx, updatedName);
+      if (s) {
+        result.eventName = s;
+        JS_FreeCString(ctx, s);
+      }
+    }
+    JS_FreeValue(ctx, updatedName);
+  }
+
+  JS_FreeValue(ctx, ret);
+  JS_FreeValue(ctx, ctxObj);
+  JS_FreeValue(ctx, enterFn);
+  JS_FreeValue(ctx, global);
+
+  return result;
+}
+
+QuickJSHookEngine::LeaveResult QuickJSHookEngine::RunLeave(uint32_t scriptId,
+                                                           bool succeeded)
+{
+  LeaveResult result;
+
+  auto it = pImpl->scripts.find(scriptId);
+  if (it == pImpl->scripts.end()) {
+    result.error = "Script not found";
+    return result;
+  }
+
+  if (!it->second.hasLeave) {
+    result.ok = true;
+    return result;
+  }
+
+  std::string prefix = "__hook_" + std::to_string(scriptId);
+  JSContext* ctx = pImpl->ctx;
+
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue leaveFn =
+    JS_GetPropertyStr(ctx, global, (prefix + "_leave").c_str());
+
+  JSValue ctxObj = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, ctxObj, "succeeded", JS_NewBool(ctx, succeeded));
+
+  JSValue ret = JS_Call(ctx, leaveFn, JS_UNDEFINED, 1, &ctxObj);
+
+  if (JS_IsException(ret)) {
+    result.error = GetQJSError(ctx);
+  } else {
+    result.ok = true;
+  }
+
+  JS_FreeValue(ctx, ret);
+  JS_FreeValue(ctx, ctxObj);
+  JS_FreeValue(ctx, leaveFn);
+  JS_FreeValue(ctx, global);
+
+  return result;
+}
+
+void QuickJSHookEngine::RemoveScript(uint32_t scriptId)
+{
+  auto it = pImpl->scripts.find(scriptId);
+  if (it == pImpl->scripts.end()) {
+    return;
+  }
+
+  std::string prefix = "__hook_" + std::to_string(scriptId);
+  JSContext* ctx = pImpl->ctx;
+  JSValue global = JS_GetGlobalObject(ctx);
+
+  // Delete the global functions
+  JSAtom enterAtom = JS_NewAtom(ctx, (prefix + "_enter").c_str());
+  JS_DeleteProperty(ctx, global, enterAtom, 0);
+  JS_FreeAtom(ctx, enterAtom);
+
+  JSAtom leaveAtom = JS_NewAtom(ctx, (prefix + "_leave").c_str());
+  JS_DeleteProperty(ctx, global, leaveAtom, 0);
+  JS_FreeAtom(ctx, leaveAtom);
+
+  JS_FreeValue(ctx, global);
+  pImpl->scripts.erase(it);
+}
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/QuickJSHookEngine.h b/skyrim-platform/src/platform_se/skyrim_platform/QuickJSHookEngine.h
new file mode 100644
index 000000000..a74c81b7b
--- /dev/null
+++ b/skyrim-platform/src/platform_se/skyrim_platform/QuickJSHookEngine.h
@@ -0,0 +1,53 @@
+#pragma once
+#include "HooksStorage.h"
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+// Lightweight JS engine for running hook scripts off the main Node.js thread.
+// Each QuickJSHookEngine owns an independent QuickJS runtime+context with
+// "hooksStorage" bindings already installed so scripts can share state with
+// the Node.js side through HooksStorage.
+class QuickJSHookEngine
+{
+public:
+  QuickJSHookEngine();
+  ~QuickJSHookEngine();
+
+  QuickJSHookEngine(const QuickJSHookEngine&) = delete;
+  QuickJSHookEngine& operator=(const QuickJSHookEngine&) = delete;
+
+  // Compile a script once. Returns an opaque handle (0 on failure).
+  // The error string is set on failure.
+  uint32_t Compile(const std::string& source, const std::string& filename,
+                   std::string& outError);
+
+  // Run the enter callback for a compiled script.
+  // Sets ctx.selfId, ctx.eventName (or the hook-specific variable name)
+  // before calling the global enter() function.
+  // Returns the (possibly modified) eventName.
+  struct EnterResult
+  {
+    std::string eventName;
+    bool ok = false;
+    std::string error;
+  };
+  EnterResult RunEnter(uint32_t scriptId, uint32_t selfId,
+                       const std::string& eventName);
+
+  // Run the leave callback for a compiled script.
+  // Sets ctx.succeeded (if applicable) before calling global leave().
+  struct LeaveResult
+  {
+    bool ok = false;
+    std::string error;
+  };
+  LeaveResult RunLeave(uint32_t scriptId, bool succeeded);
+
+  void RemoveScript(uint32_t scriptId);
+
+private:
+  struct Impl;
+  std::unique_ptr<Impl> pImpl;
+};
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.cpp b/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.cpp
index 373105f02..1b4a763e6 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.cpp
@@ -79,7 +79,8 @@ class CommonExecutionListener : public TickListener
   {
     try {
       GetJsEngine()->AcquireEnvAndCall(
-        [this](Napi::Env env) { TickImpl(env); });
+        [this](Napi::Env env) { TickImpl(env); },
+        "CommonExecutionListener_Tick");
     } catch (const std::exception& e) {
       ExceptionPrinter::Print(e);
     }
@@ -89,7 +90,8 @@ class CommonExecutionListener : public TickListener
   {
     try {
       GetJsEngine()->AcquireEnvAndCall(
-        [this](Napi::Env env) { UpdateImpl(env); });
+        [this](Napi::Env env) { UpdateImpl(env); },
+        "CommonExecutionListener_Update");
     } catch (const std::exception& e) {
       ExceptionPrinter::Print(e);
     }
@@ -365,32 +367,11 @@ class CommonExecutionListener : public TickListener
 };
 }
 
-typedef asio::executor_work_guard<asio::io_context::executor_type> SPWorkGuard;
-
 struct SkyrimPlatform::Impl
 {
   std::shared_ptr<CommonExecutionListener> commonExecutionListener;
   std::vector<std::shared_ptr<TickListener>> tickListeners;
   Viet::TaskQueue<Napi::Env> tickTasks, updateTasks;
-  ThreadPoolWrapper pool;
-
-  // Stuff needed to push functions from js to game thread
-  asio::io_context ioContext;
-  std::mutex syncLock;
-  std::condition_variable conditionalVariable;
-  bool complete;
-  std::shared_ptr<SPWorkGuard> workGuard;
-  void RunInIOContext(RE::BSTSmartPointer<RE::BSScript::IFunction> fPtr,
-                      const RE::BSTSmartPointer<RE::BSScript::Stack>& stack,
-                      RE::BSScript::ErrorLogger* logger,
-                      RE::BSScript::Internal::VirtualMachine* vm,
-                      RE::BSScript::IFunction::CallResult* ret)
-  {
-    *ret = fPtr->Call(stack, logger, vm, false);
-    std::lock_guard<std::mutex> lock(syncLock);
-    complete = true;
-    conditionalVariable.notify_all();
-  }
 };
 
 SkyrimPlatform::SkyrimPlatform()
@@ -401,7 +382,6 @@ SkyrimPlatform::SkyrimPlatform()
 
   pImpl->tickListeners.push_back(std::make_shared<HelloTickListener>());
   pImpl->tickListeners.push_back(pImpl->commonExecutionListener);
-  pImpl->complete = false;
 }
 
 SkyrimPlatform* SkyrimPlatform::GetSingleton()
@@ -438,20 +418,29 @@ void SkyrimPlatform::AddUpdateTask(const std::function<void(Napi::Env)>& f)
   pImpl->updateTasks.AddTask(f);
 }
 
-void SkyrimPlatform::PushAndWait(const std::function<void(Napi::Env)>& f)
+void SkyrimPlatform::RunTask(const std::function<void(Napi::Env)>& f)
 {
-  pImpl->pool.PushAndWait([this, f] {
-    auto engine = pImpl->commonExecutionListener->GetJsEngine();
-    engine->AcquireEnvAndCall(f);
-  });
+  auto engine = pImpl->commonExecutionListener->GetJsEngine();
+  engine->AcquireEnvAndCall(f, "SkyrimPlatform_RunTask");
 }
 
-void SkyrimPlatform::Push(const std::function<void(Napi::Env)>& f)
+std::future<void> SkyrimPlatform::QueueTask(
+  const std::function<void(Napi::Env env)>& task)
 {
-  pImpl->pool.Push([this, f] {
-    auto engine = pImpl->commonExecutionListener->GetJsEngine();
-    engine->AcquireEnvAndCall(f);
+  std::shared_ptr<std::promise<void>> promise =
+    std::make_shared<std::promise<void>>();
+  std::future<void> future = promise->get_future();
+
+  pImpl->tickTasks.AddTask([task, promise](Napi::Env env) {
+    try {
+      task(env);
+      promise->set_value();
+    } catch (...) {
+      promise->set_exception(std::current_exception());
+    }
   });
+
+  return future;
 }
 
 void SkyrimPlatform::PushToWorkerAndWait(
@@ -461,30 +450,5 @@ void SkyrimPlatform::PushToWorkerAndWait(
   RE::BSScript::Internal::VirtualMachine* vm,
   RE::BSScript::IFunction::CallResult* ret)
 {
-  std::unique_lock<std::mutex> lock(pImpl->syncLock);
-  pImpl->complete = false;
-  asio::post(
-    pImpl->ioContext.get_executor(),
-    std::bind(&Impl::RunInIOContext, pImpl, fPtr, stack, logger, vm, ret));
-  pImpl->conditionalVariable.wait(
-    lock, [] { return SkyrimPlatform::GetSingleton()->pImpl->complete; });
-}
-
-void SkyrimPlatform::PrepareWorker()
-{
-  if (pImpl->ioContext.stopped()) {
-    pImpl->ioContext.restart();
-  }
-  pImpl->workGuard =
-    std::make_shared<SPWorkGuard>(pImpl->ioContext.get_executor());
-}
-
-void SkyrimPlatform::StartWorker()
-{
-  pImpl->ioContext.run();
-}
-
-void SkyrimPlatform::StopWorker()
-{
-  pImpl->ioContext.stop();
+  *ret = fPtr->Call(stack, logger, vm, false);
 }
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.h b/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.h
index d6e323415..cc360b4e3 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/SkyrimPlatform.h
@@ -1,6 +1,8 @@
 #pragma once
 #include "TPOverlayService.h"
 
+#include <future>
+
 class SkyrimPlatform
 {
 public:
@@ -9,17 +11,19 @@ class SkyrimPlatform
   void JsTick(Napi::Env env, bool gameFunctionsAvailable);
   void AddTickTask(const std::function<void(Napi::Env env)>& f);
   void AddUpdateTask(const std::function<void(Napi::Env env)>& f);
-  void PushAndWait(const std::function<void(Napi::Env env)>& task);
-  void Push(const std::function<void(Napi::Env env)>& task);
+
+  // Must be called in main game thread
+  void RunTask(const std::function<void(Napi::Env env)>& task);
+
+  // Must be called from non-main game thread (i.e. Anim event hook)
+  std::future<void> QueueTask(const std::function<void(Napi::Env env)>& task);
+
   void PushToWorkerAndWait(
     RE::BSTSmartPointer<RE::BSScript::IFunction> fPtr,
     const RE::BSTSmartPointer<RE::BSScript::Stack>& stack,
     RE::BSScript::ErrorLogger* logger,
     RE::BSScript::Internal::VirtualMachine* vm,
     RE::BSScript::IFunction::CallResult* ret);
-  void PrepareWorker();
-  void StartWorker();
-  void StopWorker();
 
 private:
   SkyrimPlatform();
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/TickHandler.h b/skyrim-platform/src/platform_se/skyrim_platform/TickHandler.h
index 3914b0885..a2095acda 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/TickHandler.h
+++ b/skyrim-platform/src/platform_se/skyrim_platform/TickHandler.h
@@ -14,18 +14,17 @@ class TickHandler
 
   void Update()
   {
-    _threadPool->Push([=] { _taskInterface->AddTask(onTick); });
+    // Must be async to avoid infinite loop in SKSE's task drain.
+    // Synchronous AddTask from within a task callback causes SKSE to
+    // immediately re-process the newly added task in the same frame.
+    _threadPool.Push([this] { _taskInterface->AddTask(onTick); });
   }
 
 private:
-  TickHandler()
-  {
-    _taskInterface = SKSE::GetTaskInterface();
-    _threadPool = std::make_shared<ThreadPoolWrapper>();
-  }
+  TickHandler() { _taskInterface = SKSE::GetTaskInterface(); }
 
   const std::function<void()> onTick = [] {
-    SkyrimPlatform::GetSingleton()->PushAndWait([=](Napi::Env env) {
+    SkyrimPlatform::GetSingleton()->RunTask([=](Napi::Env env) {
       SkyrimPlatform::GetSingleton()->JsTick(env, false);
     });
     TESModPlatform::Update();
@@ -33,5 +32,5 @@ class TickHandler
   };
 
   const SKSE::TaskInterface* _taskInterface;
-  std::shared_ptr<ThreadPoolWrapper> _threadPool;
+  ThreadPoolWrapper _threadPool{ 1 };
 };
diff --git a/skyrim-platform/src/platform_se/skyrim_platform/main.cpp b/skyrim-platform/src/platform_se/skyrim_platform/main.cpp
index 124640dab..291bd12e1 100644
--- a/skyrim-platform/src/platform_se/skyrim_platform/main.cpp
+++ b/skyrim-platform/src/platform_se/skyrim_platform/main.cpp
@@ -75,12 +75,8 @@ void OnUpdate(IVM* vm, StackID stackId)
 
   g_nativeCallRequirements.stackId = stackId;
   g_nativeCallRequirements.vm = vm;
-  SkyrimPlatform::GetSingleton()->PrepareWorker();
-  SkyrimPlatform::GetSingleton()->Push([=](Napi::Env env) {
-    SkyrimPlatform::GetSingleton()->JsTick(env, true);
-    SkyrimPlatform::GetSingleton()->StopWorker();
-  });
-  SkyrimPlatform::GetSingleton()->StartWorker();
+  SkyrimPlatform::GetSingleton()->RunTask(
+    [=](Napi::Env env) { SkyrimPlatform::GetSingleton()->JsTick(env, true); });
   g_nativeCallRequirements.gameThrQ->Update(Viet::Void());
   g_nativeCallRequirements.stackId = std::numeric_limits<StackID>::max();
   g_nativeCallRequirements.vm = nullptr;
diff --git a/vcpkg.json b/vcpkg.json
index 9ee6bbb39..0b254245e 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -21,6 +21,7 @@
     "prometheus-cpp-lite",
     "slikenet",
     "libsodium",
+    "quickjs-ng",
     {
       "name": "mongo-cxx-driver",
       "platform": "!emscripten"