diff --git a/NativeScript/NativeScript-Prefix.pch b/NativeScript/NativeScript-Prefix.pch
index ec0604b8..11999277 100644
--- a/NativeScript/NativeScript-Prefix.pch
+++ b/NativeScript/NativeScript-Prefix.pch
@@ -1,7 +1,7 @@
 #ifndef NativeScript_Prefix_pch
 #define NativeScript_Prefix_pch
 
-#define NATIVESCRIPT_VERSION "8.9.0"
+#define NATIVESCRIPT_VERSION "9.0.0-esm.2"
 
 #ifdef DEBUG
 #define SIZEOF_OFF_T 8
diff --git a/NativeScript/runtime/FFICall.h b/NativeScript/runtime/FFICall.h
index c2f35549..46666405 100644
--- a/NativeScript/runtime/FFICall.h
+++ b/NativeScript/runtime/FFICall.h
@@ -2,117 +2,127 @@
 #define FFICall_h
 
 #include <malloc/malloc.h>
+
 #include <map>
-#include "robin_hood.h"
-#include "Metadata.h"
+
 #include "DataWrapper.h"
+#include "Metadata.h"
 #include "libffi.h"
+#include "robin_hood.h"
 
 namespace tns {
 
 class BaseCall {
-public:
-    BaseCall(uint8_t* buffer, size_t returnOffset = 0)
-        : buffer_(buffer),
-          returnOffset_(returnOffset) {
-    }
+ public:
+  BaseCall(uint8_t* buffer, size_t returnOffset = 0)
+      : buffer_(buffer), returnOffset_(returnOffset) {}
 
-    ~BaseCall() {
-    }
+  ~BaseCall() {}
 
-    inline void* ResultBuffer() {
-        return this->buffer_ + this->returnOffset_;
-    }
+  inline void* ResultBuffer() { return this->buffer_ + this->returnOffset_; }
 
-    template <typename T>
-    inline T& GetResult() {
-        return *static_cast<T*>(this->ResultBuffer());
-    }
-protected:
-    uint8_t* buffer_;
-    size_t returnOffset_;
+  template <typename T>
+  inline T& GetResult() {
+    return *static_cast<T*>(this->ResultBuffer());
+  }
+
+ protected:
+  uint8_t* buffer_;
+  size_t returnOffset_;
 };
 
 class ParametrizedCall {
-public:
-    ParametrizedCall(ffi_cif* cif)
-        : Cif(cif),
-          ReturnOffset(0),
-          StackSize(0) {
-        unsigned int argsCount = cif->nargs;
-        this->StackSize = 0;
-
-        if (argsCount > 0) {
-            this->StackSize = malloc_good_size(sizeof(void* [argsCount]));
-        }
-
-        this->ReturnOffset = this->StackSize;
-
-        this->StackSize += malloc_good_size(std::max(cif->rtype->size, sizeof(ffi_arg)));
-
-        this->ArgValueOffsets.reserve(argsCount);
-        for (size_t i = 0; i < argsCount; i++) {
-            this->ArgValueOffsets.push_back(this->StackSize);
-            ffi_type* argType = cif->arg_types[i];
-            this->StackSize += malloc_good_size(std::max(argType->size, sizeof(ffi_arg)));
-        }
+ public:
+  ParametrizedCall(ffi_cif* cif) : Cif(cif), ReturnOffset(0), StackSize(0) {
+    unsigned int argsCount = cif->nargs;
+    this->StackSize = 0;
+
+    if (argsCount > 0) {
+      // compute total bytes = number of pointers × size of a pointer
+      size_t needed = sizeof(void*) * static_cast<size_t>(argsCount);
+      this->StackSize = malloc_good_size(needed);
     }
 
-    static ParametrizedCall* Get(const TypeEncoding* typeEncoding, const int initialParameterIndex, const int argsCount);
+    this->ReturnOffset = this->StackSize;
 
-    ffi_cif* Cif;
-    size_t ReturnOffset;
-    size_t StackSize;
-    std::vector<size_t> ArgValueOffsets;
-private:
-    static robin_hood::unordered_map<const TypeEncoding*, ParametrizedCall*> callsCache_;
-};
+    this->StackSize +=
+        malloc_good_size(std::max(cif->rtype->size, sizeof(ffi_arg)));
 
-class FFICall: public BaseCall {
-public:
-    FFICall(ParametrizedCall* parametrizedCall): BaseCall(nullptr) {
-        this->returnOffset_ = parametrizedCall->ReturnOffset;
-        this->useDynamicBuffer_ = parametrizedCall->StackSize > 512;
-        if(this->useDynamicBuffer_) {
-            this->buffer_ = reinterpret_cast<uint8_t*>(malloc(parametrizedCall->StackSize));
-        } else {
-            this->buffer_ = reinterpret_cast<uint8_t*>(this->staticBuffer);
-        }
-
-        this->argsArray_ = reinterpret_cast<void**>(this->buffer_);
-        for (size_t i = 0; i < parametrizedCall->Cif->nargs; i++) {
-            this->argsArray_[i] = this->buffer_ + parametrizedCall->ArgValueOffsets[i];
-        }
+    this->ArgValueOffsets.reserve(argsCount);
+    for (size_t i = 0; i < argsCount; i++) {
+      this->ArgValueOffsets.push_back(this->StackSize);
+      ffi_type* argType = cif->arg_types[i];
+      this->StackSize +=
+          malloc_good_size(std::max(argType->size, sizeof(ffi_arg)));
     }
+  }
 
-    ~FFICall() {
-        if(this->useDynamicBuffer_) {
-          free(this->buffer_);
-        }
-    }
+  static ParametrizedCall* Get(const TypeEncoding* typeEncoding,
+                               const int initialParameterIndex,
+                               const int argsCount);
 
-    /**
-     When calling this, always make another call to DisposeFFIType with the same parameters
-     */
-    static ffi_type* GetArgumentType(const TypeEncoding* typeEncoding, bool isStructMember = false);
-    static void DisposeFFIType(ffi_type* type, const TypeEncoding* typeEncoding);
-    static StructInfo GetStructInfo(const StructMeta* structMeta, std::string structName = "");
-    static StructInfo GetStructInfo(size_t fieldsCount, const TypeEncoding* fieldEncoding, const String* fieldNames, std::string structName = "");
+  ffi_cif* Cif;
+  size_t ReturnOffset;
+  size_t StackSize;
+  std::vector<size_t> ArgValueOffsets;
+
+ private:
+  static robin_hood::unordered_map<const TypeEncoding*, ParametrizedCall*>
+      callsCache_;
+};
+
+class FFICall : public BaseCall {
+ public:
+  FFICall(ParametrizedCall* parametrizedCall) : BaseCall(nullptr) {
+    this->returnOffset_ = parametrizedCall->ReturnOffset;
+    this->useDynamicBuffer_ = parametrizedCall->StackSize > 512;
+    if (this->useDynamicBuffer_) {
+      this->buffer_ =
+          reinterpret_cast<uint8_t*>(malloc(parametrizedCall->StackSize));
+    } else {
+      this->buffer_ = reinterpret_cast<uint8_t*>(this->staticBuffer);
+    }
 
-    inline void* ArgumentBuffer(unsigned index) {
-        return this->argsArray_[index];
+    this->argsArray_ = reinterpret_cast<void**>(this->buffer_);
+    for (size_t i = 0; i < parametrizedCall->Cif->nargs; i++) {
+      this->argsArray_[i] =
+          this->buffer_ + parametrizedCall->ArgValueOffsets[i];
     }
+  }
 
-    inline void** ArgsArray() {
-        return this->argsArray_;
+  ~FFICall() {
+    if (this->useDynamicBuffer_) {
+      free(this->buffer_);
     }
-private:
-    static robin_hood::unordered_map<std::string, StructInfo> structInfosCache_;
-    void** argsArray_;
-    bool useDynamicBuffer_;
-    uint8_t staticBuffer[512];
+  }
+
+  /**
+   When calling this, always make another call to DisposeFFIType with the same
+   parameters
+   */
+  static ffi_type* GetArgumentType(const TypeEncoding* typeEncoding,
+                                   bool isStructMember = false);
+  static void DisposeFFIType(ffi_type* type, const TypeEncoding* typeEncoding);
+  static StructInfo GetStructInfo(const StructMeta* structMeta,
+                                  std::string structName = "");
+  static StructInfo GetStructInfo(size_t fieldsCount,
+                                  const TypeEncoding* fieldEncoding,
+                                  const String* fieldNames,
+                                  std::string structName = "");
+
+  inline void* ArgumentBuffer(unsigned index) {
+    return this->argsArray_[index];
+  }
+
+  inline void** ArgsArray() { return this->argsArray_; }
+
+ private:
+  static robin_hood::unordered_map<std::string, StructInfo> structInfosCache_;
+  void** argsArray_;
+  bool useDynamicBuffer_;
+  uint8_t staticBuffer[512];
 };
 
-}
+}  // namespace tns
 
 #endif /* FFICall_h */
diff --git a/NativeScript/runtime/Helpers.mm b/NativeScript/runtime/Helpers.mm
index db93fcb2..73f5621a 100644
--- a/NativeScript/runtime/Helpers.mm
+++ b/NativeScript/runtime/Helpers.mm
@@ -1,961 +1,851 @@
+#include "Helpers.h"
 #include <Foundation/Foundation.h>
+#include <cxxabi.h>
 #include <dispatch/dispatch.h>
-#include <sys/stat.h>
+#include <dlfcn.h>
 #include <execinfo.h>
-#include <fstream>
+#include <stdio.h>
+#include <sys/stat.h>
 #include <codecvt>
+#include <fstream>
 #include <locale>
-#include <stdio.h>
 #include <sstream>
-#include <dlfcn.h>
-#include <cxxabi.h>
-#include "RuntimeConfig.h"
-#include "Runtime.h"
-#include "Helpers.h"
 #include "Caches.h"
+#include "NativeScriptException.h"
+#include "Runtime.h"
+#include "RuntimeConfig.h"
 
 using namespace v8;
 
 namespace {
-    const int BUFFER_SIZE = 1024 * 1024;
-    char* Buffer = new char[BUFFER_SIZE];
-    uint8_t* BinBuffer = new uint8_t[BUFFER_SIZE];
+const int BUFFER_SIZE = 1024 * 1024;
+char* Buffer = new char[BUFFER_SIZE];
+uint8_t* BinBuffer = new uint8_t[BUFFER_SIZE];
 }
 
 std::u16string tns::ToUtf16String(Isolate* isolate, const Local<Value>& value) {
-    std::string valueStr = tns::ToString(isolate, value);
+  std::string valueStr = tns::ToString(isolate, value);
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    // FIXME: std::codecvt_utf8_utf16 is deprecated
-    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    std::u16string value16 = convert.from_bytes(valueStr);
+  // FIXME: std::codecvt_utf8_utf16 is deprecated
+  std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
+  std::u16string value16 = convert.from_bytes(valueStr);
 
-    return value16;
+  return value16;
 }
 
 std::vector<uint16_t> tns::ToVector(const std::string& value) {
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    // FIXME: std::codecvt_utf8_utf16 is deprecated
-    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    std::u16string value16 = convert.from_bytes(value);
+  // FIXME: std::codecvt_utf8_utf16 is deprecated
+  std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
+  std::u16string value16 = convert.from_bytes(value);
 
-    const uint16_t *begin = reinterpret_cast<uint16_t const*>(value16.data());
-    const uint16_t *end = reinterpret_cast<uint16_t const*>(value16.data() + value16.size());
-    std::vector<uint16_t> vector(begin, end);
-    return vector;
+  const uint16_t* begin = reinterpret_cast<uint16_t const*>(value16.data());
+  const uint16_t* end = reinterpret_cast<uint16_t const*>(value16.data() + value16.size());
+  std::vector<uint16_t> vector(begin, end);
+  return vector;
 }
 
 bool tns::Exists(const char* fullPath) {
-    struct stat statbuf;
-    mode_t mode = S_IFDIR | S_IFREG;
-    if (stat(fullPath, &statbuf) == 0) {
-        return (statbuf.st_mode & S_IFMT) & mode;
-    }
+  struct stat statbuf;
+  mode_t mode = S_IFDIR | S_IFREG;
+  if (stat(fullPath, &statbuf) == 0) {
+    return (statbuf.st_mode & S_IFMT) & mode;
+  }
 
-    return false;
+  return false;
 }
 
-Local<v8::String> tns::ReadModule(Isolate* isolate, const std::string &filePath) {
-    struct stat finfo;
+Local<v8::String> tns::ReadModule(Isolate* isolate, const std::string& filePath) {
+  struct stat finfo;
 
-    int file = open(filePath.c_str(), O_RDONLY);
-    if (file < 0) {
-        tns::Assert(false);
-    }
+  int file = open(filePath.c_str(), O_RDONLY);
+  if (file < 0) {
+    throw NativeScriptException(isolate, "Cannot read module " + filePath);
+  }
 
-    fstat(file, &finfo);
-    long length = finfo.st_size;
+  fstat(file, &finfo);
+  long length = finfo.st_size;
 
-    char* newBuffer = new char[length + 128];
-    strcpy(newBuffer, "(function(module, exports, require, __filename, __dirname) { ");  // 61 Characters
-    read(file, &newBuffer[61], length);
-    close(file);
-    length += 61;
+  char* newBuffer = new char[length + 128];
+  strcpy(newBuffer,
+         "(function(module, exports, require, __filename, __dirname) { ");  // 61 Characters
+  read(file, &newBuffer[61], length);
+  close(file);
+  length += 61;
 
-    // Add the closing "\n})"
-    newBuffer[length] = 10;
-    ++length;
-    newBuffer[length] = '}';
-    ++length;
-    newBuffer[length] = ')';
-    ++length;
-    newBuffer[length] = 0;
+  // Add the closing "\n})"
+  newBuffer[length] = 10;
+  ++length;
+  newBuffer[length] = '}';
+  ++length;
+  newBuffer[length] = ')';
+  ++length;
+  newBuffer[length] = 0;
 
-    Local<v8::String> str = v8::String::NewFromUtf8(isolate, newBuffer, NewStringType::kNormal, (int)length).ToLocalChecked();
-    delete[] newBuffer;
+  Local<v8::String> str =
+      v8::String::NewFromUtf8(isolate, newBuffer, NewStringType::kNormal, (int)length)
+          .ToLocalChecked();
+  delete[] newBuffer;
 
-    return str;
+  return str;
 }
 
 const char* tns::ReadText(const std::string& filePath, long& length, bool& isNew) {
-    FILE* file = fopen(filePath.c_str(), "rb");
-    if (file == nullptr) {
-        tns::Assert(false);
-    }
+  FILE* file = fopen(filePath.c_str(), "rb");
+  if (file == nullptr) {
+    tns::Assert(false);
+  }
 
-    fseek(file, 0, SEEK_END);
+  fseek(file, 0, SEEK_END);
 
-    length = ftell(file);
-    isNew = length > BUFFER_SIZE;
+  length = ftell(file);
+  isNew = length > BUFFER_SIZE;
 
-    rewind(file);
+  rewind(file);
 
-    if (isNew) {
-        char* newBuffer = new char[length];
-        fread(newBuffer, 1, length, file);
-        fclose(file);
+  if (isNew) {
+    char* newBuffer = new char[length];
+    fread(newBuffer, 1, length, file);
+    fclose(file);
 
-        return newBuffer;
-    }
+    return newBuffer;
+  }
 
-    fread(Buffer, 1, length, file);
-    fclose(file);
+  fread(Buffer, 1, length, file);
+  fclose(file);
 
-    return Buffer;
+  return Buffer;
 }
 
 std::string tns::ReadText(const std::string& file) {
-    long length;
-    bool isNew;
-    const char* content = tns::ReadText(file, length, isNew);
+  long length;
+  bool isNew;
+  const char* content = tns::ReadText(file, length, isNew);
 
-    std::string result(content, length);
+  std::string result(content, length);
 
-    if (isNew) {
-        delete[] content;
-    }
+  if (isNew) {
+    delete[] content;
+  }
 
-    return result;
+  return result;
 }
 
 uint8_t* tns::ReadBinary(const std::string path, long& length, bool& isNew) {
-    length = 0;
-    std::ifstream ifs(path);
-    if (ifs.fail()) {
-        return nullptr;
-    }
-
-    FILE* file = fopen(path.c_str(), "rb");
-    if (!file) {
-        return nullptr;
-    }
-
-    fseek(file, 0, SEEK_END);
-    length = ftell(file);
-    rewind(file);
-
-    isNew = length > BUFFER_SIZE;
-
-    if (isNew) {
-        uint8_t* data = new uint8_t[length];
-        fread(data, sizeof(uint8_t), length, file);
-        fclose(file);
-        return data;
-    }
-
-    fread(BinBuffer, 1, length, file);
+  length = 0;
+  std::ifstream ifs(path);
+  if (ifs.fail()) {
+    return nullptr;
+  }
+
+  FILE* file = fopen(path.c_str(), "rb");
+  if (!file) {
+    return nullptr;
+  }
+
+  fseek(file, 0, SEEK_END);
+  length = ftell(file);
+  rewind(file);
+
+  isNew = length > BUFFER_SIZE;
+
+  if (isNew) {
+    uint8_t* data = new uint8_t[length];
+    fread(data, sizeof(uint8_t), length, file);
     fclose(file);
+    return data;
+  }
+
+  fread(BinBuffer, 1, length, file);
+  fclose(file);
 
-    return BinBuffer;
+  return BinBuffer;
 }
 
 bool tns::WriteBinary(const std::string& path, const void* data, long length) {
-    FILE* file = fopen(path.c_str(), "wb");
-    if (!file) {
-        return false;
-    }
+  FILE* file = fopen(path.c_str(), "wb");
+  if (!file) {
+    return false;
+  }
 
-    size_t writtenBytes = fwrite(data, sizeof(uint8_t), length, file);
-    fclose(file);
+  size_t writtenBytes = fwrite(data, sizeof(uint8_t), length, file);
+  fclose(file);
 
-    return writtenBytes == length;
+  return writtenBytes == length;
 }
 
-void tns::SetPrivateValue(const Local<Object>& obj, const Local<v8::String>& propName, const Local<Value>& value) {
-    Local<Context> context;
-    bool success = obj->GetCreationContext().ToLocal(&context);
-    tns::Assert(success);
-    Isolate* isolate = context->GetIsolate();
-    Local<Private> privateKey = Private::ForApi(isolate, propName);
+void tns::SetPrivateValue(const Local<Object>& obj, const Local<v8::String>& propName,
+                          const Local<Value>& value) {
+  Local<Context> context;
+  bool success = obj->GetCreationContext().ToLocal(&context);
+  tns::Assert(success);
+  Isolate* isolate = context->GetIsolate();
+  Local<Private> privateKey = Private::ForApi(isolate, propName);
 
-    if (!obj->SetPrivate(context, privateKey, value).To(&success) || !success) {
-        tns::Assert(false, isolate);
-    }
+  if (!obj->SetPrivate(context, privateKey, value).To(&success) || !success) {
+    tns::Assert(false, isolate);
+  }
 }
 
 Local<Value> tns::GetPrivateValue(const Local<Object>& obj, const Local<v8::String>& propName) {
-    Local<Context> context;
-    bool success = obj->GetCreationContext().ToLocal(&context);
-    tns::Assert(success);
-    Isolate* isolate = context->GetIsolate();
-    Local<Private> privateKey = Private::ForApi(isolate, propName);
+  Local<Context> context;
+  bool success = obj->GetCreationContext().ToLocal(&context);
+  tns::Assert(success);
+  Isolate* isolate = context->GetIsolate();
+  Local<Private> privateKey = Private::ForApi(isolate, propName);
 
-    Maybe<bool> hasPrivate = obj->HasPrivate(context, privateKey);
+  Maybe<bool> hasPrivate = obj->HasPrivate(context, privateKey);
 
-    tns::Assert(!hasPrivate.IsNothing(), isolate);
+  tns::Assert(!hasPrivate.IsNothing(), isolate);
 
-    if (!hasPrivate.FromMaybe(false)) {
-        return Local<Value>();
-    }
+  if (!hasPrivate.FromMaybe(false)) {
+    return Local<Value>();
+  }
 
-    v8::Locker locker(isolate);
-    Local<Value> result;
-    if (!obj->GetPrivate(context, privateKey).ToLocal(&result)) {
-        tns::Assert(false, isolate);
-    }
+  v8::Locker locker(isolate);
+  Local<Value> result;
+  if (!obj->GetPrivate(context, privateKey).ToLocal(&result)) {
+    tns::Assert(false, isolate);
+  }
 
-    return result;
+  return result;
 }
 
 bool tns::DeleteWrapperIfUnused(Isolate* isolate, const Local<Value>& obj, BaseDataWrapper* value) {
-    if (GetValue(isolate, obj) != value) {
-        delete value;
-        return true;
-    }
-    return false;
+  if (GetValue(isolate, obj) != value) {
+    delete value;
+    return true;
+  }
+  return false;
 }
 
 void tns::SetValue(Isolate* isolate, const Local<Object>& obj, BaseDataWrapper* value) {
-    if (obj.IsEmpty() || obj->IsNullOrUndefined()) {
-        return;
-    }
+  if (obj.IsEmpty() || obj->IsNullOrUndefined()) {
+    return;
+  }
 
-    Local<External> ext = External::New(isolate, value);
+  Local<External> ext = External::New(isolate, value);
 
-    if (obj->InternalFieldCount() > 0) {
-        obj->SetInternalField(0, ext);
-    } else {
-        tns::SetPrivateValue(obj, tns::ToV8String(isolate, "metadata"), ext);
-    }
+  if (obj->InternalFieldCount() > 0) {
+    obj->SetInternalField(0, ext);
+  } else {
+    tns::SetPrivateValue(obj, tns::ToV8String(isolate, "metadata"), ext);
+  }
 }
 
 tns::BaseDataWrapper* tns::GetValue(Isolate* isolate, const Local<Value>& val) {
-    if (val.IsEmpty() || val->IsNullOrUndefined() || !val->IsObject()) {
-        return nullptr;
-    }
-
-    Local<Object> obj = val.As<Object>();
-    if (obj->InternalFieldCount() > 0) {
-        Local<Value> field = obj->GetInternalField(0);
-        if (field.IsEmpty() || field->IsNullOrUndefined() || !field->IsExternal()) {
-            return nullptr;
-        }
+  if (val.IsEmpty() || val->IsNullOrUndefined() || !val->IsObject()) {
+    return nullptr;
+  }
 
-        return static_cast<BaseDataWrapper*>(field.As<External>()->Value());
+  Local<Object> obj = val.As<Object>();
+  if (obj->InternalFieldCount() > 0) {
+    Local<Value> field = obj->GetInternalField(0);
+    if (field.IsEmpty() || field->IsNullOrUndefined() || !field->IsExternal()) {
+      return nullptr;
     }
 
-    Local<Value> metadataProp = tns::GetPrivateValue(obj, tns::ToV8String(isolate, "metadata"));
-    if (metadataProp.IsEmpty() || metadataProp->IsNullOrUndefined() || !metadataProp->IsExternal()) {
-        return nullptr;
-    }
+    return static_cast<BaseDataWrapper*>(field.As<External>()->Value());
+  }
 
-    return static_cast<BaseDataWrapper*>(metadataProp.As<External>()->Value());
+  Local<Value> metadataProp = tns::GetPrivateValue(obj, tns::ToV8String(isolate, "metadata"));
+  if (metadataProp.IsEmpty() || metadataProp->IsNullOrUndefined() || !metadataProp->IsExternal()) {
+    return nullptr;
+  }
+
+  return static_cast<BaseDataWrapper*>(metadataProp.As<External>()->Value());
 }
 
 void tns::DeleteValue(Isolate* isolate, const Local<Value>& val) {
-    if (val.IsEmpty() || val->IsNullOrUndefined() || !val->IsObject()) {
-        return;
-    }
+  if (val.IsEmpty() || val->IsNullOrUndefined() || !val->IsObject()) {
+    return;
+  }
 
-    Local<Object> obj = val.As<Object>();
-    if (obj->InternalFieldCount() > 0) {
-        obj->SetInternalField(0, v8::Undefined(isolate));
-        return;
-    }
+  Local<Object> obj = val.As<Object>();
+  if (obj->InternalFieldCount() > 0) {
+    obj->SetInternalField(0, v8::Undefined(isolate));
+    return;
+  }
 
-    Local<v8::String> metadataKey = tns::ToV8String(isolate, "metadata");
-    Local<Value> metadataProp = tns::GetPrivateValue(obj, metadataKey);
-    if (metadataProp.IsEmpty() || metadataProp->IsNullOrUndefined() || !metadataProp->IsExternal()) {
-        return;
-    }
+  Local<v8::String> metadataKey = tns::ToV8String(isolate, "metadata");
+  Local<Value> metadataProp = tns::GetPrivateValue(obj, metadataKey);
+  if (metadataProp.IsEmpty() || metadataProp->IsNullOrUndefined() || !metadataProp->IsExternal()) {
+    return;
+  }
 
-    Local<Context> context;
-    bool success = obj->GetCreationContext().ToLocal(&context);
-    tns::Assert(success, isolate);
-    Local<Private> privateKey = Private::ForApi(isolate, metadataKey);
+  Local<Context> context;
+  bool success = obj->GetCreationContext().ToLocal(&context);
+  tns::Assert(success, isolate);
+  Local<Private> privateKey = Private::ForApi(isolate, metadataKey);
 
-    success = obj->DeletePrivate(context, privateKey).FromMaybe(false);
-    tns::Assert(success, isolate);
+  success = obj->DeletePrivate(context, privateKey).FromMaybe(false);
+  tns::Assert(success, isolate);
 }
 
 std::vector<Local<Value>> tns::ArgsToVector(const FunctionCallbackInfo<Value>& info) {
-    std::vector<Local<Value>> args;
-    args.reserve(info.Length());
-    for (int i = 0; i < info.Length(); i++) {
-        args.push_back(info[i]);
-    }
-    return args;
+  std::vector<Local<Value>> args;
+  args.reserve(info.Length());
+  for (int i = 0; i < info.Length(); i++) {
+    args.push_back(info[i]);
+  }
+  return args;
 }
 
 bool tns::IsArrayOrArrayLike(Isolate* isolate, const Local<Value>& value) {
-    if (value->IsArray()) {
-        return true;
-    }
+  if (value->IsArray()) {
+    return true;
+  }
 
-    if (!value->IsObject()) {
-        return false;
-    }
+  if (!value->IsObject()) {
+    return false;
+  }
 
-    Local<Object> obj = value.As<Object>();
-    Local<Context> context;
-    bool success = obj->GetCreationContext().ToLocal(&context);
-    tns::Assert(success, isolate);
-    return obj->Has(context, ToV8String(isolate, "length")).FromMaybe(false);
+  Local<Object> obj = value.As<Object>();
+  Local<Context> context;
+  bool success = obj->GetCreationContext().ToLocal(&context);
+  tns::Assert(success, isolate);
+  return obj->Has(context, ToV8String(isolate, "length")).FromMaybe(false);
 }
 
 void* tns::TryGetBufferFromArrayBuffer(const v8::Local<v8::Value>& value, bool& isArrayBuffer) {
-    isArrayBuffer = false;
+  isArrayBuffer = false;
 
-    if (value.IsEmpty() || (!value->IsArrayBuffer() && !value->IsArrayBufferView())) {
-        return nullptr;
-    }
+  if (value.IsEmpty() || (!value->IsArrayBuffer() && !value->IsArrayBufferView())) {
+    return nullptr;
+  }
 
-    Local<ArrayBuffer> buffer;
-    if (value->IsArrayBufferView()) {
-        isArrayBuffer = true;
-        buffer = value.As<ArrayBufferView>()->Buffer();
-    } else if (value->IsArrayBuffer()) {
-        isArrayBuffer = true;
-        buffer = value.As<ArrayBuffer>();
-    }
+  Local<ArrayBuffer> buffer;
+  if (value->IsArrayBufferView()) {
+    isArrayBuffer = true;
+    buffer = value.As<ArrayBufferView>()->Buffer();
+  } else if (value->IsArrayBuffer()) {
+    isArrayBuffer = true;
+    buffer = value.As<ArrayBuffer>();
+  }
 
-    if (buffer.IsEmpty()) {
-        return nullptr;
-    }
+  if (buffer.IsEmpty()) {
+    return nullptr;
+  }
 
-    void* data = buffer->GetBackingStore()->Data();
-    return data;
+  void* data = buffer->GetBackingStore()->Data();
+  return data;
 }
 
 struct LockAndCV {
-    std::mutex m;
-    std::condition_variable cv;
+  std::mutex m;
+  std::condition_variable cv;
 };
 
-void tns::ExecuteOnRunLoop(CFRunLoopRef queue, std::function<void ()> func, bool async) {
-    if(!async) {
-        bool __block finished = false;
-        auto v = new LockAndCV;
-        std::unique_lock<std::mutex> lock(v->m);
-        CFRunLoopPerformBlock(queue, kCFRunLoopCommonModes, ^(void) {
-            func();
-            {
-                std::unique_lock lk(v->m);
-                finished = true;
-            }
-            v->cv.notify_all();
-        });
-        CFRunLoopWakeUp(queue);
-        while(!finished) {
-            v->cv.wait(lock);
-        }
-        delete v;
-    } else {
-        CFRunLoopPerformBlock(queue, kCFRunLoopCommonModes, ^(void) {
-            func();
-        });
-        CFRunLoopWakeUp(queue);
-    }
-    
-}
-
-void tns::ExecuteOnDispatchQueue(dispatch_queue_t queue, std::function<void ()> func, bool async) {
-    if (async) {
-        dispatch_async(queue, ^(void) {
-            func();
-        });
-    } else {
-        dispatch_sync(queue, ^(void) {
-            func();
-        });
-    }
-}
-
-void tns::ExecuteOnMainThread(std::function<void ()> func, bool async) {
-    if (async) {
-        dispatch_async(dispatch_get_main_queue(), ^(void) {
-            func();
-        });
-    } else {
-        dispatch_sync(dispatch_get_main_queue(), ^(void) {
-            func();
-        });
-    }
+void tns::ExecuteOnRunLoop(CFRunLoopRef queue, std::function<void()> func, bool async) {
+  if (!async) {
+    bool __block finished = false;
+    auto v = new LockAndCV;
+    std::unique_lock<std::mutex> lock(v->m);
+    CFRunLoopPerformBlock(queue, kCFRunLoopCommonModes, ^(void) {
+      func();
+      {
+        std::unique_lock lk(v->m);
+        finished = true;
+      }
+      v->cv.notify_all();
+    });
+    CFRunLoopWakeUp(queue);
+    while (!finished) {
+      v->cv.wait(lock);
+    }
+    delete v;
+  } else {
+    CFRunLoopPerformBlock(queue, kCFRunLoopCommonModes, ^(void) {
+      func();
+    });
+    CFRunLoopWakeUp(queue);
+  }
+}
+
+void tns::ExecuteOnDispatchQueue(dispatch_queue_t queue, std::function<void()> func, bool async) {
+  if (async) {
+    dispatch_async(queue, ^(void) {
+      func();
+    });
+  } else {
+    dispatch_sync(queue, ^(void) {
+      func();
+    });
+  }
+}
+
+void tns::ExecuteOnMainThread(std::function<void()> func, bool async) {
+  if (async) {
+    dispatch_async(dispatch_get_main_queue(), ^(void) {
+      func();
+    });
+  } else {
+    dispatch_sync(dispatch_get_main_queue(), ^(void) {
+      func();
+    });
+  }
 }
 
 void tns::LogError(Isolate* isolate, TryCatch& tc) {
-    if (!tc.HasCaught()) {
-        return;
-    }
-
-    Log(@"Native stack trace:");
-    LogBacktrace();
-
-    Local<Value> stack;
-    Local<Context> context = isolate->GetCurrentContext();
-    bool success = tc.StackTrace(context).ToLocal(&stack);
-    if (!success || stack.IsEmpty()) {
-        return;
-    }
-
-    Local<v8::String> stackV8Str;
-    success = stack->ToDetailString(context).ToLocal(&stackV8Str);
-    if (!success || stackV8Str.IsEmpty()) {
-        return;
-    }
-
-    std::string stackTraceStr = tns::ToString(isolate, stackV8Str);
-    stackTraceStr = ReplaceAll(stackTraceStr, RuntimeConfig.BaseDir, "");
-
-    Log(@"JavaScript error:");
-    Log(@"%s", stackTraceStr.c_str());
-}
-
-Local<v8::String> tns::JsonStringifyObject(Local<Context> context, Local<Value> value, bool handleCircularReferences) {
-    Isolate* isolate = context->GetIsolate();
-    if (value.IsEmpty()) {
-        return v8::String::Empty(isolate);
-    }
-
-    if (handleCircularReferences) {
-        Local<v8::Function> smartJSONStringifyFunction = tns::GetSmartJSONStringifyFunction(isolate);
-
-        if (!smartJSONStringifyFunction.IsEmpty()) {
-            if (value->IsObject()) {
-                Local<Value> resultValue;
-                TryCatch tc(isolate);
-
-                Local<Value> args[] = {
-                    value->ToObject(context).ToLocalChecked()
-                };
-                bool success = smartJSONStringifyFunction->Call(context, v8::Undefined(isolate), 1, args).ToLocal(&resultValue);
-
-                if (success && !tc.HasCaught()) {
-                    return resultValue->ToString(context).ToLocalChecked();
-                }
-            }
+  if (!tc.HasCaught()) {
+    return;
+  }
+
+  Log(@"Native stack trace:");
+  LogBacktrace();
+
+  Local<Value> stack;
+  Local<Context> context = isolate->GetCurrentContext();
+  bool success = tc.StackTrace(context).ToLocal(&stack);
+  if (!success || stack.IsEmpty()) {
+    return;
+  }
+
+  Local<v8::String> stackV8Str;
+  success = stack->ToDetailString(context).ToLocal(&stackV8Str);
+  if (!success || stackV8Str.IsEmpty()) {
+    return;
+  }
+
+  std::string stackTraceStr = tns::ToString(isolate, stackV8Str);
+  stackTraceStr = ReplaceAll(stackTraceStr, RuntimeConfig.BaseDir, "");
+
+  Log(@"JavaScript error:");
+  Log(@"%s", stackTraceStr.c_str());
+}
+
+Local<v8::String> tns::JsonStringifyObject(Local<Context> context, Local<Value> value,
+                                           bool handleCircularReferences) {
+  Isolate* isolate = context->GetIsolate();
+  if (value.IsEmpty()) {
+    return v8::String::Empty(isolate);
+  }
+
+  if (handleCircularReferences) {
+    Local<v8::Function> smartJSONStringifyFunction = tns::GetSmartJSONStringifyFunction(isolate);
+
+    if (!smartJSONStringifyFunction.IsEmpty()) {
+      if (value->IsObject()) {
+        Local<Value> resultValue;
+        TryCatch tc(isolate);
+
+        Local<Value> args[] = {value->ToObject(context).ToLocalChecked()};
+        bool success = smartJSONStringifyFunction->Call(context, v8::Undefined(isolate), 1, args)
+                           .ToLocal(&resultValue);
+
+        if (success && !tc.HasCaught()) {
+          return resultValue->ToString(context).ToLocalChecked();
         }
+      }
     }
+  }
 
-    Local<v8::String> resultString;
-    TryCatch tc(isolate);
-    bool success = v8::JSON::Stringify(context, value->ToObject(context).ToLocalChecked()).ToLocal(&resultString);
+  Local<v8::String> resultString;
+  TryCatch tc(isolate);
+  bool success = v8::JSON::Stringify(context, value->ToObject(context).ToLocalChecked())
+                     .ToLocal(&resultString);
 
-    if (!success && tc.HasCaught()) {
-        tns::LogError(isolate, tc);
-        return Local<v8::String>();
-    }
+  if (!success && tc.HasCaught()) {
+    tns::LogError(isolate, tc);
+    return Local<v8::String>();
+  }
 
-    return resultString;
+  return resultString;
 }
 
 Local<v8::Function> tns::GetSmartJSONStringifyFunction(Isolate* isolate) {
-    std::shared_ptr<Caches> caches = Caches::Get(isolate);
-    if (caches->SmartJSONStringifyFunc != nullptr) {
-        return caches->SmartJSONStringifyFunc->Get(isolate);
-    }
-
-    std::string smartStringifyFunctionScript =
-        "(function () {\n"
-        "    function smartStringify(object) {\n"
-        "        const seen = [];\n"
-        "        var replacer = function (key, value) {\n"
-        "            if (value != null && typeof value == \"object\") {\n"
-        "                if (seen.indexOf(value) >= 0) {\n"
-        "                    if (key) {\n"
-        "                        return \"[Circular]\";\n"
-        "                    }\n"
-        "                    return;\n"
-        "                }\n"
-        "                seen.push(value);\n"
-        "            }\n"
-        "            return value;\n"
-        "        };\n"
-        "        return JSON.stringify(object, replacer, 2);\n"
-        "    }\n"
-        "    return smartStringify;\n"
-        "})();";
-
-    Local<v8::String> source = tns::ToV8String(isolate, smartStringifyFunctionScript);
-    Local<Context> context = isolate->GetCurrentContext();
-
-    Local<Script> script;
-    bool success = Script::Compile(context, source).ToLocal(&script);
-    tns::Assert(success, isolate);
-
-    if (script.IsEmpty()) {
-        return Local<v8::Function>();
-    }
-
-    Local<Value> result;
-    success = script->Run(context).ToLocal(&result);
-    tns::Assert(success, isolate);
-
-    if (result.IsEmpty() && !result->IsFunction()) {
-        return Local<v8::Function>();
-    }
-
-    Local<v8::Function> smartStringifyFunction = result.As<v8::Function>();
-
-    caches->SmartJSONStringifyFunc = std::make_unique<Persistent<v8::Function>>(isolate, smartStringifyFunction);
-
-    return smartStringifyFunction;
+  std::shared_ptr<Caches> caches = Caches::Get(isolate);
+  if (caches->SmartJSONStringifyFunc != nullptr) {
+    return caches->SmartJSONStringifyFunc->Get(isolate);
+  }
+
+  std::string smartStringifyFunctionScript =
+      "(function () {\n"
+      "    function smartStringify(object) {\n"
+      "        const seen = [];\n"
+      "        var replacer = function (key, value) {\n"
+      "            if (value != null && typeof value == \"object\") {\n"
+      "                if (seen.indexOf(value) >= 0) {\n"
+      "                    if (key) {\n"
+      "                        return \"[Circular]\";\n"
+      "                    }\n"
+      "                    return;\n"
+      "                }\n"
+      "                seen.push(value);\n"
+      "            }\n"
+      "            return value;\n"
+      "        };\n"
+      "        return JSON.stringify(object, replacer, 2);\n"
+      "    }\n"
+      "    return smartStringify;\n"
+      "})();";
+
+  Local<v8::String> source = tns::ToV8String(isolate, smartStringifyFunctionScript);
+  Local<Context> context = isolate->GetCurrentContext();
+
+  Local<Script> script;
+  bool success = Script::Compile(context, source).ToLocal(&script);
+  tns::Assert(success, isolate);
+
+  if (script.IsEmpty()) {
+    return Local<v8::Function>();
+  }
+
+  Local<Value> result;
+  success = script->Run(context).ToLocal(&result);
+  tns::Assert(success, isolate);
+
+  if (result.IsEmpty() && !result->IsFunction()) {
+    return Local<v8::Function>();
+  }
+
+  Local<v8::Function> smartStringifyFunction = result.As<v8::Function>();
+
+  caches->SmartJSONStringifyFunc =
+      std::make_unique<Persistent<v8::Function>>(isolate, smartStringifyFunction);
+
+  return smartStringifyFunction;
 }
 
 std::string tns::ReplaceAll(const std::string source, std::string find, std::string replacement) {
-    std::string result = source;
-    size_t pos = result.find(find);
-    while (pos != std::string::npos) {
-        result.replace(pos, find.size(), replacement);
-        pos = result.find(find, pos + replacement.size());
-    }
+  std::string result = source;
+  size_t pos = result.find(find);
+  while (pos != std::string::npos) {
+    result.replace(pos, find.size(), replacement);
+    pos = result.find(find, pos + replacement.size());
+  }
 
-    return result;
+  return result;
 }
 
 void tns::LogBacktrace(int skip) {
-    void *callstack[128];
-    const int nMaxFrames = sizeof(callstack) / sizeof(callstack[0]);
-    char buf[1024];
-    int nFrames = backtrace(callstack, nMaxFrames);
-    char **symbols = backtrace_symbols(callstack, nFrames);
-
-    for (int i = skip; i < nFrames; i++) {
-        Dl_info info;
-        if (dladdr(callstack[i], &info) && info.dli_sname) {
-            char *demangled = NULL;
-            int status = -1;
-            if (info.dli_sname[0] == '_') {
-                demangled = abi::__cxa_demangle(info.dli_sname, NULL, 0, &status);
-            }
-            snprintf(buf,
-                     sizeof(buf),
-                     "%-3d %*p %s + %zd\n",
-                     i,
-                     int(2 + sizeof(void*) * 2),
-                     callstack[i],
-                     status == 0 ? demangled : info.dli_sname == 0 ? symbols[i] : info.dli_sname,
-                     (char *)callstack[i] - (char *)info.dli_saddr);
-            free(demangled);
-        } else {
-            snprintf(buf, sizeof(buf), "%-3d %*p %s\n", i, int(2 + sizeof(void*) * 2), callstack[i], symbols[i]);
-        }
-        Log(@"%s", buf);
-    }
-    free(symbols);
-    if (nFrames == nMaxFrames) {
-        Log(@"[truncated]");
+  void* callstack[128];
+  const int nMaxFrames = sizeof(callstack) / sizeof(callstack[0]);
+  char buf[1024];
+  int nFrames = backtrace(callstack, nMaxFrames);
+  char** symbols = backtrace_symbols(callstack, nFrames);
+
+  for (int i = skip; i < nFrames; i++) {
+    Dl_info info;
+    if (dladdr(callstack[i], &info) && info.dli_sname) {
+      char* demangled = NULL;
+      int status = -1;
+      if (info.dli_sname[0] == '_') {
+        demangled = abi::__cxa_demangle(info.dli_sname, NULL, 0, &status);
+      }
+      snprintf(buf, sizeof(buf), "%-3d %*p %s + %zd\n", i, int(2 + sizeof(void*) * 2), callstack[i],
+               status == 0 ? demangled : info.dli_sname == 0 ? symbols[i] : info.dli_sname,
+               (char*)callstack[i] - (char*)info.dli_saddr);
+      free(demangled);
+    } else {
+      snprintf(buf, sizeof(buf), "%-3d %*p %s\n", i, int(2 + sizeof(void*) * 2), callstack[i],
+               symbols[i]);
     }
+    Log(@"%s", buf);
+  }
+  free(symbols);
+  if (nFrames == nMaxFrames) {
+    Log(@"[truncated]");
+  }
 }
 
 const std::string tns::GetStackTrace(Isolate* isolate) {
-    Local<StackTrace> stack = StackTrace::CurrentStackTrace(isolate, 10, StackTrace::StackTraceOptions::kDetailed);
-    int framesCount = stack->GetFrameCount();
-    std::stringstream ss;
-    for (int i = 0; i < framesCount; i++) {
-        Local<StackFrame> frame = stack->GetFrame(isolate, i);
-        ss << BuildStacktraceFrameMessage(isolate, frame) << std::endl;
-    }
-    return ss.str();
+  Local<StackTrace> stack =
+      StackTrace::CurrentStackTrace(isolate, 10, StackTrace::StackTraceOptions::kDetailed);
+  int framesCount = stack->GetFrameCount();
+  std::stringstream ss;
+  for (int i = 0; i < framesCount; i++) {
+    Local<StackFrame> frame = stack->GetFrame(isolate, i);
+    ss << BuildStacktraceFrameMessage(isolate, frame) << std::endl;
+  }
+  return ss.str();
 }
 
 const std::string tns::GetCurrentScriptUrl(Isolate* isolate) {
-    Local<StackTrace> stack = StackTrace::CurrentStackTrace(isolate, 1, StackTrace::StackTraceOptions::kDetailed);
-    int framesCount = stack->GetFrameCount();
-    if (framesCount > 0) {
-        Local<StackFrame> frame = stack->GetFrame(isolate, 0);
-        return tns::BuildStacktraceFrameLocationPart(isolate, frame);
-    }
+  Local<StackTrace> stack =
+      StackTrace::CurrentStackTrace(isolate, 1, StackTrace::StackTraceOptions::kDetailed);
+  int framesCount = stack->GetFrameCount();
+  if (framesCount > 0) {
+    Local<StackFrame> frame = stack->GetFrame(isolate, 0);
+    return tns::BuildStacktraceFrameLocationPart(isolate, frame);
+  }
 
-    return "";
+  return "";
 }
 
 const std::string tns::BuildStacktraceFrameLocationPart(Isolate* isolate, Local<StackFrame> frame) {
-    std::stringstream ss;
+  std::stringstream ss;
 
-    Local<v8::String> scriptName = frame->GetScriptNameOrSourceURL();
-    std::string scriptNameStr = tns::ToString(isolate, scriptName);
-    scriptNameStr = tns::ReplaceAll(scriptNameStr, RuntimeConfig.BaseDir, "");
+  Local<v8::String> scriptName = frame->GetScriptNameOrSourceURL();
+  std::string scriptNameStr = tns::ToString(isolate, scriptName);
+  scriptNameStr = tns::ReplaceAll(scriptNameStr, RuntimeConfig.BaseDir, "");
 
-    if (scriptNameStr.length() < 1) {
-        ss << "VM";
-    } else {
-        ss << scriptNameStr << ":" << frame->GetLineNumber() << ":" << frame->GetColumn();
-    }
+  if (scriptNameStr.length() < 1) {
+    ss << "VM";
+  } else {
+    ss << scriptNameStr << ":" << frame->GetLineNumber() << ":" << frame->GetColumn();
+  }
 
-    std::string stringResult = ss.str();
+  std::string stringResult = ss.str();
 
-    return stringResult;
+  return stringResult;
 }
 
 const std::string tns::BuildStacktraceFrameMessage(Isolate* isolate, Local<StackFrame> frame) {
-    std::stringstream ss;
+  std::stringstream ss;
 
-    Local<v8::String> functionName = frame->GetFunctionName();
-    std::string functionNameStr = tns::ToString(isolate, functionName);
-    if (functionNameStr.empty()) {
-        functionNameStr = "<anonymous>";
-    }
+  Local<v8::String> functionName = frame->GetFunctionName();
+  std::string functionNameStr = tns::ToString(isolate, functionName);
+  if (functionNameStr.empty()) {
+    functionNameStr = "<anonymous>";
+  }
 
-    if (frame->IsConstructor()) {
-        ss << "at new " << functionNameStr << " (" << tns::BuildStacktraceFrameLocationPart(isolate, frame) << ")";
-    } else if (frame->IsEval()) {
-        ss << "eval at " << BuildStacktraceFrameLocationPart(isolate, frame) << std::endl;
-    } else {
-        ss << "at " << functionNameStr << " (" << tns::BuildStacktraceFrameLocationPart(isolate, frame) << ")";
-    }
+  if (frame->IsConstructor()) {
+    ss << "at new " << functionNameStr << " ("
+       << tns::BuildStacktraceFrameLocationPart(isolate, frame) << ")";
+  } else if (frame->IsEval()) {
+    ss << "eval at " << BuildStacktraceFrameLocationPart(isolate, frame) << std::endl;
+  } else {
+    ss << "at " << functionNameStr << " (" << tns::BuildStacktraceFrameLocationPart(isolate, frame)
+       << ")";
+  }
 
-    std::string stringResult = ss.str();
+  std::string stringResult = ss.str();
 
-    return stringResult;
+  return stringResult;
 }
 
 bool tns::LiveSync(Isolate* isolate) {
-    v8::Locker locker(isolate);
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-    std::shared_ptr<Caches> cache = Caches::Get(isolate);
-    Local<Context> context = cache->GetContext();
-    Local<Object> global = context->Global();
-    Local<Value> value;
-    bool success = global->Get(context, tns::ToV8String(isolate, "__onLiveSync")).ToLocal(&value);
-    if (!success || value.IsEmpty() || !value->IsFunction()) {
-        return false;
-    }
+  v8::Locker locker(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  Local<Context> context = cache->GetContext();
+  Local<Object> global = context->Global();
+  Local<Value> value;
+  bool success = global->Get(context, tns::ToV8String(isolate, "__onLiveSync")).ToLocal(&value);
+  if (!success || value.IsEmpty() || !value->IsFunction()) {
+    return false;
+  }
 
-    Local<v8::Function> liveSyncFunc = value.As<v8::Function>();
-    Local<Value> args[0];
-    Local<Value> result;
+  Local<v8::Function> liveSyncFunc = value.As<v8::Function>();
+  Local<Value> args[0];
+  Local<Value> result;
 
-    TryCatch tc(isolate);
-    success = liveSyncFunc->Call(context, v8::Undefined(isolate), 0, args).ToLocal(&result);
-    if (!success || tc.HasCaught()) {
-        if (tc.HasCaught()) {
-            tns::LogError(isolate, tc);
-        }
-        return false;
+  TryCatch tc(isolate);
+  success = liveSyncFunc->Call(context, v8::Undefined(isolate), 0, args).ToLocal(&result);
+  if (!success || tc.HasCaught()) {
+    if (tc.HasCaught()) {
+      tns::LogError(isolate, tc);
     }
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
-void tns::Assert(bool condition, Isolate* isolate, std::string const &reason) {
-    if (!RuntimeConfig.IsDebug) {
-        assert(condition);
-        return;
-    }
+void tns::Assert(bool condition, Isolate* isolate, std::string const& reason) {
+  if (!RuntimeConfig.IsDebug) {
+    assert(condition);
+    return;
+  }
 
-    if (condition) {
-        return;
-    }
+  if (condition) {
+    return;
+  }
 
-    if (isolate == nullptr) {
-        Runtime* runtime = Runtime::GetCurrentRuntime();
-        if (runtime != nullptr) {
-            isolate = runtime->GetIsolate();
-        }
-    }
-
-    if (isolate == nullptr) {
-        Log(@"====== Assertion failed ======");
-        if(!reason.empty()) {
-            Log(@"Reason: %s", reason.c_str());
-        }
-        Log(@"Native stack trace:");
-        LogBacktrace();
-        assert(false);
-        return;
+  if (isolate == nullptr) {
+    Runtime* runtime = Runtime::GetCurrentRuntime();
+    if (runtime != nullptr) {
+      isolate = runtime->GetIsolate();
     }
+  }
 
+  if (isolate == nullptr) {
     Log(@"====== Assertion failed ======");
+    if (!reason.empty()) {
+      Log(@"Reason: %s", reason.c_str());
+    }
     Log(@"Native stack trace:");
     LogBacktrace();
-
-    Log(@"JavaScript stack trace:");
-    std::string stack = tns::GetStackTrace(isolate);
-    Log(@"%s", stack.c_str());
     assert(false);
-}
+    return;
+  }
+
+  Log(@"====== Assertion failed ======");
+  Log(@"Native stack trace:");
+  LogBacktrace();
 
-void tns::StopExecutionAndLogStackTrace(v8::Isolate* isolate) {
-    Assert(false, isolate);
+  Log(@"JavaScript stack trace:");
+  std::string stack = tns::GetStackTrace(isolate);
+  Log(@"%s", stack.c_str());
+  assert(false);
 }
 
+void tns::StopExecutionAndLogStackTrace(v8::Isolate* isolate) { Assert(false, isolate); }
 
 namespace tns {
-Local<v8::FunctionTemplate> NewFunctionTemplate(
-                                                v8::Isolate* isolate,
-                                                v8::FunctionCallback callback,
+Local<v8::FunctionTemplate> NewFunctionTemplate(v8::Isolate* isolate, v8::FunctionCallback callback,
                                                 Local<v8::Value> data,
                                                 Local<v8::Signature> signature,
                                                 v8::ConstructorBehavior behavior,
                                                 v8::SideEffectType side_effect_type,
                                                 const v8::CFunction* c_function) {
-    return v8::FunctionTemplate::New(isolate,
-                                     callback,
-                                     data,
-                                     signature,
-                                     0,
-                                     behavior,
-                                     side_effect_type,
-                                     c_function);
-}
-void SetMethod(Local<v8::Context> context,
-               Local<v8::Object> that,
-               const char* name,
-               v8::FunctionCallback callback,
-               Local<v8::Value> data) {
-    Isolate* isolate = context->GetIsolate();
-    Local<v8::Function> function =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasSideEffect)
-    ->GetFunction(context)
-        .ToLocalChecked();
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(context, name_string, function).Check();
-    function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
-}
-void SetMethod(v8::Isolate* isolate,
-               v8::Local<v8::Template> that,
-               const char* name,
-               v8::FunctionCallback callback,
-               Local<v8::Value> data) {
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasSideEffect);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(name_string, t);
-}
-void SetFastMethod(Isolate* isolate,
-                   Local<Template> that,
-                   const char* name,
-                   v8::FunctionCallback slow_callback,
-                   const v8::CFunction* c_function,
+  return v8::FunctionTemplate::New(isolate, callback, data, signature, 0, behavior,
+                                   side_effect_type, c_function);
+}
+void SetMethod(Local<v8::Context> context, Local<v8::Object> that, const char* name,
+               v8::FunctionCallback callback, Local<v8::Value> data) {
+  Isolate* isolate = context->GetIsolate();
+  Local<v8::Function> function =
+      NewFunctionTemplate(isolate, callback, data, Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasSideEffect)
+          ->GetFunction(context)
+          .ToLocalChecked();
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(context, name_string, function).Check();
+  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
+}
+void SetMethod(v8::Isolate* isolate, v8::Local<v8::Template> that, const char* name,
+               v8::FunctionCallback callback, Local<v8::Value> data) {
+  Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(isolate, callback, data, Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(name_string, t);
+}
+void SetFastMethod(Isolate* isolate, Local<Template> that, const char* name,
+                   v8::FunctionCallback slow_callback, const v8::CFunction* c_function,
                    Local<v8::Value> data) {
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        slow_callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasSideEffect,
-                        c_function);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(name_string, t);
-}
-void SetFastMethod(Local<v8::Context> context,
-                   Local<v8::Object> that,
-                   const char* name,
-                   v8::FunctionCallback slow_callback,
-                   const v8::CFunction* c_function,
+  Local<v8::FunctionTemplate> t = NewFunctionTemplate(
+      isolate, slow_callback, data, Local<v8::Signature>(), v8::ConstructorBehavior::kThrow,
+      v8::SideEffectType::kHasSideEffect, c_function);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(name_string, t);
+}
+void SetFastMethod(Local<v8::Context> context, Local<v8::Object> that, const char* name,
+                   v8::FunctionCallback slow_callback, const v8::CFunction* c_function,
                    Local<v8::Value> data) {
-    Isolate* isolate = context->GetIsolate();
-    Local<v8::Function> function =
-    NewFunctionTemplate(isolate,
-                        slow_callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasSideEffect,
-                        c_function)
-    ->GetFunction(context)
-        .ToLocalChecked();
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(context, name_string, function).Check();
-}
-void SetFastMethodNoSideEffect(Local<v8::Context> context,
-                               Local<v8::Object> that,
-                               const char* name,
-                               v8::FunctionCallback slow_callback,
-                               const v8::CFunction* c_function,
+  Isolate* isolate = context->GetIsolate();
+  Local<v8::Function> function =
+      NewFunctionTemplate(isolate, slow_callback, data, Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasSideEffect,
+                          c_function)
+          ->GetFunction(context)
+          .ToLocalChecked();
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(context, name_string, function).Check();
+}
+void SetFastMethodNoSideEffect(Local<v8::Context> context, Local<v8::Object> that, const char* name,
+                               v8::FunctionCallback slow_callback, const v8::CFunction* c_function,
                                Local<v8::Value> data) {
-    Isolate* isolate = context->GetIsolate();
-    Local<v8::Function> function =
-    NewFunctionTemplate(isolate,
-                        slow_callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasNoSideEffect,
-                        c_function)
-    ->GetFunction(context)
-        .ToLocalChecked();
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(context, name_string, function).Check();
-}
-void SetFastMethodNoSideEffect(Isolate* isolate,
-                               Local<Template> that,
-                               const char* name,
-                               v8::FunctionCallback slow_callback,
-                               const v8::CFunction* c_function,
+  Isolate* isolate = context->GetIsolate();
+  Local<v8::Function> function =
+      NewFunctionTemplate(isolate, slow_callback, data, Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasNoSideEffect,
+                          c_function)
+          ->GetFunction(context)
+          .ToLocalChecked();
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(context, name_string, function).Check();
+}
+void SetFastMethodNoSideEffect(Isolate* isolate, Local<Template> that, const char* name,
+                               v8::FunctionCallback slow_callback, const v8::CFunction* c_function,
                                Local<v8::Value> data) {
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        slow_callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasNoSideEffect,
-                        c_function);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(name_string, t);
-}
-void SetMethodNoSideEffect(Local<v8::Context> context,
-                           Local<v8::Object> that,
-                           const char* name,
-                           v8::FunctionCallback callback,
-                           Local<v8::Value> data) {
-    Isolate* isolate = context->GetIsolate();
-    Local<v8::Function> function =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasNoSideEffect)
-    ->GetFunction(context)
-        .ToLocalChecked();
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(context, name_string, function).Check();
-    function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
-}
-void SetMethodNoSideEffect(Isolate* isolate,
-                           Local<v8::Template> that,
-                           const char* name,
-                           v8::FunctionCallback callback,
-                           Local<v8::Value> data) {
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        Local<v8::Signature>(),
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasNoSideEffect);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->Set(name_string, t);
-}
-void SetProtoMethod(v8::Isolate* isolate,
-                    Local<v8::FunctionTemplate> that,
-                    const char* name,
-                    v8::FunctionCallback callback,
-                    Local<v8::Value> data) {
-    Local<v8::Signature> signature = v8::Signature::New(isolate, that);
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        signature,
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasSideEffect);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->PrototypeTemplate()->Set(name_string, t);
-    t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
-}
-void SetProtoMethodNoSideEffect(v8::Isolate* isolate,
-                                Local<v8::FunctionTemplate> that,
-                                const char* name,
-                                v8::FunctionCallback callback,
+  Local<v8::FunctionTemplate> t = NewFunctionTemplate(
+      isolate, slow_callback, data, Local<v8::Signature>(), v8::ConstructorBehavior::kThrow,
+      v8::SideEffectType::kHasNoSideEffect, c_function);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(name_string, t);
+}
+void SetMethodNoSideEffect(Local<v8::Context> context, Local<v8::Object> that, const char* name,
+                           v8::FunctionCallback callback, Local<v8::Value> data) {
+  Isolate* isolate = context->GetIsolate();
+  Local<v8::Function> function =
+      NewFunctionTemplate(isolate, callback, data, Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasNoSideEffect)
+          ->GetFunction(context)
+          .ToLocalChecked();
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(context, name_string, function).Check();
+  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
+}
+void SetMethodNoSideEffect(Isolate* isolate, Local<v8::Template> that, const char* name,
+                           v8::FunctionCallback callback, Local<v8::Value> data) {
+  Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(isolate, callback, data, Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kThrow, v8::SideEffectType::kHasNoSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->Set(name_string, t);
+}
+void SetProtoMethod(v8::Isolate* isolate, Local<v8::FunctionTemplate> that, const char* name,
+                    v8::FunctionCallback callback, Local<v8::Value> data) {
+  Local<v8::Signature> signature = v8::Signature::New(isolate, that);
+  Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(isolate, callback, data, signature, v8::ConstructorBehavior::kThrow,
+                          v8::SideEffectType::kHasSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->PrototypeTemplate()->Set(name_string, t);
+  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
+}
+void SetProtoMethodNoSideEffect(v8::Isolate* isolate, Local<v8::FunctionTemplate> that,
+                                const char* name, v8::FunctionCallback callback,
                                 Local<v8::Value> data) {
-    Local<v8::Signature> signature = v8::Signature::New(isolate, that);
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        signature,
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasNoSideEffect);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->PrototypeTemplate()->Set(name_string, t);
-    t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
-}
-void SetInstanceMethod(v8::Isolate* isolate,
-                       Local<v8::FunctionTemplate> that,
-                       const char* name,
-                       v8::FunctionCallback callback,
-                       Local<v8::Value> data) {
-    Local<v8::Signature> signature = v8::Signature::New(isolate, that);
-    Local<v8::FunctionTemplate> t =
-    NewFunctionTemplate(isolate,
-                        callback,
-                        data,
-                        signature,
-                        v8::ConstructorBehavior::kThrow,
-                        v8::SideEffectType::kHasSideEffect);
-    // kInternalized strings are created in the old space.
-    const v8::NewStringType type = v8::NewStringType::kInternalized;
-    Local<v8::String> name_string =
-    v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
-    that->InstanceTemplate()->Set(name_string, t);
-    t->SetClassName(name_string);
-}
-void SetConstructorFunction(Local<v8::Context> context,
-                            Local<v8::Object> that,
-                            const char* name,
-                            Local<v8::FunctionTemplate> tmpl,
-                            SetConstructorFunctionFlag flag) {
-    Isolate* isolate = context->GetIsolate();
-    SetConstructorFunction(
-                           context, that, tns::OneByteString(isolate, name), tmpl, flag);
-}
-void SetConstructorFunction(Local<Context> context,
-                            Local<Object> that,
-                            Local<v8::String> name,
-                            Local<FunctionTemplate> tmpl,
-                            SetConstructorFunctionFlag flag) {
-    if (flag == SetConstructorFunctionFlag::SET_CLASS_NAME)
-        tmpl->SetClassName(name);
-    that->Set(context, name, tmpl->GetFunction(context).ToLocalChecked()).Check();
-}
-void SetConstructorFunction(Isolate* isolate,
-                            Local<Template> that,
-                            const char* name,
-                            Local<FunctionTemplate> tmpl,
-                            SetConstructorFunctionFlag flag) {
-    SetConstructorFunction(
-                           isolate, that, OneByteString(isolate, name), tmpl, flag);
-}
-void SetConstructorFunction(Isolate* isolate,
-                            Local<Template> that,
-                            Local<v8::String> name,
-                            Local<FunctionTemplate> tmpl,
-                            SetConstructorFunctionFlag flag) {
-    if (flag == SetConstructorFunctionFlag::SET_CLASS_NAME)
-        tmpl->SetClassName(name);
-    that->Set(name, tmpl);
+  Local<v8::Signature> signature = v8::Signature::New(isolate, that);
+  Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(isolate, callback, data, signature, v8::ConstructorBehavior::kThrow,
+                          v8::SideEffectType::kHasNoSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->PrototypeTemplate()->Set(name_string, t);
+  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
+}
+void SetInstanceMethod(v8::Isolate* isolate, Local<v8::FunctionTemplate> that, const char* name,
+                       v8::FunctionCallback callback, Local<v8::Value> data) {
+  Local<v8::Signature> signature = v8::Signature::New(isolate, that);
+  Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(isolate, callback, data, signature, v8::ConstructorBehavior::kThrow,
+                          v8::SideEffectType::kHasSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string = v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
+  that->InstanceTemplate()->Set(name_string, t);
+  t->SetClassName(name_string);
+}
+void SetConstructorFunction(Local<v8::Context> context, Local<v8::Object> that, const char* name,
+                            Local<v8::FunctionTemplate> tmpl, SetConstructorFunctionFlag flag) {
+  Isolate* isolate = context->GetIsolate();
+  SetConstructorFunction(context, that, tns::OneByteString(isolate, name), tmpl, flag);
+}
+void SetConstructorFunction(Local<Context> context, Local<Object> that, Local<v8::String> name,
+                            Local<FunctionTemplate> tmpl, SetConstructorFunctionFlag flag) {
+  if (flag == SetConstructorFunctionFlag::SET_CLASS_NAME) tmpl->SetClassName(name);
+  that->Set(context, name, tmpl->GetFunction(context).ToLocalChecked()).Check();
+}
+void SetConstructorFunction(Isolate* isolate, Local<Template> that, const char* name,
+                            Local<FunctionTemplate> tmpl, SetConstructorFunctionFlag flag) {
+  SetConstructorFunction(isolate, that, OneByteString(isolate, name), tmpl, flag);
+}
+void SetConstructorFunction(Isolate* isolate, Local<Template> that, Local<v8::String> name,
+                            Local<FunctionTemplate> tmpl, SetConstructorFunctionFlag flag) {
+  if (flag == SetConstructorFunctionFlag::SET_CLASS_NAME) tmpl->SetClassName(name);
+  that->Set(name, tmpl);
 }
 };
diff --git a/NativeScript/runtime/ModuleInternal.h b/NativeScript/runtime/ModuleInternal.h
index 25d223e9..9fae6239 100644
--- a/NativeScript/runtime/ModuleInternal.h
+++ b/NativeScript/runtime/ModuleInternal.h
@@ -11,6 +11,8 @@ class ModuleInternal {
   ModuleInternal(v8::Local<v8::Context> context);
   bool RunModule(v8::Isolate* isolate, std::string path);
   void RunScript(v8::Isolate* isolate, std::string script);
+  static v8::Local<v8::Value> LoadScript(v8::Isolate* isolate,
+                                         const std::string& path);
 
  private:
   static void RequireCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
@@ -19,10 +21,15 @@ class ModuleInternal {
   v8::Local<v8::Object> LoadImpl(v8::Isolate* isolate,
                                  const std::string& moduleName,
                                  const std::string& baseDir, bool& isData);
-  v8::Local<v8::Script> LoadScript(v8::Isolate* isolate,
-                                   const std::string& path);
-  v8::Local<v8::String> WrapModuleContent(v8::Isolate* isolate,
-                                          const std::string& path);
+  // Compile (and cache) a classic script; returns the compiled Script handle.
+  static v8::Local<v8::Script> LoadClassicScript(v8::Isolate* isolate,
+                                                 const std::string& path);
+
+  // Compile/link/evaluate an ES module; returns its namespace object.
+  static v8::Local<v8::Value> LoadESModule(v8::Isolate* isolate,
+                                           const std::string& path);
+  static v8::Local<v8::String> WrapModuleContent(v8::Isolate* isolate,
+                                                 const std::string& path);
   v8::Local<v8::Object> LoadModule(v8::Isolate* isolate,
                                    const std::string& modulePath,
                                    const std::string& cacheKey);
@@ -32,10 +39,16 @@ class ModuleInternal {
                           const std::string& moduleName);
   std::string ResolvePathFromPackageJson(const std::string& packageJson,
                                          bool& error);
-  v8::ScriptCompiler::CachedData* LoadScriptCache(const std::string& path);
-  void SaveScriptCache(const v8::Local<v8::Script> script,
-                       const std::string& path);
-  std::string GetCacheFileName(const std::string& path);
+  v8::Local<v8::Object> CreatePlaceholderModule(v8::Isolate* isolate,
+                                                const std::string& moduleName,
+                                                const std::string& cacheKey);
+  static v8::ScriptCompiler::CachedData* LoadScriptCache(
+      const std::string& path);
+  static void SaveScriptCache(const v8::Local<v8::Script> script,
+                              const std::string& path);
+  static void SaveScriptCache(const v8::ScriptCompiler::CachedData* cache,
+                              const std::string& path);
+  static std::string GetCacheFileName(const std::string& path);
   v8::MaybeLocal<v8::Value> RunScriptString(v8::Isolate* isolate,
                                             v8::Local<v8::Context> context,
                                             const std::string script);
diff --git a/NativeScript/runtime/ModuleInternal.mm b/NativeScript/runtime/ModuleInternal.mm
index 4ade584b..4a8016e1 100644
--- a/NativeScript/runtime/ModuleInternal.mm
+++ b/NativeScript/runtime/ModuleInternal.mm
@@ -2,17 +2,30 @@
 #include <Foundation/Foundation.h>
 #include <sys/stat.h>
 #include <time.h>
+#include <unistd.h>
 #include <utime.h>
 #include <string>
 #include "Caches.h"
 #include "Helpers.h"
+#include "ModuleInternalCallbacks.h"  // for ResolveModuleCallback
 #include "NativeScriptException.h"
+#include "Runtime.h"  // for GetAppConfigValue
 #include "RuntimeConfig.h"
 
 using namespace v8;
 
 namespace tns {
 
+// Helper function to check if a module name looks like an optional external module
+bool IsLikelyOptionalModule(const std::string& moduleName) {
+  // Check if it's a bare module name (no path separators) that could be an npm package
+  if (moduleName.find('/') == std::string::npos && moduleName.find('\\') == std::string::npos &&
+      moduleName[0] != '.' && moduleName[0] != '~' && moduleName[0] != '/') {
+    return true;
+  }
+  return false;
+}
+
 ModuleInternal::ModuleInternal(Local<Context> context) {
   std::string requireFactoryScript = "(function() { "
                                      "    function require_factory(requireInternal, dirName) { "
@@ -59,9 +72,24 @@
 }
 
 bool ModuleInternal::RunModule(Isolate* isolate, std::string path) {
+  // Debug: Log module loading
+  printf("ModuleInternal::RunModule: Loading module: %s\n", path.c_str());
+
   std::shared_ptr<Caches> cache = Caches::Get(isolate);
   Local<Context> context = cache->GetContext();
   Local<Object> globalObject = context->Global();
+  // Ensure global.__dirname is defined so ESM/CommonJS shims relying on it work.
+  {
+    Local<Value> dirVal;
+    bool hasDir = globalObject->Get(context, ToV8String(isolate, "__dirname")).ToLocal(&dirVal);
+    if (!hasDir || dirVal->IsUndefined()) {
+      bool setDir = globalObject
+                        ->Set(context, ToV8String(isolate, "__dirname"),
+                              ToV8String(isolate, RuntimeConfig.ApplicationPath))
+                        .FromMaybe(false);
+      tns::Assert(setDir, isolate);
+    }
+  }
   Local<Value> requireObj;
   bool success = globalObject->Get(context, ToV8String(isolate, "require")).ToLocal(&requireObj);
   tns::Assert(success && requireObj->IsFunction(), isolate);
@@ -90,14 +118,17 @@
 void ModuleInternal::RequireCallback(const FunctionCallbackInfo<Value>& info) {
   Isolate* isolate = info.GetIsolate();
 
+  // Declare these outside try block so they're available in catch
+  std::string moduleName;
+  std::string callingModuleDirName;
+  NSString* fullPath = nil;
+
   try {
     ModuleInternal* moduleInternal =
         static_cast<ModuleInternal*>(info.Data().As<External>()->Value());
 
-    std::string moduleName = tns::ToString(isolate, info[0].As<v8::String>());
-    std::string callingModuleDirName = tns::ToString(isolate, info[1].As<v8::String>());
-
-    NSString* fullPath;
+    moduleName = tns::ToString(isolate, info[0].As<v8::String>());
+    callingModuleDirName = tns::ToString(isolate, info[1].As<v8::String>());
     if (moduleName.length() > 0 && moduleName[0] != '/') {
       if (moduleName[0] == '.') {
         fullPath = [[NSString stringWithUTF8String:callingModuleDirName.c_str()]
@@ -115,7 +146,7 @@
 
         const char* path1 = [fullPath fileSystemRepresentation];
         const char* path2 =
-            [[fullPath stringByAppendingPathExtension:@"js"] fileSystemRepresentation];
+            [[fullPath stringByAppendingPathExtension:@"mjs"] fileSystemRepresentation];
 
         if (!tns::Exists(path1) && !tns::Exists(path2)) {
           fullPath = [tnsModulesPath stringByAppendingPathComponent:@"tns-core-modules"];
@@ -149,7 +180,50 @@
       info.GetReturnValue().Set(exportsObj);
     }
   } catch (NativeScriptException& ex) {
-    ex.ReThrowToV8(isolate);
+    // Add context about the require call
+    std::string contextMsg = "Error in require() call:";
+    contextMsg += "\n  Requested module: '" + moduleName + "'";
+    contextMsg += "\n  Called from: " + callingModuleDirName;
+    if (fullPath != nil) {
+      contextMsg += "\n  Resolved path: " + std::string([fullPath UTF8String]);
+    }
+
+    // Add JavaScript stack trace to show who called require
+    Local<StackTrace> stackTrace =
+        StackTrace::CurrentStackTrace(isolate, 10, StackTrace::StackTraceOptions::kDetailed);
+    std::string jsStackTrace = "";
+    if (!stackTrace.IsEmpty()) {
+      for (int i = 0; i < stackTrace->GetFrameCount(); i++) {
+        Local<StackFrame> frame = stackTrace->GetFrame(isolate, i);
+        Local<v8::String> scriptName = frame->GetScriptName();
+        Local<v8::String> functionName = frame->GetFunctionName();
+        int lineNumber = frame->GetLineNumber();
+        int columnNumber = frame->GetColumn();
+
+        jsStackTrace += "\n    at ";
+        std::string funcName = tns::ToString(isolate, functionName);
+        std::string scriptNameStr = tns::ToString(isolate, scriptName);
+
+        if (!funcName.empty()) {
+          jsStackTrace += funcName + " (";
+        } else {
+          jsStackTrace += "<anonymous> (";
+        }
+        jsStackTrace += scriptNameStr + ":" + std::to_string(lineNumber) + ":" +
+                        std::to_string(columnNumber) + ")";
+      }
+    }
+
+    contextMsg += "\n\nJavaScript stack trace:" + jsStackTrace;
+    contextMsg += "\n\nOriginal error:\n" + ex.getMessage();
+
+    // Include original stack trace if available
+    if (!ex.getStackTrace().empty()) {
+      contextMsg += "\n\nOriginal stack trace:\n" + ex.getStackTrace();
+    }
+
+    NativeScriptException contextEx(isolate, contextMsg);
+    contextEx.ReThrowToV8(isolate);
   }
 }
 
@@ -167,8 +241,25 @@
 
   Local<Object> moduleObj;
   Local<Value> exportsObj;
-  std::string path = this->ResolvePath(isolate, baseDir, moduleName);
+  std::string path;
+
+  try {
+    path = this->ResolvePath(isolate, baseDir, moduleName);
+  } catch (NativeScriptException& ex) {
+    // Add context about the module resolution
+    std::string contextMsg = "Failed to resolve module: '" + moduleName + "'";
+    contextMsg += "\n  Base directory: " + baseDir;
+    contextMsg += "\n  Module name: " + moduleName;
+    contextMsg += "\n\nOriginal error:\n" + ex.getMessage();
+
+    throw NativeScriptException(isolate, contextMsg);
+  }
+
   if (path.empty()) {
+    // Create placeholder module for optional modules
+    if (IsLikelyOptionalModule(moduleName)) {
+      return this->CreatePlaceholderModule(isolate, moduleName, cacheKey);
+    }
     return Local<Object>();
   }
 
@@ -183,7 +274,7 @@
     return it2->second->Get(isolate);
   }
 
-  if ([extension isEqualToString:@"js"]) {
+  if ([extension isEqualToString:@"mjs"] || [extension isEqualToString:@"js"]) {
     moduleObj = this->LoadModule(isolate, path, cacheKey);
   } else if ([extension isEqualToString:@"json"]) {
     moduleObj = this->LoadData(isolate, path);
@@ -217,12 +308,79 @@
       std::make_shared<Persistent<Object>>(isolate, moduleObj);
   TempModule tempModule(this, modulePath, cacheKey, poModuleObj);
 
-  Local<Script> script = LoadScript(isolate, modulePath);
+  // Compile/load the JavaScript/ESM source
+  Local<Value> scriptValue = LoadScript(isolate, modulePath);
+
+  // Check if this is an ES module
+  bool isESM = modulePath.size() >= 4 && modulePath.compare(modulePath.size() - 4, 4, ".mjs") == 0;
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+
+  // Debug: Log module type detection
+  printf("LoadModule: Module path: %s, isESM: %s\n", modulePath.c_str(), isESM ? "true" : "false");
+
+  if (isESM) {
+    // For ES modules, the returned value is the namespace object
+    printf("LoadModule: Processing as ES module\n");
+
+    if (!scriptValue->IsObject()) {
+      printf("LoadModule: ES module failed - scriptValue is not an object\n");
+      throw NativeScriptException(isolate, "Failed to load ES module " + modulePath);
+    }
+    printf("LoadModule: ES module loaded successfully\n");
+
+    // Debug: Check if we're in a worker context and if self.onmessage is set
+    std::shared_ptr<Caches> cache = Caches::Get(isolate);
+    if (cache->isWorker) {
+      printf("LoadModule: In worker context, checking self.onmessage\n");
+      Local<Context> context = isolate->GetCurrentContext();
+      Local<Object> global = context->Global();
+
+      // Check if self exists
+      Local<Value> selfValue;
+      if (global->Get(context, ToV8String(isolate, "self")).ToLocal(&selfValue)) {
+        printf("LoadModule: self exists: %s\n", selfValue->IsObject() ? "object" : "not object");
+        if (selfValue->IsObject()) {
+          Local<Object> selfObj = selfValue.As<Object>();
+          Local<Value> onmessageValue;
+          if (selfObj->Get(context, ToV8String(isolate, "onmessage")).ToLocal(&onmessageValue)) {
+            printf("LoadModule: self.onmessage exists: %s\n",
+                   onmessageValue->IsFunction() ? "function" : "not function");
+          } else {
+            printf("LoadModule: self.onmessage does not exist\n");
+          }
+        }
+      } else {
+        printf("LoadModule: self does not exist\n");
+      }
+    }
+
+    // Handle exports differently for ES modules vs worker scripts
+    if (isESM) {
+      exportsObj = scriptValue.As<Object>();
+    } else {
+      // For worker scripts, create an empty exports object since they don't export anything
+      // They work through global scope (self.onmessage, etc.)
+      exportsObj = Object::New(isolate);
+    }
+
+    bool succ =
+        moduleObj->Set(context, tns::ToV8String(isolate, "exports"), exportsObj).FromMaybe(false);
+    tns::Assert(succ, isolate);
+
+    tempModule.SaveToCache();
+    return moduleObj;
+  }
+
+  // Classic CommonJS path – expect a factory function.
+  if (!scriptValue->IsFunction()) {
+    throw NativeScriptException(isolate,
+                                "Expected module factory to be a function for " + modulePath);
+  }
+  v8::Local<v8::Function> moduleFunc = scriptValue.As<v8::Function>();
 
-  Local<v8::Function> moduleFunc;
   {
     TryCatch tc(isolate);
-    moduleFunc = script->Run(context).ToLocalChecked().As<v8::Function>();
+    // moduleFunc = script->Run(context).ToLocalChecked().As<v8::Function>();
     if (tc.HasCaught()) {
       throw NativeScriptException(isolate, tc, "Error running script " + modulePath);
     }
@@ -282,35 +440,195 @@
   return json;
 }
 
-Local<Script> ModuleInternal::LoadScript(Isolate* isolate, const std::string& path) {
-  Local<Context> context = isolate->GetCurrentContext();
-  std::string baseOrigin = tns::ReplaceAll(path, RuntimeConfig.BaseDir, "");
-  std::string fullRequiredModulePathWithSchema = "file://" + baseOrigin;
-  ScriptOrigin origin(isolate, tns::ToV8String(isolate, fullRequiredModulePathWithSchema));
-  Local<v8::String> scriptText = WrapModuleContent(isolate, path);
-  ScriptCompiler::CachedData* cacheData = LoadScriptCache(path);
-  ScriptCompiler::Source source(scriptText, origin, cacheData);
+Local<Value> ModuleInternal::LoadScript(Isolate* isolate, const std::string& path) {
+  if (path.size() >= 4 && path.compare(path.size() - 4, 4, ".mjs") == 0) {
+    // Treat all .mjs files as standard ES modules.
+    return ModuleInternal::LoadESModule(isolate, path);
+  }
 
-  ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
+  Local<Script> script = ModuleInternal::LoadClassicScript(isolate, path);
+  // run it and return the value
+  return script->Run(isolate->GetCurrentContext()).ToLocalChecked();
+}
 
-  if (cacheData != nullptr) {
-    options = ScriptCompiler::kConsumeCodeCache;
-  }
+Local<Script> ModuleInternal::LoadClassicScript(Isolate* isolate, const std::string& path) {
+  // Ensure the resolved path maps to an actual regular file before attempting
+  // to read/compile it.  This prevents `ReadModule` from aborting the process
+  // when given a directory or non-existent path.
+  struct stat st;
+  if (stat(path.c_str(), &st) != 0 || !S_ISREG(st.st_mode)) {
+    throw NativeScriptException("Cannot find module " + path);
+  }
+
+  auto context = isolate->GetCurrentContext();
+  // build URL
+  std::string base = ReplaceAll(path, RuntimeConfig.BaseDir, "");
+  std::string url = "file://" + base;
+
+  // wrap & cache lookup
+  Local<v8::String> sourceText = ModuleInternal::WrapModuleContent(isolate, path);
+  auto* cacheData = ModuleInternal::LoadScriptCache(path);
+
+  // note: is_module=false here
+  ScriptOrigin origin(
+      isolate,
+      v8::String::NewFromUtf8(isolate, url.c_str(), NewStringType::kNormal).ToLocalChecked(),
+      0,      // line offset
+      0,      // column offset
+      false,  // shared_cross_origin
+      -1,     // script_id
+      Local<Value>(),
+      false,  // is_opaque
+      false,  // is_wasm
+      false   // is_module
+  );
+  ScriptCompiler::Source source(sourceText, origin, cacheData);
+
+  auto opts = cacheData ? ScriptCompiler::kConsumeCodeCache : ScriptCompiler::kNoCompileOptions;
 
-  Local<Script> script;
   TryCatch tc(isolate);
-  bool success = ScriptCompiler::Compile(context, &source, options).ToLocal(&script);
-  if (!success || tc.HasCaught()) {
-    throw NativeScriptException(isolate, tc, "Cannot compile " + path);
+  Local<Script> script;
+  if (!ScriptCompiler::Compile(context, &source, opts).ToLocal(&script) || tc.HasCaught()) {
+    throw NativeScriptException(isolate, tc, "Cannot compile script " + path);
   }
 
   if (cacheData == nullptr) {
-    SaveScriptCache(script, path);
+    ModuleInternal::SaveScriptCache(script, path);
   }
 
   return script;
 }
 
+Local<Value> ModuleInternal::LoadESModule(Isolate* isolate, const std::string& path) {
+  auto context = isolate->GetCurrentContext();
+
+  // 1) Prepare URL & source
+  std::string base = ReplaceAll(path, RuntimeConfig.BaseDir, "");
+  std::string url = "file://" + base;
+  v8::Local<v8::String> sourceText = ModuleInternal::WrapModuleContent(isolate, path);
+  auto* cacheData = ModuleInternal::LoadScriptCache(path);
+
+  ScriptOrigin origin(
+      isolate,
+      v8::String::NewFromUtf8(isolate, url.c_str(), NewStringType::kNormal).ToLocalChecked(), 0, 0,
+      false, -1, Local<Value>(), false, false,
+      true  // ← is_module
+  );
+  ScriptCompiler::Source source(sourceText, origin, cacheData);
+
+  // 2) Compile with its own TryCatch
+  Local<Module> module;
+  {
+    TryCatch tcCompile(isolate);
+    MaybeLocal<Module> maybeMod = ScriptCompiler::CompileModule(
+        isolate, &source,
+        cacheData ? ScriptCompiler::kConsumeCodeCache : ScriptCompiler::kNoCompileOptions);
+
+    if (!maybeMod.ToLocal(&module)) {
+      // V8 threw a syntax error or similar
+      throw NativeScriptException(isolate, tcCompile, "Cannot compile ES module " + path);
+    }
+  }
+
+  // 3) Register for resolution callback
+  extern std::unordered_map<std::string, Global<Module>> g_moduleRegistry;
+
+  // Safe Global handle management: Clear any existing entry first
+  auto it = g_moduleRegistry.find(path);
+  if (it != g_moduleRegistry.end()) {
+    // Clear the existing Global handle before replacing it
+    it->second.Reset();
+  }
+
+  // Now safely set the new module handle
+  g_moduleRegistry[path].Reset(isolate, module);
+
+  // 4) Save cache if first time
+  if (cacheData == nullptr) {
+    Local<UnboundModuleScript> unbound = module->GetUnboundModuleScript();
+    auto* generatedCache = ScriptCompiler::CreateCodeCache(unbound);
+    ModuleInternal::SaveScriptCache(generatedCache, path);
+  }
+
+  // 5) Instantiate (link) with its own TryCatch
+  {
+    TryCatch tcLink(isolate);
+    bool linked = module->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false);
+
+    if (!linked) {
+      if (tcLink.HasCaught()) {
+        throw NativeScriptException(isolate, tcLink, "Cannot instantiate module " + path);
+      } else {
+        // V8 gave no exception object—throw plain text
+        throw NativeScriptException(isolate, "Cannot instantiate module " + path);
+      }
+    }
+  }
+
+  // 6) Evaluate with its own TryCatch
+  Local<Value> result;
+  {
+    TryCatch tcEval(isolate);
+    printf("LoadESModule: About to evaluate module: %s\n", path.c_str());
+    if (!module->Evaluate(context).ToLocal(&result)) {
+      printf("LoadESModule: Evaluation failed for module: %s\n", path.c_str());
+      throw NativeScriptException(isolate, tcEval, "Cannot evaluate module " + path);
+    }
+    printf("LoadESModule: Evaluation completed successfully for module: %s\n", path.c_str());
+
+    // Handle the case where evaluation returns a Promise (for top-level await)
+    if (result->IsPromise()) {
+      printf("LoadESModule: Module evaluation returned a Promise, processing...\n");
+
+      // Use TryCatch to safely handle Promise operations
+      TryCatch promiseTc(isolate);
+      Local<Promise> promise = result.As<Promise>();
+
+      // Process microtasks to allow Promise resolution (for both worker and main contexts)
+      printf("LoadESModule: Processing microtasks for Promise resolution\n");
+
+      // Limited attempts to resolve the promise to avoid infinite loops
+      int maxAttempts = 100;
+      int attempts = 0;
+
+      while (attempts < maxAttempts && !promiseTc.HasCaught()) {
+        isolate->PerformMicrotaskCheckpoint();
+
+        // Check promise state safely
+        if (promiseTc.HasCaught()) {
+          printf("LoadESModule: Exception during Promise processing, breaking\n");
+          break;
+        }
+
+        Promise::PromiseState state = promise->State();
+
+        if (state != Promise::kPending) {
+          if (state == Promise::kRejected) {
+            printf("LoadESModule: Promise was rejected\n");
+            if (!promiseTc.HasCaught()) {
+              Local<Value> reason = promise->Result();
+              isolate->ThrowException(reason);
+            }
+            throw NativeScriptException(isolate, promiseTc, "Module evaluation promise rejected");
+          }
+          printf("LoadESModule: Promise resolved successfully\n");
+          break;
+        }
+
+        attempts++;
+        usleep(100);  // 0.1ms delay
+      }
+
+      if (attempts >= maxAttempts) {
+        printf("LoadESModule: Promise resolution timeout, continuing anyway\n");
+      }
+    }
+  }
+
+  // 7) Return the namespace
+  return module->GetModuleNamespace();
+}
+
 MaybeLocal<Value> ModuleInternal::RunScriptString(Isolate* isolate, Local<Context> context,
                                                   const std::string scriptString) {
   ScriptCompiler::CompileOptions options = ScriptCompiler::kNoCompileOptions;
@@ -332,7 +650,42 @@
   this->RunScriptString(isolate, context, script);
 }
 
-Local<v8::String> ModuleInternal::WrapModuleContent(Isolate* isolate, const std::string& path) {
+v8::Local<v8::String> ModuleInternal::WrapModuleContent(v8::Isolate* isolate,
+                                                        const std::string& path) {
+  // For classical scripts we wrap the source into the CommonJS factory function
+  // but for ES modules (".mjs") we must leave the source intact so that the
+  // V8 parser can recognise the "export"/"import" syntax. Wrapping an ES module
+  // in a function expression would turn those top-level keywords into syntax
+  // errors (e.g. `export *` → "Unexpected token '*'").
+
+  // Check if we're in a worker context
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  bool isWorkerContext = cache && cache->isWorker;
+
+  if (path.size() >= 4 && path.compare(path.size() - 4, 4, ".mjs") == 0) {
+    // Read raw text without wrapping.
+    std::string sourceText = tns::ReadText(path);
+
+    // For ES modules in worker context, we need to provide access to global objects
+    // since ES modules run in their own scope
+    if (isWorkerContext) {
+      // Prepend global declarations to make worker globals available in ES module scope
+      std::string globalDeclarations = "const self = globalThis.self || globalThis;\n"
+                                       "const postMessage = globalThis.postMessage;\n"
+                                       "const close = globalThis.close;\n"
+                                       "const importScripts = globalThis.importScripts;\n"
+                                       "const console = globalThis.console;\n"
+                                       "\n";
+
+      sourceText = globalDeclarations + sourceText;
+    }
+
+    return tns::ToV8String(isolate, sourceText);
+  }
+
+  // Worker .js files should use CommonJS wrapping like regular .js files
+  // This ensures proper runtime context and global object setup
+
   return tns::ReadModule(isolate, path);
 }
 
@@ -348,7 +701,7 @@
   BOOL exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
 
   if (exists == YES && isDirectory == YES) {
-    NSString* jsFile = [fullPath stringByAppendingPathExtension:@"js"];
+    NSString* jsFile = [fullPath stringByAppendingPathExtension:@"mjs"];
     BOOL isDir;
     if ([fileManager fileExistsAtPath:jsFile isDirectory:&isDir] && isDir == NO) {
       return [jsFile UTF8String];
@@ -356,12 +709,30 @@
   }
 
   if (exists == NO) {
-    fullPath = [fullPath stringByAppendingPathExtension:@"js"];
+    fullPath = [fullPath stringByAppendingPathExtension:@"mjs"];
     exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
   }
 
   if (exists == NO) {
-    throw NativeScriptException("The specified module does not exist: " + moduleName);
+    // Check if this looks like an optional module
+    if (IsLikelyOptionalModule(moduleName)) {
+      // Return empty string to indicate optional module not found
+      return std::string();
+    }
+
+    // Create a detailed error message with context
+    std::string errorMsg = "Module not found: '" + moduleName + "'";
+    errorMsg += "\n  Base directory: " + baseDir;
+    errorMsg += "\n  Attempted paths:";
+
+    // Show the original path attempt
+    NSString* originalPath =
+        [[baseDirStr stringByAppendingPathComponent:moduleNameStr] stringByStandardizingPath];
+    errorMsg += "\n    - " + std::string([originalPath UTF8String]);
+    errorMsg +=
+        "\n    - " + std::string([[originalPath stringByAppendingPathExtension:@"mjs"] UTF8String]);
+
+    throw NativeScriptException(isolate, errorMsg);
   }
 
   if (isDirectory == NO) {
@@ -387,14 +758,26 @@ throw NativeScriptException("Unable to locate main entry in " +
   }
 
   if (exists == NO) {
-    fullPath = [fullPath stringByAppendingPathExtension:@"js"];
+    fullPath = [fullPath stringByAppendingPathExtension:@"mjs"];
   } else {
-    fullPath = [fullPath stringByAppendingPathComponent:@"index.js"];
+    fullPath = [fullPath stringByAppendingPathComponent:@"index.mjs"];
   }
 
   exists = [fileManager fileExistsAtPath:fullPath isDirectory:&isDirectory];
   if (exists == NO) {
-    throw NativeScriptException("The specified module does not exist: " + moduleName);
+    // Check if this looks like an optional module
+    if (IsLikelyOptionalModule(moduleName)) {
+      // Return empty string to indicate optional module not found
+      return std::string();
+    }
+
+    // Create a detailed error message with context for package.json resolution
+    std::string errorMsg = "Module not found: '" + moduleName + "'";
+    errorMsg += "\n  Base directory: " + baseDir;
+    errorMsg += "\n  Attempted final paths:";
+    errorMsg += "\n    - " + std::string([fullPath UTF8String]);
+
+    throw NativeScriptException(isolate, errorMsg);
   }
 
   return [fullPath UTF8String];
@@ -442,13 +825,76 @@ throw NativeScriptException("Unable to locate main entry in " +
   return [path UTF8String];
 }
 
+Local<Object> ModuleInternal::CreatePlaceholderModule(Isolate* isolate,
+                                                      const std::string& moduleName,
+                                                      const std::string& cacheKey) {
+  Local<Context> context = isolate->GetCurrentContext();
+
+  // Create a module object with exports that throws when accessed
+  Local<Object> moduleObj = Object::New(isolate);
+
+  // Create a Proxy that throws an error when any property is accessed
+  std::string errorMessage =
+      "Module '" + moduleName + "' is not available. This is an optional module.";
+  std::string proxyCode = "(function() {"
+                          "  const error = new Error('" +
+                          errorMessage +
+                          "');"
+                          "  return new Proxy({}, {"
+                          "    get: function(target, prop) {"
+                          "      throw error;"
+                          "    },"
+                          "    set: function(target, prop, value) {"
+                          "      throw error;"
+                          "    },"
+                          "    has: function(target, prop) {"
+                          "      return false;"
+                          "    },"
+                          "    ownKeys: function(target) {"
+                          "      return [];"
+                          "    },"
+                          "    getPrototypeOf: function(target) {"
+                          "      return null;"
+                          "    }"
+                          "  });"
+                          "})()";
+
+  Local<Script> proxyScript;
+  if (Script::Compile(context, tns::ToV8String(isolate, proxyCode.c_str())).ToLocal(&proxyScript)) {
+    Local<Value> proxyObject;
+    if (proxyScript->Run(context).ToLocal(&proxyObject)) {
+      // Set the exports to the proxy object
+      bool success = moduleObj->Set(context, tns::ToV8String(isolate, "exports"), proxyObject)
+                         .FromMaybe(false);
+      tns::Assert(success, isolate);
+    }
+  }
+
+  // Set up the module object
+  bool success = moduleObj
+                     ->Set(context, tns::ToV8String(isolate, "id"),
+                           tns::ToV8String(isolate, moduleName.c_str()))
+                     .FromMaybe(false);
+  tns::Assert(success, isolate);
+
+  success =
+      moduleObj->Set(context, tns::ToV8String(isolate, "loaded"), v8::Boolean::New(isolate, true))
+          .FromMaybe(false);
+  tns::Assert(success, isolate);
+
+  // Cache the placeholder module
+  this->loadedModules_[cacheKey] = std::make_shared<Persistent<Object>>(isolate, moduleObj);
+
+  return moduleObj;
+}
+
 ScriptCompiler::CachedData* ModuleInternal::LoadScriptCache(const std::string& path) {
   if (RuntimeConfig.IsDebug) {
     return nullptr;
   }
 
   long length = 0;
-  std::string cachePath = GetCacheFileName(path + ".cache");
+  std::string cachePath = ModuleInternal::GetCacheFileName(path + ".cache");
 
   struct stat result;
   if (stat(cachePath.c_str(), &result) == 0) {
@@ -474,6 +920,33 @@ throw NativeScriptException("Unable to locate main entry in " +
       isNew ? ScriptCompiler::CachedData::BufferOwned : ScriptCompiler::CachedData::BufferNotOwned);
 }
 
+void ModuleInternal::SaveScriptCache(const ScriptCompiler::CachedData* cache,
+                                     const std::string& path) {
+  std::string cachePath = ModuleInternal::GetCacheFileName(path + ".cache");
+
+  // std::ofstream ofs(cachePath, std::ios::binary);
+  // if (!ofs) return;  // or throw
+
+  // ofs.write(reinterpret_cast<const char*>(cache->data),
+  //           cache->length);
+  // ofs.close();
+
+  int length = cache->length;
+  tns::WriteBinary(cachePath, cache->data, length);
+  delete cache;
+
+  // make sure cache and js file have the same modification date
+  struct stat result;
+  struct utimbuf new_times;
+  new_times.actime = time(nullptr);
+  new_times.modtime = time(nullptr);
+  if (stat(path.c_str(), &result) == 0) {
+    auto jsLastModifiedTime = result.st_mtime;
+    new_times.modtime = jsLastModifiedTime;
+  }
+  utime(cachePath.c_str(), &new_times);
+}
+
 void ModuleInternal::SaveScriptCache(const Local<Script> script, const std::string& path) {
   if (RuntimeConfig.IsDebug) {
     return;
@@ -484,7 +957,7 @@ throw NativeScriptException("Unable to locate main entry in " +
   ScriptCompiler::CachedData* cachedData = ScriptCompiler::CreateCodeCache(unboundScript);
 
   int length = cachedData->length;
-  std::string cachePath = GetCacheFileName(path + ".cache");
+  std::string cachePath = ModuleInternal::GetCacheFileName(path + ".cache");
   tns::WriteBinary(cachePath, cachedData->data, length);
   delete cachedData;
 
diff --git a/NativeScript/runtime/ModuleInternalCallbacks.h b/NativeScript/runtime/ModuleInternalCallbacks.h
new file mode 100644
index 00000000..676824a7
--- /dev/null
+++ b/NativeScript/runtime/ModuleInternalCallbacks.h
@@ -0,0 +1,25 @@
+// ModuleInternalCallbacks.h
+#pragma once
+#include <v8.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace tns {
+
+// Export our registry so both LoadESModule and the callback see the same data:
+extern std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
+
+// Resolve callback signature (with import‑assertions slot)
+v8::MaybeLocal<v8::Module> ResolveModuleCallback(
+    v8::Local<v8::Context> context, v8::Local<v8::String> specifier,
+    v8::Local<v8::FixedArray> import_assertions,
+    v8::Local<v8::Module> referrer);
+
+// Host callback for dynamic import() expressions
+v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
+    v8::Local<v8::Context> context, v8::Local<v8::ScriptOrModule> referrer,
+    v8::Local<v8::String> specifier,
+    v8::Local<v8::FixedArray> import_assertions);
+
+}  // namespace tns
diff --git a/NativeScript/runtime/ModuleInternalCallbacks.mm b/NativeScript/runtime/ModuleInternalCallbacks.mm
new file mode 100644
index 00000000..f7d65698
--- /dev/null
+++ b/NativeScript/runtime/ModuleInternalCallbacks.mm
@@ -0,0 +1,591 @@
+// ModuleInternalCallbacks.mm
+#include "ModuleInternalCallbacks.h"
+#include <sys/stat.h>
+#include <v8.h>
+#include <queue>
+#include <string>
+#include <unordered_map>
+#include "Helpers.h"         // for tns::Exists
+#include "ModuleInternal.h"  // for LoadScript(...)
+#include "NativeScriptException.h"
+#include "Runtime.h"  // for GetAppConfigValue
+#include "RuntimeConfig.h"
+
+// Do NOT pull all v8 symbols into namespace here; String would clash with
+// other typedefs inside the NativeScript codebase. We refer to v8 symbols
+// with explicit `v8::` qualification to avoid ambiguities.
+
+namespace tns {
+
+// ────────────────────────────────────────────────────────────────────────────
+// Helper function to check if script loading logging is enabled
+// This reads the "logScriptLoading" boolean option from nativescript.config (aka, package.json in
+// the app bundle). Usage: Add "logScriptLoading": true to your nativescript.config to enable
+// verbose logging of module resolution and dynamic imports for debugging.
+static bool IsScriptLoadingLogEnabled() {
+  id value = Runtime::GetAppConfigValue("logScriptLoading");
+  return value ? [value boolValue] : false;
+}
+
+// Helper function to check if a module name looks like an optional external module
+static bool IsLikelyOptionalModule(const std::string& moduleName) {
+  // Skip Node.js built-in modules (they should be handled separately)
+  if (moduleName.rfind("node:", 0) == 0) {
+    return false;
+  }
+
+  // Check if it's a bare module name (no path separators) that could be an npm package
+  if (moduleName.find('/') == std::string::npos && moduleName.find('\\') == std::string::npos &&
+      moduleName[0] != '.' && moduleName[0] != '~' && moduleName[0] != '/') {
+    return true;
+  }
+  return false;
+}
+
+// Helper function to check if a module name is a Node.js built-in module
+static bool IsNodeBuiltinModule(const std::string& moduleName) {
+  return moduleName.rfind("node:", 0) == 0;
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Simple in-process registry: maps absolute file paths → compiled Module handles
+std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
+
+// Callback invoked by V8 to resolve `import X from 'specifier';`
+v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
+                                                 v8::Local<v8::String> specifier,
+                                                 v8::Local<v8::FixedArray> import_assertions,
+                                                 v8::Local<v8::Module> referrer) {
+  v8::Isolate* isolate = context->GetIsolate();
+
+  // 1) Turn the specifier literal into a std::string:
+  v8::String::Utf8Value specUtf8(isolate, specifier);
+  std::string spec = *specUtf8 ? *specUtf8 : "";
+  if (spec.empty()) {
+    return v8::MaybeLocal<v8::Module>();
+  }
+
+  // Debug: Log all module resolution attempts, especially for @nativescript/core/globals
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  if (cache->isWorker) {
+    printf("ResolveModuleCallback: Worker trying to resolve '%s'\n", spec.c_str());
+  }
+
+  // 2) Find which filepath the referrer was compiled under
+  std::string referrerPath;
+  for (auto& kv : g_moduleRegistry) {
+    v8::Local<v8::Module> registered = kv.second.Get(isolate);
+    if (registered == referrer) {
+      referrerPath = kv.first;
+      break;
+    }
+  }
+  // If we couldn't identify the referrer (e.g. coming from a dynamic import
+  // where the embedder did not pass the compiled Module), we can still proceed
+  // for absolute and application-rooted specifiers. Only bail out early when
+  // the specifier is clearly relative (starts with "./" or "../") and we
+  // would need the referrer's directory to resolve it.
+  bool specIsRelative = !spec.empty() && spec[0] == '.';
+  if (referrerPath.empty() && specIsRelative) {
+    // Unable to resolve a relative path without knowing the base directory.
+    return v8::MaybeLocal<v8::Module>();
+  }
+
+  // 3) Compute its directory
+  size_t slash = referrerPath.find_last_of("/\\");
+  std::string baseDir = slash == std::string::npos ? "" : referrerPath.substr(0, slash + 1);
+
+  // 4) Resolve the import specifier relative to that directory.
+  //    The incoming specifier may omit the file extension (e.g. "./foo") or
+  //    point to a directory.  Try to follow Node-style resolution rules for
+  //    the most common cases so that we locate the actual .mjs file on disk
+  //    before handing the path to LoadScript.
+
+  // ────────────────────────────────────────────────
+  // Build initial absolute path candidates
+  // ────────────────────────────────────────────────
+
+  std::vector<std::string> candidateBases;
+
+  if (!spec.empty() && spec[0] == '.') {
+    // Relative import (./ or ../)
+    std::string cleanSpec = spec.rfind("./", 0) == 0 ? spec.substr(2) : spec;
+    candidateBases.push_back(baseDir + cleanSpec);
+  } else if (spec.rfind("file://", 0) == 0) {
+    // Absolute file URL, e.g. file:///app/path/to/chunk.mjs
+    std::string tail = spec.substr(7);  // strip file://
+    if (tail.rfind("/", 0) != 0) {
+      tail = "/" + tail;
+    }
+    // If starts with /app/... drop the leading /app
+    const std::string appPrefix = "/app/";
+    std::string tailNoApp = tail;
+    if (tail.rfind(appPrefix, 0) == 0) {
+      tailNoApp = tail.substr(appPrefix.size());
+    }
+    // Candidate that keeps /app/ prefix stripped
+    std::string baseNoApp = RuntimeConfig.ApplicationPath + "/" + tailNoApp;
+    candidateBases.push_back(baseNoApp);
+
+    // Also try path with original tail (includes /app/...) directly under application dir
+    std::string baseWithApp = RuntimeConfig.ApplicationPath + tail;  // tail already begins with '/'
+    candidateBases.push_back(baseWithApp);
+  } else if (!spec.empty() && spec[0] == '~') {
+    // Alias to application root using ~/path
+    std::string tail = spec.size() >= 2 && spec[1] == '/' ? spec.substr(2) : spec.substr(1);
+    std::string base = RuntimeConfig.ApplicationPath + "/" + tail;
+    candidateBases.push_back(base);
+
+    // Debug: Log tilde resolution for worker context
+    if (cache->isWorker) {
+      printf("ResolveModuleCallback: Worker resolving tilde path '%s' -> '%s'\n", spec.c_str(),
+             base.c_str());
+    }
+  } else if (!spec.empty() && spec[0] == '/') {
+    // Absolute path within the bundle
+    candidateBases.push_back(spec);
+  } else {
+    // Bare specifier – resolve relative to the application root directory
+    std::string base = RuntimeConfig.ApplicationPath + "/" + spec;
+    candidateBases.push_back(base);
+
+    // Additional heuristic: Webpack encodes path separators as underscores in
+    // chunk IDs (e.g. "src_app_components_foo_bar_ts.mjs").  Try converting
+    // those underscores back to slashes and look for that file as well.
+    std::string withSlashes = spec;
+    std::replace(withSlashes.begin(), withSlashes.end(), '_', '/');
+    std::string baseSlashes = RuntimeConfig.ApplicationPath + "/" + withSlashes;
+    if (baseSlashes != base) {
+      candidateBases.push_back(baseSlashes);
+    }
+  }
+
+  // We'll iterate these bases and attempt to resolve to an actual file
+  std::string absPath;
+
+  // Utility: returns true iff `p` exists AND is a regular file (not directory)
+  auto isFile = [](const std::string& p) -> bool {
+    struct stat st;
+    if (stat(p.c_str(), &st) != 0) {
+      return false;
+    }
+    return (st.st_mode & S_IFMT) == S_IFREG;
+  };
+
+  // Helper to append extension if missing
+  auto withExt = [](const std::string& p, const std::string& ext) -> std::string {
+    if (p.size() >= ext.size() && p.compare(p.size() - ext.size(), ext.size(), ext) == 0) {
+      return p;
+    }
+    return p + ext;
+  };
+
+  //  ── Resolution attempts ───────────────────────────────────────
+  // Iterate base candidates until we find a file match
+  for (const std::string& baseCandidate : candidateBases) {
+    absPath = baseCandidate;
+
+    bool existsNow = isFile(absPath);
+    if (IsScriptLoadingLogEnabled()) {
+      NSLog(@"[resolver] %s -> %s", absPath.c_str(), existsNow ? "file" : "missing");
+    }
+
+    if (!existsNow) {
+      // 1) Try adding .mjs, .js
+      const char* exts[] = {".mjs", ".js"};
+      bool found = false;
+      for (const char* e : exts) {
+        std::string cand = withExt(absPath, e);
+        if (isFile(cand)) {
+          absPath = cand;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        // 2) If absPath is directory, look for index files
+        const char* idxExts[] = {"/index.mjs", "/index.js"};
+        for (const char* idx : idxExts) {
+          std::string cand = absPath + idx;
+          if (isFile(cand)) {
+            absPath = cand;
+            found = true;
+            break;
+          }
+        }
+      }
+      if (found) {
+        break;
+      }
+    }
+    if (isFile(absPath)) {
+      break;  // stop at first hit
+    }
+  }
+
+  // At this point, absPath is either a valid file or last attempted candidate.
+
+  // If we still didn't resolve to an actual file, surface an exception instead
+  // of letting ReadModule() assert while trying to open a directory.
+  if (!isFile(absPath)) {
+    // Debug: Log resolution failure for worker context
+    if (cache->isWorker) {
+      printf("ResolveModuleCallback: Worker failed to resolve '%s' -> '%s'\n", spec.c_str(),
+             absPath.c_str());
+    }
+
+    // Check if this is a Node.js built-in module (e.g., node:url)
+    if (IsNodeBuiltinModule(spec)) {
+      // Strip the "node:" prefix and try to resolve as a regular module
+      std::string builtinName = spec.substr(5);  // Remove "node:" prefix
+      std::string builtinPath = RuntimeConfig.ApplicationPath + "/" + builtinName + ".mjs";
+
+      // Check if a polyfill file exists
+      if (!isFile(builtinPath)) {
+        // Create a basic polyfill for the built-in module
+        std::string polyfillContent;
+
+        if (builtinName == "url") {
+          // Create a polyfill for node:url with fileURLToPath
+          polyfillContent = "// Polyfill for node:url\n"
+                            "export function fileURLToPath(url) {\n"
+                            "  if (typeof url === 'string') {\n"
+                            "    if (url.startsWith('file://')) {\n"
+                            "      return decodeURIComponent(url.slice(7));\n"
+                            "    }\n"
+                            "    return url;\n"
+                            "  }\n"
+                            "  if (url && typeof url.href === 'string') {\n"
+                            "    return fileURLToPath(url.href);\n"
+                            "  }\n"
+                            "  throw new Error('Invalid URL');\n"
+                            "}\n"
+                            "\n"
+                            "export function pathToFileURL(path) {\n"
+                            "  return new URL('file://' + encodeURIComponent(path));\n"
+                            "}\n";
+        } else {
+          // Generic polyfill for other Node.js built-in modules
+          polyfillContent = "// Polyfill for node:" + builtinName +
+                            "\n"
+                            "console.warn('Node.js built-in module \\'node:" +
+                            builtinName +
+                            "\\' is not fully supported in NativeScript');\n"
+                            "export default {};\n";
+        }
+
+        // Write polyfill file
+        NSString* polyfillPathStr = [NSString stringWithUTF8String:builtinPath.c_str()];
+        NSString* polyfillContentStr = [NSString stringWithUTF8String:polyfillContent.c_str()];
+
+        if ([polyfillContentStr writeToFile:polyfillPathStr
+                                 atomically:YES
+                                   encoding:NSUTF8StringEncoding
+                                      error:nil]) {
+          // File created successfully, now resolve it normally
+          absPath = builtinPath;
+        } else {
+          // Failed to create file, fall back to throwing error
+          std::string msg = "Cannot find module " + spec + " (tried " + absPath + ")";
+          isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg)));
+          return v8::MaybeLocal<v8::Module>();
+        }
+      } else {
+        // Polyfill file already exists, use it
+        absPath = builtinPath;
+      }
+    } else if (IsLikelyOptionalModule(spec)) {
+      // Create a placeholder file on disk that webpack can resolve to
+      std::string appPath = RuntimeConfig.ApplicationPath;
+      std::string placeholderPath = appPath + "/" + spec + ".mjs";
+
+      // Check if placeholder file already exists
+      if (!isFile(placeholderPath)) {
+        // Create placeholder content
+        std::string placeholderContent = "const error = new Error('Module \\'" + spec +
+                                         "\\' is not available. This is an optional module.');\n"
+                                         "const proxy = new Proxy({}, {\n"
+                                         "  get: function(target, prop) { throw error; },\n"
+                                         "  set: function(target, prop, value) { throw error; },\n"
+                                         "  has: function(target, prop) { return false; },\n"
+                                         "  ownKeys: function(target) { return []; },\n"
+                                         "  getPrototypeOf: function(target) { return null; }\n"
+                                         "});\n"
+                                         "export default proxy;\n";
+
+        // Write placeholder file
+        NSString* placeholderPathStr = [NSString stringWithUTF8String:placeholderPath.c_str()];
+        NSString* placeholderContentStr =
+            [NSString stringWithUTF8String:placeholderContent.c_str()];
+
+        if ([placeholderContentStr writeToFile:placeholderPathStr
+                                    atomically:YES
+                                      encoding:NSUTF8StringEncoding
+                                         error:nil]) {
+          // File created successfully, now resolve it normally
+          absPath = placeholderPath;
+        } else {
+          // Failed to create file, fall back to throwing error
+          std::string msg = "Cannot find module " + spec + " (tried " + absPath + ")";
+          isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg)));
+          return v8::MaybeLocal<v8::Module>();
+        }
+      } else {
+        // Placeholder file already exists, use it
+        absPath = placeholderPath;
+      }
+    } else {
+      // Not an optional module, throw the original error
+      std::string msg = "Cannot find module " + spec + " (tried " + absPath + ")";
+      isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg)));
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+
+  // Special handling for JSON imports (e.g. import data from './foo.json' assert {type:'json'})
+  if (absPath.size() >= 5 && absPath.compare(absPath.size() - 5, 5, ".json") == 0) {
+    // Debug: Log JSON module handling for worker context
+    if (cache->isWorker) {
+      printf("ResolveModuleCallback: Worker handling JSON module '%s'\n", absPath.c_str());
+    }
+
+    // Read file contents
+    std::string jsonText = tns::ReadText(absPath);
+
+    // Debug: Log JSON content preview for worker context
+    if (cache->isWorker) {
+      std::string preview = jsonText.length() > 200 ? jsonText.substr(0, 200) + "..." : jsonText;
+      printf("ResolveModuleCallback: Worker JSON content preview: %s\n", preview.c_str());
+    }
+
+    // Build a small ES module that just exports the parsed JSON as default
+    std::string moduleSource = "export default " + jsonText + ";";
+
+    v8::Local<v8::String> sourceText = tns::ToV8String(isolate, moduleSource);
+    // Build URL for stack traces
+    std::string base = ReplaceAll(absPath, RuntimeConfig.BaseDir, "");
+    std::string url = "file://" + base;
+
+    v8::ScriptOrigin origin(
+        isolate,
+        v8::String::NewFromUtf8(isolate, url.c_str(), v8::NewStringType::kNormal).ToLocalChecked(),
+        0, 0, false, -1, v8::Local<v8::Value>(), false, false, true /* is_module */);
+
+    v8::ScriptCompiler::Source src(sourceText, origin);
+
+    v8::Local<v8::Module> jsonModule;
+    if (!v8::ScriptCompiler::CompileModule(isolate, &src).ToLocal(&jsonModule)) {
+      isolate->ThrowException(
+          v8::Exception::SyntaxError(tns::ToV8String(isolate, "Failed to compile JSON module")));
+      return v8::MaybeLocal<v8::Module>();
+    }
+
+    // No imports inside this module, so instantiate directly
+    if (!jsonModule->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false)) {
+      return v8::MaybeLocal<v8::Module>();
+    }
+
+    // Evaluate immediately so namespace is populated
+    v8::MaybeLocal<v8::Value> evalResult = jsonModule->Evaluate(context);
+    if (evalResult.IsEmpty()) {
+      return v8::MaybeLocal<v8::Module>();
+    }
+
+    // Store in registry and return
+    g_moduleRegistry[absPath].Reset(isolate, jsonModule);
+    return v8::MaybeLocal<v8::Module>(jsonModule);
+  }
+
+  // 5) If we've already compiled that module (non-JSON case), return it
+  auto it = g_moduleRegistry.find(absPath);
+  if (it != g_moduleRegistry.end()) {
+    if (cache->isWorker) {
+      printf("ResolveModuleCallback: Worker found cached module '%s' -> '%s'\n", spec.c_str(),
+             absPath.c_str());
+    }
+    return v8::MaybeLocal<v8::Module>(it->second.Get(isolate));
+  }
+
+  // 6) Otherwise, compile & register it
+  if (cache->isWorker) {
+    printf("ResolveModuleCallback: Worker compiling new module '%s' -> '%s'\n", spec.c_str(),
+           absPath.c_str());
+  }
+  try {
+    tns::ModuleInternal::LoadScript(isolate, absPath);
+  } catch (NativeScriptException& ex) {
+    if (cache->isWorker) {
+      printf("ResolveModuleCallback: Worker failed to compile module '%s' -> '%s'\n", spec.c_str(),
+             absPath.c_str());
+    }
+    ex.ReThrowToV8(isolate);
+    return v8::MaybeLocal<v8::Module>();
+  }
+  // LoadScript will have added it into g_moduleRegistry under absPath
+  auto it2 = g_moduleRegistry.find(absPath);
+  if (it2 == g_moduleRegistry.end()) {
+    // something went wrong
+    return v8::MaybeLocal<v8::Module>();
+  }
+  return v8::MaybeLocal<v8::Module>(it2->second.Get(isolate));
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Dynamic import() host callback
+v8::MaybeLocal<v8::Promise> ImportModuleDynamicallyCallback(
+    v8::Local<v8::Context> context, v8::Local<v8::ScriptOrModule> referrer,
+    v8::Local<v8::String> specifier, v8::Local<v8::FixedArray> import_assertions) {
+  v8::Isolate* isolate = context->GetIsolate();
+  // Diagnostic: log every dynamic import attempt.
+  v8::String::Utf8Value specUtf8(isolate, specifier);
+  const char* cSpec = (*specUtf8) ? *specUtf8 : "<invalid>";
+  NSString* specStr = [NSString stringWithUTF8String:cSpec];
+  if (IsScriptLoadingLogEnabled()) {
+    NSLog(@"[dyn-import] → %@", specStr);
+  }
+  v8::EscapableHandleScope scope(isolate);
+
+  // Create a Promise resolver we'll resolve/reject synchronously for now.
+  v8::Local<v8::Promise::Resolver> resolver = v8::Promise::Resolver::New(context).ToLocalChecked();
+
+  // Re-use the static resolver to locate / compile the module.
+  try {
+    // Pass empty referrer since this V8 version doesn't expose GetModule() on
+    // ScriptOrModule. The resolver will fall back to absolute-path heuristics.
+    v8::Local<v8::Module> refMod;
+
+    v8::MaybeLocal<v8::Module> maybeModule =
+        ResolveModuleCallback(context, specifier, import_assertions, refMod);
+
+    v8::Local<v8::Module> module;
+    if (!maybeModule.ToLocal(&module)) {
+      // ResolveModuleCallback already threw; forward the V8 exception
+      return scope.Escape(resolver->GetPromise());
+    }
+
+    // If not yet instantiated/evaluated, do it now
+    if (module->GetStatus() == v8::Module::kUninstantiated) {
+      if (!module->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false)) {
+        if (IsScriptLoadingLogEnabled()) {
+          NSLog(@"[dyn-import] ✗ instantiate failed %@", specStr);
+        }
+        resolver
+            ->Reject(context,
+                     v8::Exception::Error(tns::ToV8String(isolate, "Failed to instantiate module")))
+            .Check();
+        return scope.Escape(resolver->GetPromise());
+      }
+    }
+
+    if (module->GetStatus() != v8::Module::kEvaluated) {
+      if (module->Evaluate(context).IsEmpty()) {
+        if (IsScriptLoadingLogEnabled()) {
+          NSLog(@"[dyn-import] ✗ evaluation failed %@", specStr);
+        }
+        v8::Local<v8::Value> ex =
+            v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed"));
+        resolver->Reject(context, ex).Check();
+        return scope.Escape(resolver->GetPromise());
+      }
+    }
+
+    // Special handling for webpack chunks: check if this is a webpack chunk and install it
+    v8::Local<v8::Value> namespaceObj = module->GetModuleNamespace();
+    if (namespaceObj->IsObject()) {
+      v8::Local<v8::Object> nsObj = namespaceObj.As<v8::Object>();
+
+      // Check if this is a webpack chunk (has __webpack_ids__ export)
+      v8::Local<v8::String> webpackIdsKey = tns::ToV8String(isolate, "__webpack_ids__");
+      v8::Local<v8::Value> webpackIds;
+      if (nsObj->Get(context, webpackIdsKey).ToLocal(&webpackIds) && !webpackIds->IsUndefined()) {
+        if (IsScriptLoadingLogEnabled()) {
+          NSLog(@"[dyn-import] Detected webpack chunk %@", specStr);
+        }
+        // This is a webpack chunk, get the webpack runtime from the runtime module
+        try {
+          // Import the runtime module to get __webpack_require__
+          // For import assertions, we need to pass an empty FixedArray
+          // Use the empty fixed array from the isolate's roots
+          v8::Local<v8::FixedArray> empty_assertions = v8::Local<v8::FixedArray>();
+          v8::MaybeLocal<v8::Module> maybeRuntimeModule =
+              ResolveModuleCallback(context, tns::ToV8String(isolate, "file:///app/runtime.mjs"),
+                                    empty_assertions, v8::Local<v8::Module>());
+
+          v8::Local<v8::Module> runtimeModule;
+          if (maybeRuntimeModule.ToLocal(&runtimeModule)) {
+            v8::Local<v8::Value> runtimeNamespace = runtimeModule->GetModuleNamespace();
+            if (runtimeNamespace->IsObject()) {
+              v8::Local<v8::Object> runtimeObj = runtimeNamespace.As<v8::Object>();
+              v8::Local<v8::String> defaultKey = tns::ToV8String(isolate, "default");
+              v8::Local<v8::Value> webpackRequire;
+
+              if (runtimeObj->Get(context, defaultKey).ToLocal(&webpackRequire) &&
+                  webpackRequire->IsObject()) {
+                if (IsScriptLoadingLogEnabled()) {
+                  NSLog(@"[dyn-import] Found runtime module default export");
+                }
+                v8::Local<v8::String> installKey = tns::ToV8String(isolate, "C");
+                v8::Local<v8::Value> installFn;
+                if (webpackRequire.As<v8::Object>()->Get(context, installKey).ToLocal(&installFn) &&
+                    installFn->IsFunction()) {
+                  if (IsScriptLoadingLogEnabled()) {
+                    NSLog(@"[dyn-import] Calling webpack installChunk function");
+                  }
+                  // Call webpack's installChunk function with the module namespace
+                  v8::Local<v8::Value> args[] = {namespaceObj};
+                  v8::Local<v8::Value> result;
+                  if (!installFn.As<v8::Function>()
+                           ->Call(context, v8::Undefined(isolate), 1, args)
+                           .ToLocal(&result)) {
+                    // If the call fails, we can ignore it since this is just a helper for webpack
+                    // chunks
+                    if (IsScriptLoadingLogEnabled()) {
+                      NSLog(@"[dyn-import] ✗ webpack installChunk call failed");
+                    }
+                  } else {
+                    if (IsScriptLoadingLogEnabled()) {
+                      NSLog(@"[dyn-import] ✓ webpack installChunk call succeeded");
+                    }
+                  }
+                } else {
+                  if (IsScriptLoadingLogEnabled()) {
+                    NSLog(@"[dyn-import] ✗ webpack installChunk function not found");
+                  }
+                }
+              } else {
+                if (IsScriptLoadingLogEnabled()) {
+                  NSLog(@"[dyn-import] ✗ runtime module default export not found");
+                }
+              }
+            }
+          } else {
+            if (IsScriptLoadingLogEnabled()) {
+              NSLog(@"[dyn-import] ✗ runtime module not found");
+            }
+          }
+        } catch (...) {
+          if (IsScriptLoadingLogEnabled()) {
+            NSLog(@"[dyn-import] ✗ exception while accessing runtime module");
+          }
+        }
+      }
+    }
+
+    resolver->Resolve(context, module->GetModuleNamespace()).Check();
+    if (IsScriptLoadingLogEnabled()) {
+      NSLog(@"[dyn-import] ✓ resolved %@", specStr);
+    }
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+    if (IsScriptLoadingLogEnabled()) {
+      NSLog(@"[dyn-import] ✗ native failed %@", specStr);
+    }
+    resolver
+        ->Reject(context, v8::Exception::Error(
+                              tns::ToV8String(isolate, "Native error during dynamic import")))
+        .Check();
+  }
+
+  return scope.Escape(resolver->GetPromise());
+}
+}
\ No newline at end of file
diff --git a/NativeScript/runtime/NativeScriptException.h b/NativeScript/runtime/NativeScriptException.h
index d8033d82..108ee7df 100644
--- a/NativeScript/runtime/NativeScriptException.h
+++ b/NativeScript/runtime/NativeScriptException.h
@@ -1,31 +1,45 @@
 #ifndef NativeScriptException_h
 #define NativeScriptException_h
 
-#include "Common.h"
 #include <string>
 
+#include "Common.h"
+
 namespace tns {
 
 class NativeScriptException {
-public:
-    NativeScriptException(const std::string& message);
-    NativeScriptException(v8::Isolate* isolate, v8::TryCatch& tc, const std::string& message);
-    NativeScriptException(v8::Isolate* isolate, const std::string& message, const std::string& name = "NativeScriptException");
-    ~NativeScriptException();
-    void ReThrowToV8(v8::Isolate* isolate);
-    static void OnUncaughtError(v8::Local<v8::Message> message, v8::Local<v8::Value> error);
-private:
-    v8::Persistent<v8::Value>* javascriptException_;
-    std::string name_;
-    std::string message_;
-    std::string stackTrace_;
-    std::string fullMessage_;
-    static std::string GetErrorStackTrace(v8::Isolate* isolate, const v8::Local<v8::StackTrace>& stackTrace);
-    static std::string GetErrorMessage(v8::Isolate* isolate, v8::Local<v8::Value>& error, const std::string& prependMessage = "");
-    static std::string GetFullMessage(v8::Isolate* isolate, const v8::TryCatch& tc, const std::string& jsExceptionMessage);
-    static std::string GetFullMessage(v8::Isolate* isolate, v8::Local<v8::Message> message, const std::string& jsExceptionMessage);
+ public:
+  NativeScriptException(const std::string& message);
+  NativeScriptException(v8::Isolate* isolate, v8::TryCatch& tc,
+                        const std::string& message);
+  NativeScriptException(v8::Isolate* isolate, const std::string& message,
+                        const std::string& name = "NativeScriptException");
+  ~NativeScriptException();
+  void ReThrowToV8(v8::Isolate* isolate);
+  const std::string& getMessage() const { return message_; }
+  const std::string& getStackTrace() const { return stackTrace_; }
+  static void OnUncaughtError(v8::Local<v8::Message> message,
+                              v8::Local<v8::Value> error);
+
+ private:
+  v8::Persistent<v8::Value>* javascriptException_;
+  std::string name_;
+  std::string message_;
+  std::string stackTrace_;
+  std::string fullMessage_;
+  static std::string GetErrorStackTrace(
+      v8::Isolate* isolate, const v8::Local<v8::StackTrace>& stackTrace);
+  static std::string GetErrorMessage(v8::Isolate* isolate,
+                                     v8::Local<v8::Value>& error,
+                                     const std::string& prependMessage = "");
+  static std::string GetFullMessage(v8::Isolate* isolate,
+                                    const v8::TryCatch& tc,
+                                    const std::string& jsExceptionMessage);
+  static std::string GetFullMessage(v8::Isolate* isolate,
+                                    v8::Local<v8::Message> message,
+                                    const std::string& jsExceptionMessage);
 };
 
-}
+}  // namespace tns
 
 #endif /* NativeScriptException_h */
diff --git a/NativeScript/runtime/NativeScriptException.mm b/NativeScript/runtime/NativeScriptException.mm
index 256a5295..f9fa9726 100644
--- a/NativeScript/runtime/NativeScriptException.mm
+++ b/NativeScript/runtime/NativeScriptException.mm
@@ -1,231 +1,263 @@
 #include "NativeScriptException.h"
-#include "Runtime.h"
-#include "Helpers.h"
-#include "Caches.h"
 #include <sstream>
+#include "Caches.h"
+#include "Helpers.h"
+#include "Runtime.h"
 
 using namespace v8;
 
 namespace tns {
 
 NativeScriptException::NativeScriptException(const std::string& message) {
-    this->javascriptException_ = nullptr;
-    this->message_ = message;
-    this->name_ = "NativeScriptException";
+  this->javascriptException_ = nullptr;
+  this->message_ = message;
+  this->name_ = "NativeScriptException";
 }
 
-NativeScriptException::NativeScriptException(Isolate* isolate, TryCatch& tc, const std::string& message) {
-    Local<Value> error = tc.Exception();
-    this->javascriptException_ = new Persistent<Value>(isolate, tc.Exception());
-    this->message_ = GetErrorMessage(isolate, error, message);
-    this->stackTrace_ = GetErrorStackTrace(isolate, tc.Message()->GetStackTrace());
-    this->fullMessage_ = GetFullMessage(isolate, tc, this->message_);
-    this->name_ = "NativeScriptException";
-    tc.Reset();
+NativeScriptException::NativeScriptException(Isolate* isolate, TryCatch& tc,
+                                             const std::string& message) {
+  Local<Value> error = tc.Exception();
+  this->javascriptException_ = new Persistent<Value>(isolate, tc.Exception());
+  this->message_ = GetErrorMessage(isolate, error, message);
+  this->stackTrace_ = GetErrorStackTrace(isolate, tc.Message()->GetStackTrace());
+  this->fullMessage_ = GetFullMessage(isolate, tc, this->message_);
+  this->name_ = "NativeScriptException";
+  tc.Reset();
 }
 
-NativeScriptException::NativeScriptException(Isolate* isolate, const std::string& message, const std::string& name) {
-    this->name_ = name;
-    Local<Value> error = Exception::Error(tns::ToV8String(isolate, message));
-    auto context = Caches::Get(isolate)->GetContext();
-    error.As<Object>()->Set(context, ToV8String(isolate, "name"), ToV8String(isolate, this->name_)).FromMaybe(false);
-    this->javascriptException_ = new Persistent<Value>(isolate, error);
-    this->message_ = GetErrorMessage(isolate, error, message);
-    this->stackTrace_ = GetErrorStackTrace(isolate, Exception::GetStackTrace(error));
-    this->fullMessage_ = GetFullMessage(isolate, Exception::CreateMessage(isolate, error), this->message_);
-}
-NativeScriptException::~NativeScriptException() {
-    delete this->javascriptException_;
+NativeScriptException::NativeScriptException(Isolate* isolate, const std::string& message,
+                                             const std::string& name) {
+  this->name_ = name;
+  Local<Value> error = Exception::Error(tns::ToV8String(isolate, message));
+  auto context = Caches::Get(isolate)->GetContext();
+  error.As<Object>()
+      ->Set(context, ToV8String(isolate, "name"), ToV8String(isolate, this->name_))
+      .FromMaybe(false);
+  this->javascriptException_ = new Persistent<Value>(isolate, error);
+  this->message_ = GetErrorMessage(isolate, error, message);
+  this->stackTrace_ = GetErrorStackTrace(isolate, Exception::GetStackTrace(error));
+  this->fullMessage_ =
+      GetFullMessage(isolate, Exception::CreateMessage(isolate, error), this->message_);
 }
+NativeScriptException::~NativeScriptException() { delete this->javascriptException_; }
 
 void NativeScriptException::OnUncaughtError(Local<v8::Message> message, Local<Value> error) {
-    Isolate* isolate = message->GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Object> global = context->Global();
-    Local<Value> handler;
-    id value = Runtime::GetAppConfigValue("discardUncaughtJsExceptions");
-    bool isDiscarded = value ? [value boolValue] : false;
-
-    std::string cbName = isDiscarded ? "__onDiscardedError" : "__onUncaughtError";
-    bool success = global->Get(context, tns::ToV8String(isolate, cbName)).ToLocal(&handler);
-
-    std::string stackTrace = GetErrorStackTrace(isolate, message->GetStackTrace());
-    std::string fullMessage;
-    
-    auto errObject = error.As<Object>();
-    auto fullMessageString = tns::ToV8String(isolate, "fullMessage");
-    if(errObject->HasOwnProperty(context, fullMessageString).ToChecked()) {
-        // check if we have a "fullMessage" on the error, and log that instead - since it includes more info about the exception.
-        auto fullMessage_ = errObject->Get(context, fullMessageString).ToLocalChecked();
-        fullMessage = tns::ToString(isolate, fullMessage_);
-    } else {
-        Local<v8::String> messageV8String = message->Get();
-        std::string messageString = tns::ToString(isolate, messageV8String);
-        fullMessage = messageString + "\n at \n" + stackTrace;
+  Isolate* isolate = message->GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Object> global = context->Global();
+  Local<Value> handler;
+  id value = Runtime::GetAppConfigValue("discardUncaughtJsExceptions");
+  bool isDiscarded = value ? [value boolValue] : false;
+
+  std::string cbName = isDiscarded ? "__onDiscardedError" : "__onUncaughtError";
+  bool success = global->Get(context, tns::ToV8String(isolate, cbName)).ToLocal(&handler);
+
+  std::string stackTrace = GetErrorStackTrace(isolate, message->GetStackTrace());
+  std::string fullMessage;
+
+  auto errObject = error.As<Object>();
+  auto fullMessageString = tns::ToV8String(isolate, "fullMessage");
+  if (errObject->HasOwnProperty(context, fullMessageString).ToChecked()) {
+    // check if we have a "fullMessage" on the error, and log that instead - since it includes more
+    // info about the exception.
+    auto fullMessage_ = errObject->Get(context, fullMessageString).ToLocalChecked();
+    fullMessage = tns::ToString(isolate, fullMessage_);
+  } else {
+    Local<v8::String> messageV8String = message->Get();
+    std::string messageString = tns::ToString(isolate, messageV8String);
+    fullMessage = messageString + "\n at \n" + stackTrace;
+  }
+
+  if (success && handler->IsFunction()) {
+    if (error->IsObject()) {
+      tns::Assert(error.As<Object>()
+                      ->Set(context, tns::ToV8String(isolate, "stackTrace"),
+                            tns::ToV8String(isolate, stackTrace))
+                      .FromMaybe(false),
+                  isolate);
     }
 
-    if (success && handler->IsFunction()) {
-        if (error->IsObject()) {
-            tns::Assert(error.As<Object>()->Set(context, tns::ToV8String(isolate, "stackTrace"), tns::ToV8String(isolate, stackTrace)).FromMaybe(false), isolate);
-        }
-
-        Local<v8::Function> errorHandlerFunc = handler.As<v8::Function>();
-        Local<Object> thiz = Object::New(isolate);
-        Local<Value> args[] = { error };
-        Local<Value> result;
-        TryCatch tc(isolate);
-        success = errorHandlerFunc->Call(context, thiz, 1, args).ToLocal(&result);
-        if (tc.HasCaught()) {
-            tns::LogError(isolate, tc);
-        }
-
-        tns::Assert(success, isolate);
+    Local<v8::Function> errorHandlerFunc = handler.As<v8::Function>();
+    Local<Object> thiz = Object::New(isolate);
+    Local<Value> args[] = {error};
+    Local<Value> result;
+    TryCatch tc(isolate);
+    success = errorHandlerFunc->Call(context, thiz, 1, args).ToLocal(&result);
+    if (tc.HasCaught()) {
+      tns::LogError(isolate, tc);
     }
 
-    if (!isDiscarded) {
-        NSString* name = [NSString stringWithFormat:@"NativeScript encountered a fatal error:\n\n%s", fullMessage.c_str()];
-        // we throw the exception on main thread
-        // otherwise it seems that when getting NSException info from NSSetUncaughtExceptionHandler
-        // we are missing almost all data. No explanation for why yet
-        dispatch_async(dispatch_get_main_queue(), ^(void) {
-          NSException* objcException = [NSException exceptionWithName:name reason:nil userInfo:@{ @"sender": @"onUncaughtError" }];
-
-          NSLog(@"***** Fatal JavaScript exception - application has been terminated. *****\n");
-          NSLog(@"%@", [objcException description]);
-          @throw objcException;
-        });
-    } else {
-        NSLog(@"NativeScript discarding uncaught JS exception!");
-    }
-}
+    tns::Assert(success, isolate);
+  }
 
-void NativeScriptException::ReThrowToV8(Isolate* isolate) {
-    // The Isolate::Scope here is necessary because the Exception::Error method internally relies on the
-    // Isolate::GetCurrent method which might return null if we do not use the proper scope
-    Isolate::Scope scope(isolate);
-
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Value> errObj;
-
-    if (this->javascriptException_ != nullptr) {
-        errObj = this->javascriptException_->Get(isolate);
-        if (errObj->IsObject()) {
-            if (!this->fullMessage_.empty()) {
-                tns::Assert(errObj.As<Object>()->Set(context, tns::ToV8String(isolate, "fullMessage"), tns::ToV8String(isolate, this->fullMessage_)).FromMaybe(false), isolate);
-            } else if (!this->message_.empty()) {
-                tns::Assert(errObj.As<Object>()->Set(context, tns::ToV8String(isolate, "fullMessage"), tns::ToV8String(isolate, this->message_)).FromMaybe(false), isolate);
-            }
-        }
-    } else if (!this->fullMessage_.empty()) {
-        errObj = Exception::Error(tns::ToV8String(isolate, this->fullMessage_));
-    } else if (!this->message_.empty()) {
-        errObj = Exception::Error(tns::ToV8String(isolate, this->message_));
-    } else {
-        errObj = Exception::Error(tns::ToV8String(isolate, "No javascript exception or message provided."));
+  if (!isDiscarded) {
+    NSString* reasonStr = [NSString stringWithUTF8String:fullMessage.c_str()];
+    if (reasonStr == nil) {
+      reasonStr = @"(invalid UTF-8 message from JS)";
     }
 
-    isolate->ThrowException(errObj);
+    NSString* name = @"NativeScriptUncaughtJSException";
+
+    // we throw the exception on main thread so all meta-data is captured
+    dispatch_async(dispatch_get_main_queue(), ^(void) {
+      NSException* objcException =
+          [NSException exceptionWithName:name
+                                  reason:reasonStr
+                                userInfo:@{@"sender" : @"onUncaughtError"}];
+
+      NSLog(@"***** Fatal JavaScript exception - application has been terminated. *****\n");
+      NSLog(@"%@", objcException);
+      @throw objcException;
+    });
+  } else {
+    NSLog(@"NativeScript discarding uncaught JS exception!");
+  }
 }
 
-std::string NativeScriptException::GetErrorMessage(Isolate* isolate, Local<Value>& error, const std::string& prependMessage) {
-    std::shared_ptr<Caches> cache = Caches::Get(isolate);
-    Local<Context> context = cache->GetContext();
-
-    // get whole error message from previous stack
-    std::stringstream ss;
-
-    if (prependMessage != "") {
-        ss << prependMessage << std::endl;
+void NativeScriptException::ReThrowToV8(Isolate* isolate) {
+  // The Isolate::Scope here is necessary because the Exception::Error method internally relies on
+  // the Isolate::GetCurrent method which might return null if we do not use the proper scope
+  Isolate::Scope scope(isolate);
+
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Value> errObj;
+
+  if (this->javascriptException_ != nullptr) {
+    errObj = this->javascriptException_->Get(isolate);
+    if (errObj->IsObject()) {
+      if (!this->fullMessage_.empty()) {
+        tns::Assert(errObj.As<Object>()
+                        ->Set(context, tns::ToV8String(isolate, "fullMessage"),
+                              tns::ToV8String(isolate, this->fullMessage_))
+                        .FromMaybe(false),
+                    isolate);
+      } else if (!this->message_.empty()) {
+        tns::Assert(errObj.As<Object>()
+                        ->Set(context, tns::ToV8String(isolate, "fullMessage"),
+                              tns::ToV8String(isolate, this->message_))
+                        .FromMaybe(false),
+                    isolate);
+      }
     }
+  } else if (!this->fullMessage_.empty()) {
+    errObj = Exception::Error(tns::ToV8String(isolate, this->fullMessage_));
+  } else if (!this->message_.empty()) {
+    errObj = Exception::Error(tns::ToV8String(isolate, this->message_));
+  } else {
+    errObj =
+        Exception::Error(tns::ToV8String(isolate, "No javascript exception or message provided."));
+  }
+
+  isolate->ThrowException(errObj);
+}
 
-    std::string errMessage;
-    bool hasFullErrorMessage = false;
-    auto v8FullMessage = tns::ToV8String(isolate, "fullMessage");
-    if (error->IsObject() && error.As<Object>()->Has(context, v8FullMessage).ToChecked()) {
-        hasFullErrorMessage = true;
-        Local<Value> errMsgVal;
-        bool success = error.As<Object>()->Get(context, v8FullMessage).ToLocal(&errMsgVal);
-        tns::Assert(success, isolate);
-        if (!errMsgVal.IsEmpty()) {
-            errMessage = tns::ToString(isolate, errMsgVal.As<v8::String>());
-        } else {
-            errMessage = "";
-        }
-        ss << errMessage;
+std::string NativeScriptException::GetErrorMessage(Isolate* isolate, Local<Value>& error,
+                                                   const std::string& prependMessage) {
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  Local<Context> context = cache->GetContext();
+
+  // get whole error message from previous stack
+  std::stringstream ss;
+
+  if (prependMessage != "") {
+    ss << prependMessage << std::endl;
+  }
+
+  std::string errMessage;
+  bool hasFullErrorMessage = false;
+  auto v8FullMessage = tns::ToV8String(isolate, "fullMessage");
+  if (error->IsObject() && error.As<Object>()->Has(context, v8FullMessage).ToChecked()) {
+    hasFullErrorMessage = true;
+    Local<Value> errMsgVal;
+    bool success = error.As<Object>()->Get(context, v8FullMessage).ToLocal(&errMsgVal);
+    tns::Assert(success, isolate);
+    if (!errMsgVal.IsEmpty()) {
+      errMessage = tns::ToString(isolate, errMsgVal.As<v8::String>());
+    } else {
+      errMessage = "";
     }
-
-    MaybeLocal<v8::String> str = error->ToDetailString(context);
-    if (!str.IsEmpty()) {
-        v8::String::Utf8Value utfError(isolate, str.FromMaybe(Local<v8::String>()));
-        if (hasFullErrorMessage) {
-            ss << std::endl;
-        }
-        ss << *utfError;
+    ss << errMessage;
+  }
+
+  MaybeLocal<v8::String> str = error->ToDetailString(context);
+  if (!str.IsEmpty()) {
+    v8::String::Utf8Value utfError(isolate, str.FromMaybe(Local<v8::String>()));
+    if (hasFullErrorMessage) {
+      ss << std::endl;
     }
+    ss << *utfError;
+  }
 
-    return ss.str();
+  return ss.str();
 }
 
-std::string NativeScriptException::GetErrorStackTrace(Isolate* isolate, const Local<StackTrace>& stackTrace) {
-    if (stackTrace.IsEmpty()) {
-        return "";
-    }
+std::string NativeScriptException::GetErrorStackTrace(Isolate* isolate,
+                                                      const Local<StackTrace>& stackTrace) {
+  if (stackTrace.IsEmpty()) {
+    return "";
+  }
 
-    std::stringstream ss;
+  std::stringstream ss;
 
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
+  Isolate::Scope isolate_scope(isolate);
+  HandleScope handle_scope(isolate);
 
-    int frameCount = stackTrace->GetFrameCount();
+  int frameCount = stackTrace->GetFrameCount();
 
-    for (int i = 0; i < frameCount; i++) {
-        Local<StackFrame> frame = stackTrace->GetFrame(isolate, i);
-        std::string funcName = tns::ToString(isolate, frame->GetFunctionName());
-        std::string srcName = tns::ToString(isolate, frame->GetScriptName());
-        int lineNumber = frame->GetLineNumber();
-        int column = frame->GetColumn();
+  for (int i = 0; i < frameCount; i++) {
+    Local<StackFrame> frame = stackTrace->GetFrame(isolate, i);
+    std::string funcName = tns::ToString(isolate, frame->GetFunctionName());
+    std::string srcName = tns::ToString(isolate, frame->GetScriptName());
+    int lineNumber = frame->GetLineNumber();
+    int column = frame->GetColumn();
 
-        ss << "\t" << (i > 0 ? "at " : "") << funcName.c_str() << "(" << srcName.c_str() << ":" << lineNumber << ":" << column << ")" << std::endl;
-    }
+    ss << "\t" << (i > 0 ? "at " : "") << funcName.c_str() << "(" << srcName.c_str() << ":"
+       << lineNumber << ":" << column << ")" << std::endl;
+  }
 
-    return ss.str();
+  return ss.str();
 }
-std::string NativeScriptException::GetFullMessage(Isolate* isolate, const TryCatch& tc, const std::string& jsExceptionMessage) {
-    std::string loggedMessage = GetFullMessage(isolate, tc.Message(), jsExceptionMessage);
-    if (!tc.CanContinue()) {
-        std::stringstream errM;
-        errM << std::endl << "An uncaught error has occurred and V8's TryCatch block CAN'T be continued. ";
-        loggedMessage = errM.str() + loggedMessage;
-    }
-    return loggedMessage;
+std::string NativeScriptException::GetFullMessage(Isolate* isolate, const TryCatch& tc,
+                                                  const std::string& jsExceptionMessage) {
+  std::string loggedMessage = GetFullMessage(isolate, tc.Message(), jsExceptionMessage);
+  if (!tc.CanContinue()) {
+    std::stringstream errM;
+    errM << std::endl
+         << "An uncaught error has occurred and V8's TryCatch block CAN'T be continued. ";
+    loggedMessage = errM.str() + loggedMessage;
+  }
+  return loggedMessage;
 }
 
-std::string NativeScriptException::GetFullMessage(Isolate* isolate, Local<v8::Message> message, const std::string& jsExceptionMessage) {
-    Local<Context> context = isolate->GetEnteredOrMicrotaskContext();
+std::string NativeScriptException::GetFullMessage(Isolate* isolate, Local<v8::Message> message,
+                                                  const std::string& jsExceptionMessage) {
+  Local<Context> context = isolate->GetEnteredOrMicrotaskContext();
 
-    std::stringstream ss;
-    ss << jsExceptionMessage;
+  std::stringstream ss;
+  ss << jsExceptionMessage;
 
-    //get script name
-    Local<Value> scriptResName = message->GetScriptResourceName();
+  // get script name
+  Local<Value> scriptResName = message->GetScriptResourceName();
 
-    //get stack trace
-    std::string stackTraceMessage = GetErrorStackTrace(isolate, message->GetStackTrace());
+  // get stack trace
+  std::string stackTraceMessage = GetErrorStackTrace(isolate, message->GetStackTrace());
 
-    if (!scriptResName.IsEmpty() && scriptResName->IsString()) {
-        ss << std::endl <<"File: (" << tns::ToString(isolate, scriptResName.As<v8::String>());
-    } else {
-        ss << std::endl <<"File: (<unknown>";
-    }
-    ss << ":" << message->GetLineNumber(context).ToChecked() << ":" << message->GetStartColumn() << ")" << std::endl << std::endl;
-    ss << "StackTrace: " << std::endl << stackTraceMessage << std::endl;
+  if (!scriptResName.IsEmpty() && scriptResName->IsString()) {
+    ss << std::endl << "File: (" << tns::ToString(isolate, scriptResName.As<v8::String>());
+  } else {
+    ss << std::endl << "File: (<unknown>";
+  }
+  ss << ":" << message->GetLineNumber(context).ToChecked() << ":" << message->GetStartColumn()
+     << ")" << std::endl
+     << std::endl;
+  ss << "StackTrace: " << std::endl << stackTraceMessage << std::endl;
 
-    std::string loggedMessage = ss.str();
+  std::string loggedMessage = ss.str();
 
-    // TODO: Log the error
-    // tns::LogError(isolate, tc);
+  // TODO: Log the error
+  // tns::LogError(isolate, tc);
 
-    return loggedMessage;
+  return loggedMessage;
 }
 
 }
diff --git a/NativeScript/runtime/Runtime.mm b/NativeScript/runtime/Runtime.mm
index c943b0b2..046800c6 100644
--- a/NativeScript/runtime/Runtime.mm
+++ b/NativeScript/runtime/Runtime.mm
@@ -22,10 +22,12 @@
 #include "DisposerPHV.h"
 #include "IsolateWrapper.h"
 
+#include <unordered_map>
 #include "ModuleBinding.hpp"
+#include "ModuleInternalCallbacks.h"
 #include "URLImpl.h"
-#include "URLSearchParamsImpl.h"
 #include "URLPatternImpl.h"
+#include "URLSearchParamsImpl.h"
 
 #define STRINGIZE(x) #x
 #define STRINGIZE_VALUE_OF(x) STRINGIZE(x)
@@ -33,6 +35,82 @@
 using namespace v8;
 using namespace std;
 
+// Import meta callback to support import.meta.url
+static void InitializeImportMetaObject(Local<Context> context, Local<Module> module,
+                                       Local<Object> meta) {
+  Isolate* isolate = context->GetIsolate();
+
+  // Look up the module path in the global module registry (with safety checks)
+  std::string modulePath;
+
+  try {
+    for (auto& kv : tns::g_moduleRegistry) {
+      // Check if Global handle is empty before accessing
+      if (kv.second.IsEmpty()) {
+        continue;
+      }
+
+      Local<Module> registered = kv.second.Get(isolate);
+      if (!registered.IsEmpty() && registered == module) {
+        modulePath = kv.first;
+        break;
+      }
+    }
+  } catch (...) {
+    NSLog(@"[import.meta] Exception during module registry lookup, using fallback");
+    modulePath = "";  // Will use fallback path
+  }
+
+  // Debug logging
+  NSLog(@"[import.meta] Module lookup: found path = %s",
+        modulePath.empty() ? "(empty)" : modulePath.c_str());
+  NSLog(@"[import.meta] Registry size: %zu", tns::g_moduleRegistry.size());
+
+  // Convert file path to file:// URL
+  std::string moduleUrl;
+  if (!modulePath.empty()) {
+    // Remove base directory and create file:// URL
+    std::string base = tns::ReplaceAll(modulePath, RuntimeConfig.BaseDir, "");
+    moduleUrl = "file://" + base;
+  } else {
+    // Fallback URL if module not found in registry
+    moduleUrl = "file:///app/";
+  }
+
+  NSLog(@"[import.meta] Final URL: %s", moduleUrl.c_str());
+
+  Local<String> url =
+      String::NewFromUtf8(isolate, moduleUrl.c_str(), NewStringType::kNormal).ToLocalChecked();
+
+  // Set import.meta.url property
+  meta->CreateDataProperty(
+          context, String::NewFromUtf8(isolate, "url", NewStringType::kNormal).ToLocalChecked(),
+          url)
+      .Check();
+
+  // Add import.meta.dirname support (extract directory from path)
+  std::string dirname;
+  if (!modulePath.empty()) {
+    size_t lastSlash = modulePath.find_last_of("/\\");
+    if (lastSlash != std::string::npos) {
+      dirname = modulePath.substr(0, lastSlash);
+    } else {
+      dirname = "/app";  // fallback
+    }
+  } else {
+    dirname = "/app";  // fallback
+  }
+
+  Local<String> dirnameStr =
+      String::NewFromUtf8(isolate, dirname.c_str(), NewStringType::kNormal).ToLocalChecked();
+
+  // Set import.meta.dirname property
+  meta->CreateDataProperty(
+          context, String::NewFromUtf8(isolate, "dirname", NewStringType::kNormal).ToLocalChecked(),
+          dirnameStr)
+      .Check();
+}
+
 namespace tns {
 
 std::atomic<int> Runtime::nextIsolateId{0};
@@ -113,6 +191,15 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
 
   {
     v8::Locker lock(isolate_);
+
+    // Clear module registry before disposing other handles
+    // This prevents crashes during g_moduleRegistry cleanup
+    extern std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
+    for (auto& kv : g_moduleRegistry) {
+      kv.second.Reset();
+    }
+    g_moduleRegistry.clear();
+
     DisposerPHV phv(isolate_);
     isolate_->VisitHandlesWithClassIds(&phv);
 
@@ -198,6 +285,16 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
   MetadataBuilder::RegisterConstantsOnGlobalObject(isolate, globalTemplate, isWorker);
 
   isolate->SetCaptureStackTraceForUncaughtExceptions(true, 100, StackTrace::kOverview);
+
+  // Enable dynamic import() support (handle API rename across V8 versions)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  isolate->SetHostImportModuleDynamicallyCallback(tns::ImportModuleDynamicallyCallback);
+#pragma clang diagnostic pop
+
+  // Set up import.meta callback
+  isolate->SetHostInitializeImportMetaObjectCallback(InitializeImportMetaObject);
+
   isolate->AddMessageListener(NativeScriptException::OnUncaughtError);
 
   Local<Context> context = Context::New(isolate, nullptr, globalTemplate);
@@ -364,6 +461,12 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
                        .FromMaybe(false)) {
     tns::Assert(false, isolate);
   }
+
+  if (isWorker) {
+    // Register proper interop types for worker context
+    // Worker bundles need full interop functionality, not just simple stubs
+    tns::Interop::RegisterInteropTypes(context);
+  }
 }
 
 void Runtime::DefineCollectFunction(Local<Context> context) {
diff --git a/NativeScript/runtime/Timers.cpp b/NativeScript/runtime/Timers.cpp
index 9afe55d5..90599266 100644
--- a/NativeScript/runtime/Timers.cpp
+++ b/NativeScript/runtime/Timers.cpp
@@ -7,275 +7,288 @@
 //
 
 #include "Timers.hpp"
+
 #include <CoreFoundation/CoreFoundation.h>
+
+#include <vector>
+
+#include "Caches.h"
 #include "Helpers.h"
 #include "ModuleBinding.hpp"
-#include "Caches.h"
 #include "Runtime.h"
 
 using namespace v8;
 
-
-
 // Takes a value and transform into a positive number
 // returns a negative number if the number is negative or invalid
-inline static double
-ToMaybePositiveValue(const v8::Local<v8::Value> &v, const v8::Local<v8::Context> &ctx) {
-    double value = -1;
-    if (v->IsNullOrUndefined()) {
-        return -1;
+inline static double ToMaybePositiveValue(const v8::Local<v8::Value>& v,
+                                          const v8::Local<v8::Context>& ctx) {
+  double value = -1;
+  if (v->IsNullOrUndefined()) {
+    return -1;
+  }
+  Local<Number> numberValue;
+  auto success = v->ToNumber(ctx).ToLocal(&numberValue);
+  if (success) {
+    value = numberValue->Value();
+    if (isnan(value)) {
+      value = -1;
     }
-    Local<Number> numberValue;
-    auto success = v->ToNumber(ctx).ToLocal(&numberValue);
-    if (success) {
-        value = numberValue->Value();
-        if (isnan(value)) {
-            value = -1;
-        }
-    }
-    return value;
+  }
+  return value;
 }
 
 static double now_ms() {
-    struct timespec res;
-    clock_gettime(CLOCK_MONOTONIC, &res);
-    return 1000.0 * res.tv_sec + (double) res.tv_nsec / 1e6;
+  struct timespec res;
+  clock_gettime(CLOCK_MONOTONIC, &res);
+  return 1000.0 * res.tv_sec + (double)res.tv_nsec / 1e6;
 }
 
 namespace tns {
 
 class TimerState {
-public:
-    std::mutex timerMutex_;
-    std::atomic<int> currentTimerId = 0;
-    robin_hood::unordered_map<int, std::shared_ptr<TimerTask>> timerMap_;
-    CFRunLoopRef runloop;
-    
-    void removeTask(const std::shared_ptr<TimerTask> &task) {
-        removeTask(task->id_);
-    }
-    
-    void removeTask(const int &taskId) {
-        auto it = timerMap_.find(taskId);
-        if (it != timerMap_.end()) {
-            //auto wasScheduled = it->second->queued_;
-            auto timer = it->second->timer;
-            it->second->Unschedule();
-            timerMap_.erase(it);
-            CFRunLoopTimerInvalidate(timer);
-            // timer and context will be released by the retain function
-            //CFRunLoopTimerContext context;
-            //CFRunLoopTimerGetContext(timer, &context);
-            //delete static_cast<std::shared_ptr<TimerTask>*>(context.info);
-            // CFRelease(timer);
-        }
+ public:
+  std::mutex timerMutex_;
+  std::atomic<int> currentTimerId = 0;
+  robin_hood::unordered_map<int, std::shared_ptr<TimerTask>> timerMap_;
+  CFRunLoopRef runloop;
+
+  void removeTask(const std::shared_ptr<TimerTask>& task) {
+    removeTask(task->id_);
+  }
+
+  void removeTask(const int& taskId) {
+    auto it = timerMap_.find(taskId);
+    if (it != timerMap_.end()) {
+      // auto wasScheduled = it->second->queued_;
+      auto timer = it->second->timer;
+      it->second->Unschedule();
+      timerMap_.erase(it);
+      CFRunLoopTimerInvalidate(timer);
+      // timer and context will be released by the retain function
+      // CFRunLoopTimerContext context;
+      // CFRunLoopTimerGetContext(timer, &context);
+      // delete static_cast<std::shared_ptr<TimerTask>*>(context.info);
+      // CFRelease(timer);
     }
-    
-    // this all comes from the android runtime implementation
-    void addTask(std::shared_ptr<TimerTask> task) {
-        if (task->queued_) {
-            return;
-        }
-        //        auto now = now_ms();
-        // task->nestingLevel_ = nesting + 1;
-        task->queued_ = true;
-        // theoretically this should be >5 on the spec, but we're following chromium behavior here again
-        //        if (task->nestingLevel_ >= 5 && task->frequency_ < 4) {
-        //            task->frequency_ = 4;
-        //            task->startTime_ = now;
-        //        }
-        timerMap_.emplace(task->id_, task);
-        // not needed on the iOS runtime for now
-        //        auto newTime = task->NextTime(now);
-        //        task->dueTime_ = newTime;
+  }
+
+  // this all comes from the android runtime implementation
+  void addTask(std::shared_ptr<TimerTask> task) {
+    if (task->queued_) {
+      return;
     }
-    
+    //        auto now = now_ms();
+    // task->nestingLevel_ = nesting + 1;
+    task->queued_ = true;
+    // theoretically this should be >5 on the spec, but we're following chromium
+    // behavior here again
+    //        if (task->nestingLevel_ >= 5 && task->frequency_ < 4) {
+    //            task->frequency_ = 4;
+    //            task->startTime_ = now;
+    //        }
+    timerMap_.emplace(task->id_, task);
+    // not needed on the iOS runtime for now
+    //        auto newTime = task->NextTime(now);
+    //        task->dueTime_ = newTime;
+  }
 };
 
 // this class is attached to the timer object itself
 // we use a retain/release flow because we want to bind this to the Timer itself
 // additionally it helps if we deal with timers on different threads
-// The current implementation puts the timers on the runtime's runloop, so it shouldn't be necessary.
+// The current implementation puts the timers on the runtime's runloop, so it
+// shouldn't be necessary.
 class TimerContext {
-public:
-    std::atomic<int> retainCount{0};
-    std::shared_ptr<TimerTask> task;
-    TimerState* state;
-    ~TimerContext() {
-        task->Unschedule();
-        CFRelease(task->timer);
-    }
-    
-    static const void* TimerRetain(const void* ret) {
-        auto v = (TimerContext*)(ret);
-        v->retainCount++;
-        return ret;
-    }
-    
-    static void TimerRelease(const void* ret) {
-        auto v = (TimerContext*)(ret);
-        if(--v->retainCount <= 0) {
-            delete v;
-        };
-    }
-};
-
-
+ public:
+  std::atomic<int> retainCount{0};
+  std::shared_ptr<TimerTask> task;
+  TimerState* state;
+  ~TimerContext() {
+    task->Unschedule();
+    CFRelease(task->timer);
+  }
 
+  static const void* TimerRetain(const void* ret) {
+    auto v = (TimerContext*)(ret);
+    v->retainCount++;
+    return ret;
+  }
 
+  static void TimerRelease(const void* ret) {
+    auto v = (TimerContext*)(ret);
+    if (--v->retainCount <= 0) {
+      delete v;
+    };
+  }
+};
 
 void Timers::Init(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {
-    auto timerState = new TimerState();
-    timerState->runloop = Runtime::GetRuntime(isolate)->RuntimeLoop();
-    Caches::Get(isolate)->registerCacheBoundObject(timerState);
-    tns::NewFunctionTemplate(isolate, Timers::SetTimeoutCallback, v8::External::New(isolate, timerState));
-    tns::SetMethod(isolate, globalTemplate, "__ns__setTimeout", Timers::SetTimeoutCallback, v8::External::New(isolate, timerState));
-    tns::SetMethod(isolate, globalTemplate, "__ns__setInterval", Timers::SetIntervalCallback, v8::External::New(isolate, timerState));
-    tns::SetMethod(isolate, globalTemplate, "__ns__clearTimeout", Timers::ClearTimeoutCallback, v8::External::New(isolate, timerState));
-    tns::SetMethod(isolate, globalTemplate, "__ns__clearInterval", Timers::ClearTimeoutCallback, v8::External::New(isolate, timerState));
-    Caches::Get(isolate)->registerCacheBoundObject(new TimerState());
-    
+  auto timerState = new TimerState();
+  timerState->runloop = Runtime::GetRuntime(isolate)->RuntimeLoop();
+  Caches::Get(isolate)->registerCacheBoundObject(timerState);
+  tns::NewFunctionTemplate(isolate, Timers::SetTimeoutCallback,
+                           v8::External::New(isolate, timerState));
+  tns::SetMethod(isolate, globalTemplate, "__ns__setTimeout",
+                 Timers::SetTimeoutCallback,
+                 v8::External::New(isolate, timerState));
+  tns::SetMethod(isolate, globalTemplate, "__ns__setInterval",
+                 Timers::SetIntervalCallback,
+                 v8::External::New(isolate, timerState));
+  tns::SetMethod(isolate, globalTemplate, "__ns__clearTimeout",
+                 Timers::ClearTimeoutCallback,
+                 v8::External::New(isolate, timerState));
+  tns::SetMethod(isolate, globalTemplate, "__ns__clearInterval",
+                 Timers::ClearTimeoutCallback,
+                 v8::External::New(isolate, timerState));
+  Caches::Get(isolate)->registerCacheBoundObject(new TimerState());
 }
 
+void TimerCallback(CFRunLoopTimerRef timer, void* info) {
+  TimerContext* data = (TimerContext*)info;
+  auto task = data->task;
+  // we check for this first so we can be 100% sure that this task is still
+  // alive since we're always dealing with the runtime's runloop, it should
+  // always work if we even support firing the timers in a another runloop, then
+  // this is useful as it'll avoid use-after-free issues
+  if (!task->queued_ || !task->wrapper.IsValid()) {
+    return;
+  }
+  auto isolate = task->isolate_;
 
+  v8::Locker locker(isolate);
+  v8::Isolate::Scope isolate_scope(isolate);
+  v8::HandleScope handleScope(isolate);
+  // ensure we're still queued after locking
+  if (!task->queued_) {
+    return;
+  }
 
-void TimerCallback(CFRunLoopTimerRef timer, void *info) {
-    TimerContext* data = (TimerContext*)info;
-    auto task = data->task;
-    // we check for this first so we can be 100% sure that this task is still alive
-    // since we're always dealing with the runtime's runloop, it should always work
-    // if we even support firing the timers in a another runloop, then this is useful as it'll avoid use-after-free issues
-    if (!task->queued_ || !task->wrapper.IsValid()) {
-        return;
-    }
-    auto isolate = task->isolate_;
-    
-    v8::Locker locker(isolate);
-    v8::Isolate::Scope isolate_scope(isolate);
-    v8::HandleScope handleScope(isolate);
-    // ensure we're still queued after locking
-    if(!task->queued_) {
-        return;
-    }
-    
-    v8::Local<v8::Function> cb = task->callback_.Get(isolate);
-    v8::Local<v8::Context> context = cb->GetCreationContextChecked();
-    Context::Scope context_scope(context);
-    auto argc = task->args_.get() == nullptr ? 0 : task->args_->size();
-    if (argc > 0) {
-        Local<Value> argv[argc];
-        for (int i = 0; i < argc; i++) {
-            argv[i] = task->args_->at(i)->Get(isolate);
-        }
-        (void)cb->Call(context, context->Global(), (int)argc, argv);
-    } else {
-        (void)cb->Call(context, context->Global(), 0, nullptr);
-    }
-    
-    if (!task->repeats_) {
-        data->state->removeTask(task);
+  v8::Local<v8::Function> cb = task->callback_.Get(isolate);
+  v8::Local<v8::Context> context = cb->GetCreationContextChecked();
+  Context::Scope context_scope(context);
+  int argc = task->args_ ? static_cast<int>(task->args_->size()) : 0;
+  if (argc > 0) {
+    // allocate an array of the right size
+    std::vector<Local<Value>> argv(argc);
+
+    for (int i = 0; i < argc; ++i) {
+      argv[i] = task->args_->at(i)->Get(isolate);
     }
-    
+
+    // pass pointer to the first element
+    (void)cb->Call(context, context->Global(), argc, argv.data());
+  } else {
+    (void)cb->Call(context, context->Global(), 0, nullptr);
+  }
+
+  if (!task->repeats_) {
+    data->state->removeTask(task);
+  }
 }
 
-void Timers::SetTimer(const v8::FunctionCallbackInfo<v8::Value>& args, bool repeatable) {
-    auto argLength = args.Length();
-    auto extData = args.Data().As<External>();
-    TimerState* state = reinterpret_cast<TimerState*>(extData->Value());
-    int id = ++state->currentTimerId;
-    if (argLength >= 1) {
-        if (!args[0]->IsFunction()) {
-            args.GetReturnValue().Set(-1);
-            return;
-        }
-        auto handler = args[0].As<v8::Function>();
-        auto isolate = args.GetIsolate();
-        auto ctx = isolate->GetCurrentContext();
-        long timeout = 0;
-        if (argLength >= 2) {
-            timeout = (long) ToMaybePositiveValue(args[1], ctx);
-            if (timeout < 0) {
-                timeout = 0;
-            }
-        }
-        std::shared_ptr<std::vector<std::shared_ptr<Persistent<Value>>>> argArray;
-        if (argLength >= 3) {
-            auto otherArgLength = argLength - 2;
-            argArray = std::make_shared<std::vector<std::shared_ptr<Persistent<Value>>>>(
-                                                                                         otherArgLength);
-            for (int i = 0; i < otherArgLength; i++) {
-                (*argArray)[i] = std::make_shared<Persistent<Value>>(isolate, args[i + 2]);
+void Timers::SetTimer(const v8::FunctionCallbackInfo<v8::Value>& args,
+                      bool repeatable) {
+  auto argLength = args.Length();
+  auto extData = args.Data().As<External>();
+  TimerState* state = reinterpret_cast<TimerState*>(extData->Value());
+  int id = ++state->currentTimerId;
+  if (argLength >= 1) {
+    if (!args[0]->IsFunction()) {
+      args.GetReturnValue().Set(-1);
+      return;
+    }
+    auto handler = args[0].As<v8::Function>();
+    auto isolate = args.GetIsolate();
+    auto ctx = isolate->GetCurrentContext();
+    long timeout = 0;
+    if (argLength >= 2) {
+      timeout = (long)ToMaybePositiveValue(args[1], ctx);
+      if (timeout < 0) {
+        timeout = 0;
+      }
+    }
+    std::shared_ptr<std::vector<std::shared_ptr<Persistent<Value>>>> argArray;
+    if (argLength >= 3) {
+      auto otherArgLength = argLength - 2;
+      argArray =
+          std::make_shared<std::vector<std::shared_ptr<Persistent<Value>>>>(
+              otherArgLength);
+      for (int i = 0; i < otherArgLength; i++) {
+        (*argArray)[i] =
+            std::make_shared<Persistent<Value>>(isolate, args[i + 2]);
 #ifdef DEBUG
-                (*argArray)[i]->AnnotateStrongRetainer("timer_argument");
+        (*argArray)[i]->AnnotateStrongRetainer("timer_argument");
 #endif
-            }
-        }
-        
-        auto task = std::make_shared<TimerTask>(isolate, handler, timeout, repeatable, argArray, id, now_ms());
+      }
+    }
+
+    auto task = std::make_shared<TimerTask>(isolate, handler, timeout,
+                                            repeatable, argArray, id, now_ms());
 #ifdef DEBUG
-        task->callback_.AnnotateStrongRetainer("timer");
+    task->callback_.AnnotateStrongRetainer("timer");
 #endif
-        task->repeats_ = repeatable;
-        
-        CFRunLoopTimerContext timerContext = {0, NULL, NULL, NULL, NULL};
-        auto timerData = new TimerContext();
-        timerData->task = task;
-        timerData->state = state;
-        timerContext.info = timerData;
-        timerContext.retain = TimerContext::TimerRetain;
-        timerContext.release = TimerContext::TimerRelease;
-        
-        // we do this because the timer should take hold of exactly 1 retaincount after scheduling
-        // so if by our manual release the retain is 0 then we need to cleanup the TimerContext
-        TimerContext::TimerRetain(timerData);
-        
-        // timeout should be bigger than 0 if it's repeatable and 0
-        auto timeoutInSeconds = repeatable && timeout == 0 ? 0.0000001f : timeout / 1000.f;
-        auto timer = CFRunLoopTimerCreate(kCFAllocatorDefault,
-                                          CFAbsoluteTimeGetCurrent() + timeoutInSeconds,
-                                          repeatable ? timeoutInSeconds : 0,
-                                          0, 0,
-                                          TimerCallback,
-                                          &timerContext);
-        state->addTask(task);
-        // set the actual timer we created
-        task->timer = timer;
-        CFRunLoopAddTimer(state->runloop, timer, kCFRunLoopCommonModes);
-        TimerContext::TimerRelease(timerData);
-        //        auto task = std::make_shared<TimerTask>(isolate, handler, timeout, repeatable,
-        //                                                argArray, id, now_ms());
-        // thiz->addTask(task);
-    }
-    args.GetReturnValue().Set(id);
-}
+    task->repeats_ = repeatable;
 
-void Timers::SetTimeoutCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    Timers::SetTimer(args, false);
-    
+    CFRunLoopTimerContext timerContext = {0, NULL, NULL, NULL, NULL};
+    auto timerData = new TimerContext();
+    timerData->task = task;
+    timerData->state = state;
+    timerContext.info = timerData;
+    timerContext.retain = TimerContext::TimerRetain;
+    timerContext.release = TimerContext::TimerRelease;
+
+    // we do this because the timer should take hold of exactly 1 retaincount
+    // after scheduling so if by our manual release the retain is 0 then we need
+    // to cleanup the TimerContext
+    TimerContext::TimerRetain(timerData);
+
+    // timeout should be bigger than 0 if it's repeatable and 0
+    auto timeoutInSeconds =
+        repeatable && timeout == 0 ? 0.0000001f : timeout / 1000.f;
+    auto timer = CFRunLoopTimerCreate(
+        kCFAllocatorDefault, CFAbsoluteTimeGetCurrent() + timeoutInSeconds,
+        repeatable ? timeoutInSeconds : 0, 0, 0, TimerCallback, &timerContext);
+    state->addTask(task);
+    // set the actual timer we created
+    task->timer = timer;
+    CFRunLoopAddTimer(state->runloop, timer, kCFRunLoopCommonModes);
+    TimerContext::TimerRelease(timerData);
+    //        auto task = std::make_shared<TimerTask>(isolate, handler, timeout,
+    //        repeatable,
+    //                                                argArray, id, now_ms());
+    // thiz->addTask(task);
+  }
+  args.GetReturnValue().Set(id);
 }
 
-void Timers::SetIntervalCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    Timers::SetTimer(args, true);
-    
+void Timers::SetTimeoutCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Timers::SetTimer(args, false);
 }
 
-void Timers::ClearTimeoutCallback(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto argLength = args.Length();
-    auto extData = args.Data().As<External>();
-    auto thiz = reinterpret_cast<TimerState *>(extData->Value());
-    int id = -1;
-    if (argLength > 0) {
-        auto isolate = args.GetIsolate();
-        auto ctx = isolate->GetCurrentContext();
-        id = (int) ToMaybePositiveValue(args[0], ctx);
-    }
-    // ids start at 1
-    if (id > 0) {
-        thiz->removeTask(id);
-    }
+void Timers::SetIntervalCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Timers::SetTimer(args, true);
 }
 
+void Timers::ClearTimeoutCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  auto argLength = args.Length();
+  auto extData = args.Data().As<External>();
+  auto thiz = reinterpret_cast<TimerState*>(extData->Value());
+  int id = -1;
+  if (argLength > 0) {
+    auto isolate = args.GetIsolate();
+    auto ctx = isolate->GetCurrentContext();
+    id = (int)ToMaybePositiveValue(args[0], ctx);
+  }
+  // ids start at 1
+  if (id > 0) {
+    thiz->removeTask(id);
+  }
 }
 
+}  // namespace tns
 
 NODE_BINDING_PER_ISOLATE_INIT_OBJ(timers, tns::Timers::Init)
diff --git a/NativeScript/runtime/Worker.mm b/NativeScript/runtime/Worker.mm
index d3ec8841..b315b4fd 100644
--- a/NativeScript/runtime/Worker.mm
+++ b/NativeScript/runtime/Worker.mm
@@ -1,323 +1,382 @@
-#include <functional>
-#include "ObjectManager.h"
-#include "NativeScriptException.h"
 #include "Worker.h"
+#include <functional>
 #include "Caches.h"
-#include "Helpers.h"
-#include "Runtime.h"
 #include "Constants.h"
+#include "Helpers.h"
 #include "ModuleBinding.hpp"
+#include "NativeScriptException.h"
+#include "ObjectManager.h"
+#include "Runtime.h"
 
 using namespace v8;
 
 namespace tns {
 
-std::vector<std::string> Worker::GlobalFunctions = {
-    "postMessage",
-    "close"
-};
+std::vector<std::string> Worker::GlobalFunctions = {"postMessage", "close"};
 
 void Worker::Init(Isolate* isolate, Local<ObjectTemplate> globalTemplate) {
-    Worker::Init(isolate, globalTemplate, Caches::Get(isolate)->isWorker);
+  Worker::Init(isolate, globalTemplate, Caches::Get(isolate)->isWorker);
 }
 
 void Worker::Init(Isolate* isolate, Local<ObjectTemplate> globalTemplate, bool isWorkerThread) {
-    if (isWorkerThread) {
-        // Register functions in the worker thread
-        Local<FunctionTemplate> postMessageTemplate = FunctionTemplate::New(isolate, Worker::PostMessageToMainCallback);
-        globalTemplate->Set(tns::ToV8String(isolate, "postMessage"), postMessageTemplate);
-
-        Local<FunctionTemplate> closeTemplate = FunctionTemplate::New(isolate, Worker::CloseWorkerCallback);
-        globalTemplate->Set(tns::ToV8String(isolate, "close"), closeTemplate);
-    }
-    // Register functions in the main thread
-    Local<FunctionTemplate> workerFuncTemplate = FunctionTemplate::New(isolate, ConstructorCallback);
-    workerFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);
-    Local<v8::String> workerFuncName = ToV8String(isolate, "Worker");
-    workerFuncTemplate->SetClassName(workerFuncName);
-
-    Local<ObjectTemplate> prototype = workerFuncTemplate->PrototypeTemplate();
-    Local<FunctionTemplate> postMessageFuncTemplate = FunctionTemplate::New(isolate, PostMessageCallback);
-    Local<FunctionTemplate> terminateWorkerFuncTemplate = FunctionTemplate::New(isolate, TerminateCallback);
-
-    prototype->Set(ToV8String(isolate, "postMessage"), postMessageFuncTemplate);
-    prototype->Set(ToV8String(isolate, "terminate"), terminateWorkerFuncTemplate);
-
-    globalTemplate->Set(workerFuncName, workerFuncTemplate);
-
+  if (isWorkerThread) {
+    // Register functions in the worker thread
+    Local<FunctionTemplate> postMessageTemplate =
+        FunctionTemplate::New(isolate, Worker::PostMessageToMainCallback);
+    globalTemplate->Set(tns::ToV8String(isolate, "postMessage"), postMessageTemplate);
+
+    Local<FunctionTemplate> closeTemplate =
+        FunctionTemplate::New(isolate, Worker::CloseWorkerCallback);
+    globalTemplate->Set(tns::ToV8String(isolate, "close"), closeTemplate);
+  }
+  // Register functions in the main thread
+  Local<FunctionTemplate> workerFuncTemplate = FunctionTemplate::New(isolate, ConstructorCallback);
+  workerFuncTemplate->InstanceTemplate()->SetInternalFieldCount(1);
+  Local<v8::String> workerFuncName = ToV8String(isolate, "Worker");
+  workerFuncTemplate->SetClassName(workerFuncName);
+
+  Local<ObjectTemplate> prototype = workerFuncTemplate->PrototypeTemplate();
+  Local<FunctionTemplate> postMessageFuncTemplate =
+      FunctionTemplate::New(isolate, PostMessageCallback);
+  Local<FunctionTemplate> terminateWorkerFuncTemplate =
+      FunctionTemplate::New(isolate, TerminateCallback);
+
+  prototype->Set(ToV8String(isolate, "postMessage"), postMessageFuncTemplate);
+  prototype->Set(ToV8String(isolate, "terminate"), terminateWorkerFuncTemplate);
+
+  globalTemplate->Set(workerFuncName, workerFuncTemplate);
 }
 
 void Worker::ConstructorCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
-    Local<Context> context = isolate->GetCurrentContext();
-    try {
-        if (!info.IsConstructCall()) {
-            throw NativeScriptException("Worker function must be called as a constructor.");
-        }
-
-        if (info.Length() < 1) {
-            throw NativeScriptException("Not enough arguments.");
-        }
-
-        if (info.Length() > 1) {
-            throw NativeScriptException("Too many arguments passed.");
-        }
-
-        if (!tns::IsString(info[0])) {
-            throw NativeScriptException("Worker function must be called as a constructor.");
-        }
+  Isolate* isolate = info.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  try {
+    if (!info.IsConstructCall()) {
+      throw NativeScriptException("Worker function must be called as a constructor.");
+    }
 
-        Local<Object> thiz = info.This();
-        std::string workerPath = ToString(isolate, info[0]);
-        // TODO: Validate worker path and call worker.onerror if the script does not exist
-
-        WorkerWrapper* worker = new WorkerWrapper(isolate, Worker::OnMessageCallback);
-        tns::SetValue(isolate, thiz, worker);
-        std::shared_ptr<Persistent<Value>> poWorker = ObjectManager::Register(context, thiz);
-
-        std::function<Isolate* ()> func([worker, workerPath]() {
-            tns::Runtime* runtime = new tns::Runtime();
-            Isolate* isolate = runtime->CreateIsolate();
-            v8::Locker locker(isolate);
-            runtime->Init(isolate, true);
-            runtime->SetWorkerId(worker->WorkerId());
-            int workerId = worker->WorkerId();
-            Worker::SetWorkerId(isolate, workerId);
-
-            TryCatch tc(isolate);
-            runtime->RunModule(workerPath);
-            if (tc.HasCaught()) {
-                Isolate::Scope isolate_scope(isolate);
-                HandleScope handle_scope(isolate);
-                Local<Context> context = Caches::Get(isolate)->GetContext();
-                worker->PassUncaughtExceptionFromWorkerToMain(context, tc, false);
-                worker->Terminate();
-            }
-
-            return isolate;
-        });
-
-        worker->Start(poWorker, func);
-
-        std::shared_ptr<Caches::WorkerState> state = std::make_shared<Caches::WorkerState>(isolate, poWorker, worker);
-        int workerId = worker->Id();
-        Caches::Workers->Insert(workerId, state);
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+    if (info.Length() < 1) {
+      throw NativeScriptException("Not enough arguments.");
     }
-}
 
-void Worker::PostMessageToMainCallback(const FunctionCallbackInfo<Value>& info) {
-    // Send message from worker to main
-    Isolate* isolate = info.GetIsolate();
+    if (info.Length() > 2) {
+      throw NativeScriptException("Too many arguments passed.");
+    }
 
-    try {
-        if (info.Length() < 1) {
-            throw NativeScriptException("Not enough arguments.");
-        }
-        
-        if (info.Length() > 1) {
-            throw NativeScriptException("Too many arguments passed.");
-        }
-        
-        int workerId = Worker::GetWorkerId(isolate, info.This());
-        std::shared_ptr<Caches::WorkerState> state = Caches::Workers->Get(workerId);
-        tns::Assert(state != nullptr, isolate);
-        WorkerWrapper* worker = static_cast<WorkerWrapper*>(state->UserData());
-        if (!worker->IsRunning()) {
-            return;
-        }
-        
-//        Local<Value> error;
-//        Local<Value> result = Worker::Serialize(isolate, info[0], error);
-//        if (result.IsEmpty()) {
-//            isolate->ThrowException(error);
-//            return;
-//        }
-        
-        auto context = Caches::Get(isolate)->GetContext();
-        auto message = std::make_shared<worker::Message>();
-        Local<ObjectTemplate> objTemplate = ObjectTemplate::New(isolate);
-        Local<Object> obj;
-        bool success = objTemplate->NewInstance(context).ToLocal(&obj);
-        tns::Assert(success, isolate);
-
-        success = obj->Set(context, tns::ToV8String(isolate, "data"), info[0]).FromMaybe(false);
-        tns::Assert(success, isolate);
-        
-        message->Serialize(isolate, context, obj);
-        // std::string message = tns::ToString(isolate, result);
-        
-        auto runtime = static_cast<Runtime*>(state->GetIsolate()->GetData(Constants::RUNTIME_SLOT));
-        if (runtime == nullptr) {
-            return;
+    Local<Object> thiz = info.This();
+    std::string workerPath;
+
+    // Handle URL objects by calling toString() on them
+    if (info[0]->IsObject()) {
+      Local<Object> urlObj = info[0].As<Object>();
+      Local<Value> toStringMethod;
+      if (urlObj->Get(context, tns::ToV8String(isolate, "toString")).ToLocal(&toStringMethod)) {
+        if (toStringMethod->IsFunction()) {
+          Local<v8::Function> toString = toStringMethod.As<v8::Function>();
+          Local<Value> result = toString->Call(context, urlObj, 0, nullptr).ToLocalChecked();
+          if (result->IsString()) {
+            workerPath = ToString(isolate, result);
+          } else {
+            throw NativeScriptException("Worker URL object toString() must return a string.");
+          }
+        } else {
+          throw NativeScriptException("Worker URL object must have a toString() method.");
         }
-        tns::ExecuteOnRunLoop(runtime->RuntimeLoop(), [state, message]() {
-            Isolate* isolate = state->GetIsolate();
-            v8::Locker locker(isolate);
-            Isolate::Scope isolate_scope(isolate);
-            HandleScope handle_scope(isolate);
-            Local<Value> workerInstance = state->GetWorker()->Get(isolate);
-            tns::Assert(!workerInstance.IsEmpty() && workerInstance->IsObject(), isolate);
-            Worker::OnMessageCallback(isolate, workerInstance, message);
-        });
-    } catch (NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
+      } else {
+        throw NativeScriptException("Worker URL object must have a toString() method.");
+      }
+    } else if (IsString(info[0])) {
+      workerPath = ToString(isolate, info[0]);
+    } else {
+      throw NativeScriptException("Worker constructor expects a string URL or URL object.");
     }
-}
 
-void Worker::PostMessageCallback(const FunctionCallbackInfo<Value>& info) {
-    // Send message from main to worker
-    Isolate* isolate = info.GetIsolate();
-    try {
-        if (info.Length() < 1) {
-            throw NativeScriptException("Not enough arguments.");
-            return;
+    // TODO: Handle options parameter (info[1]) if provided
+    // For now, we ignore the options parameter to maintain compatibility
+    // TODO: Validate worker path and call worker.onerror if the script does not exist
+
+    WorkerWrapper* worker = new WorkerWrapper(isolate, Worker::OnMessageCallback);
+    tns::SetValue(isolate, thiz, worker);
+    std::shared_ptr<Persistent<Value>> poWorker = ObjectManager::Register(context, thiz);
+
+    std::function<Isolate*()> func([worker, workerPath]() {
+      tns::Runtime* runtime = new tns::Runtime();
+      Isolate* isolate = runtime->CreateIsolate();
+      v8::Locker locker(isolate);
+      runtime->Init(isolate, true);
+      runtime->SetWorkerId(worker->WorkerId());
+      int workerId = worker->WorkerId();
+      Worker::SetWorkerId(isolate, workerId);
+
+      TryCatch tc(isolate);
+
+      // Debug: Log worker execution
+      printf("Worker: About to run module: %s\n", workerPath.c_str());
+
+      // Debug: Check if console exists in worker context
+      {
+        HandleScope debugScope(isolate);
+        Local<Context> workerContext = Caches::Get(isolate)->GetContext();
+        Local<Object> global = workerContext->Global();
+        if (global->Has(workerContext, tns::ToV8String(isolate, "console")).FromMaybe(false)) {
+          printf("Worker: console object exists in worker context\n");
+        } else {
+          printf("Worker: console object NOT found in worker context\n");
         }
+      }
 
-        if (info.Length() > 1) {
-            throw NativeScriptException("Too many arguments passed.");
-            return;
-        }
+      runtime->RunModule(workerPath);
 
-        BaseDataWrapper* wrapper = tns::GetValue(isolate, info.This());
-        tns::Assert(wrapper != nullptr && wrapper->Type() == WrapperType::Worker, isolate);
+      if (tc.HasCaught()) {
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+        Local<Context> context = Caches::Get(isolate)->GetContext();
 
-        WorkerWrapper* worker = static_cast<WorkerWrapper*>(wrapper);
-        if (!worker->IsRunning() || worker->IsClosing()) {
-            return;
+        // Debug: Log the error
+        printf("Worker: Error occurred while running module\n");
+        Local<Value> exception = tc.Exception();
+        if (!exception.IsEmpty()) {
+          v8::String::Utf8Value error_str(isolate, exception);
+          printf("Worker: Exception: %s\n", *error_str);
         }
 
-        Local<Value> error;
-        auto context = Caches::Get(isolate)->GetContext();
-        auto message = std::make_shared<worker::Message>();
-        Local<ObjectTemplate> objTemplate = ObjectTemplate::New(isolate);
-        Local<Object> obj;
-        bool success = objTemplate->NewInstance(context).ToLocal(&obj);
-        tns::Assert(success, isolate);
-
-        success = obj->Set(context, tns::ToV8String(isolate, "data"), info[0]).FromMaybe(false);
-        tns::Assert(success, isolate);
-        
-        message->Serialize(isolate, context, obj);
-        
-         
-//        Local<Value> result = Worker::Serialize(isolate, info[0], error);
-//        if (result.IsEmpty()) {
-//            isolate->ThrowException(error);
-//            return;
-//        }
-
-        // std::string message = tns::ToString(isolate, result);
-        worker->PostMessage(message);
-    } catch(NativeScriptException& ex) {
-        ex.ReThrowToV8(isolate);
-    }
+        worker->PassUncaughtExceptionFromWorkerToMain(context, tc, false);
+        worker->Terminate();
+      } else {
+        // Debug: Log successful execution
+        printf("Worker: Module executed successfully\n");
+      }
+
+      return isolate;
+    });
+
+    worker->Start(poWorker, func);
+
+    std::shared_ptr<Caches::WorkerState> state =
+        std::make_shared<Caches::WorkerState>(isolate, poWorker, worker);
+    int workerId = worker->Id();
+    Caches::Workers->Insert(workerId, state);
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
 }
 
-void Worker::OnMessageCallback(Isolate* isolate, Local<Value> receiver, std::shared_ptr<worker::Message> message) {
-    Local<Context> context = Caches::Get(isolate)->GetContext();
-    Local<Value> onMessageValue;
-    bool success = receiver.As<Object>()->Get(context, tns::ToV8String(isolate, "onmessage")).ToLocal(&onMessageValue);
-    tns::Assert(success, isolate);
+void Worker::PostMessageToMainCallback(const FunctionCallbackInfo<Value>& info) {
+  // Send message from worker to main
+  Isolate* isolate = info.GetIsolate();
 
-    if (!onMessageValue->IsFunction()) {
-        return;
+  try {
+    if (info.Length() < 1) {
+      throw NativeScriptException("Not enough arguments.");
     }
 
-    Local<v8::Function> onMessageFunc = onMessageValue.As<v8::Function>();
-    Local<Value> result;
-
-    Local<Value> arg;
-//    TryCatch tc(isolate);
-    if(!message->Deserialize(isolate, context).ToLocal(&arg)) {
-//        tc.ReThrow();
-        return;
+    if (info.Length() > 1) {
+      throw NativeScriptException("Too many arguments passed.");
     }
 
-    Local<Value> args[1] { arg };
-    success = onMessageFunc->Call(context, receiver, 1, args).ToLocal(&result);
-}
-
-void Worker::CloseWorkerCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
     int workerId = Worker::GetWorkerId(isolate, info.This());
     std::shared_ptr<Caches::WorkerState> state = Caches::Workers->Get(workerId);
     tns::Assert(state != nullptr, isolate);
     WorkerWrapper* worker = static_cast<WorkerWrapper*>(state->UserData());
-
-    if (!worker->IsRunning() || worker->IsClosing()) {
-        return;
+    if (!worker->IsRunning()) {
+      return;
     }
 
-    worker->Close();
+    //        Local<Value> error;
+    //        Local<Value> result = Worker::Serialize(isolate, info[0], error);
+    //        if (result.IsEmpty()) {
+    //            isolate->ThrowException(error);
+    //            return;
+    //        }
+
+    auto context = Caches::Get(isolate)->GetContext();
+    auto message = std::make_shared<worker::Message>();
+    Local<ObjectTemplate> objTemplate = ObjectTemplate::New(isolate);
+    Local<Object> obj;
+    bool success = objTemplate->NewInstance(context).ToLocal(&obj);
+    tns::Assert(success, isolate);
 
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Object> global = context->Global();
-    Local<Value> onCloseVal;
-    bool success = global->Get(context, tns::ToV8String(isolate, "onclose")).ToLocal(&onCloseVal);
+    success = obj->Set(context, tns::ToV8String(isolate, "data"), info[0]).FromMaybe(false);
     tns::Assert(success, isolate);
-    if (!onCloseVal.IsEmpty() && onCloseVal->IsFunction()) {
-        Local<v8::Function> onCloseFunc = onCloseVal.As<v8::Function>();
-        Local<Value> args[0] { };
-        Local<Value> result;
-        TryCatch tc(isolate);
-        success = onCloseFunc->Call(context, v8::Undefined(isolate), 0, args).ToLocal(&result);
-        if (!success && tc.HasCaught()) {
-            worker->CallOnErrorHandlers(tc);
-        }
+
+    message->Serialize(isolate, context, obj);
+    // std::string message = tns::ToString(isolate, result);
+
+    auto runtime = static_cast<Runtime*>(state->GetIsolate()->GetData(Constants::RUNTIME_SLOT));
+    if (runtime == nullptr) {
+      return;
     }
+    tns::ExecuteOnRunLoop(runtime->RuntimeLoop(), [state, message]() {
+      Isolate* isolate = state->GetIsolate();
+      v8::Locker locker(isolate);
+      Isolate::Scope isolate_scope(isolate);
+      HandleScope handle_scope(isolate);
+      Local<Value> workerInstance = state->GetWorker()->Get(isolate);
+      tns::Assert(!workerInstance.IsEmpty() && workerInstance->IsObject(), isolate);
+      Worker::OnMessageCallback(isolate, workerInstance, message);
+    });
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
 }
 
-void Worker::TerminateCallback(const FunctionCallbackInfo<Value>& info) {
-    Isolate* isolate = info.GetIsolate();
+void Worker::PostMessageCallback(const FunctionCallbackInfo<Value>& info) {
+  // Send message from main to worker
+  Isolate* isolate = info.GetIsolate();
+  try {
+    if (info.Length() < 1) {
+      throw NativeScriptException("Not enough arguments.");
+      return;
+    }
+
+    if (info.Length() > 1) {
+      throw NativeScriptException("Too many arguments passed.");
+      return;
+    }
+
     BaseDataWrapper* wrapper = tns::GetValue(isolate, info.This());
     tns::Assert(wrapper != nullptr && wrapper->Type() == WrapperType::Worker, isolate);
 
     WorkerWrapper* worker = static_cast<WorkerWrapper*>(wrapper);
-    worker->Terminate();
-}
+    if (!worker->IsRunning() || worker->IsClosing()) {
+      return;
+    }
 
-Local<v8::String> Worker::Serialize(Isolate* isolate, Local<Value> value, Local<Value>& error) {
-    Local<Context> context = isolate->GetCurrentContext();
+    Local<Value> error;
+    auto context = Caches::Get(isolate)->GetContext();
+    auto message = std::make_shared<worker::Message>();
     Local<ObjectTemplate> objTemplate = ObjectTemplate::New(isolate);
-
     Local<Object> obj;
     bool success = objTemplate->NewInstance(context).ToLocal(&obj);
     tns::Assert(success, isolate);
 
-    success = obj->Set(context, tns::ToV8String(isolate, "data"), value).FromMaybe(false);
+    success = obj->Set(context, tns::ToV8String(isolate, "data"), info[0]).FromMaybe(false);
     tns::Assert(success, isolate);
 
+    message->Serialize(isolate, context, obj);
+
+    //        Local<Value> result = Worker::Serialize(isolate, info[0], error);
+    //        if (result.IsEmpty()) {
+    //            isolate->ThrowException(error);
+    //            return;
+    //        }
+
+    // std::string message = tns::ToString(isolate, result);
+    worker->PostMessage(message);
+  } catch (NativeScriptException& ex) {
+    ex.ReThrowToV8(isolate);
+  }
+}
+
+void Worker::OnMessageCallback(Isolate* isolate, Local<Value> receiver,
+                               std::shared_ptr<worker::Message> message) {
+  Local<Context> context = Caches::Get(isolate)->GetContext();
+  Local<Value> onMessageValue;
+  bool success = receiver.As<Object>()
+                     ->Get(context, tns::ToV8String(isolate, "onmessage"))
+                     .ToLocal(&onMessageValue);
+  tns::Assert(success, isolate);
+
+  if (!onMessageValue->IsFunction()) {
+    return;
+  }
+
+  Local<v8::Function> onMessageFunc = onMessageValue.As<v8::Function>();
+  Local<Value> result;
+
+  Local<Value> arg;
+  //    TryCatch tc(isolate);
+  if (!message->Deserialize(isolate, context).ToLocal(&arg)) {
+    //        tc.ReThrow();
+    return;
+  }
+
+  Local<Value> args[1]{arg};
+  success = onMessageFunc->Call(context, receiver, 1, args).ToLocal(&result);
+}
+
+void Worker::CloseWorkerCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  int workerId = Worker::GetWorkerId(isolate, info.This());
+  std::shared_ptr<Caches::WorkerState> state = Caches::Workers->Get(workerId);
+  tns::Assert(state != nullptr, isolate);
+  WorkerWrapper* worker = static_cast<WorkerWrapper*>(state->UserData());
+
+  if (!worker->IsRunning() || worker->IsClosing()) {
+    return;
+  }
+
+  worker->Close();
+
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Object> global = context->Global();
+  Local<Value> onCloseVal;
+  bool success = global->Get(context, tns::ToV8String(isolate, "onclose")).ToLocal(&onCloseVal);
+  tns::Assert(success, isolate);
+  if (!onCloseVal.IsEmpty() && onCloseVal->IsFunction()) {
+    Local<v8::Function> onCloseFunc = onCloseVal.As<v8::Function>();
+    Local<Value> args[0]{};
     Local<Value> result;
     TryCatch tc(isolate);
-    success = v8::JSON::Stringify(context, obj).ToLocal(&result);
+    success = onCloseFunc->Call(context, v8::Undefined(isolate), 0, args).ToLocal(&result);
     if (!success && tc.HasCaught()) {
-        error = tc.Exception();
-        return Local<v8::String>();
+      worker->CallOnErrorHandlers(tc);
     }
+  }
+}
 
-    tns::Assert(success, isolate);
+void Worker::TerminateCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  BaseDataWrapper* wrapper = tns::GetValue(isolate, info.This());
+  tns::Assert(wrapper != nullptr && wrapper->Type() == WrapperType::Worker, isolate);
+
+  WorkerWrapper* worker = static_cast<WorkerWrapper*>(wrapper);
+  worker->Terminate();
+}
+
+Local<v8::String> Worker::Serialize(Isolate* isolate, Local<Value> value, Local<Value>& error) {
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<ObjectTemplate> objTemplate = ObjectTemplate::New(isolate);
+
+  Local<Object> obj;
+  bool success = objTemplate->NewInstance(context).ToLocal(&obj);
+  tns::Assert(success, isolate);
+
+  success = obj->Set(context, tns::ToV8String(isolate, "data"), value).FromMaybe(false);
+  tns::Assert(success, isolate);
+
+  Local<Value> result;
+  TryCatch tc(isolate);
+  success = v8::JSON::Stringify(context, obj).ToLocal(&result);
+  if (!success && tc.HasCaught()) {
+    error = tc.Exception();
+    return Local<v8::String>();
+  }
+
+  tns::Assert(success, isolate);
 
-    return result.As<v8::String>();
+  return result.As<v8::String>();
 }
 
 void Worker::SetWorkerId(Isolate* isolate, int workerId) {
-    HandleScope scope(isolate);
-    Local<Context> context = isolate->GetCurrentContext();
-    Local<Object> global = context->Global();
-    global->SetPrivate(context, Private::ForApi(isolate, tns::ToV8String(isolate, "workerId")), Number::New(isolate, workerId));
+  HandleScope scope(isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+  Local<Object> global = context->Global();
+  global->SetPrivate(context, Private::ForApi(isolate, tns::ToV8String(isolate, "workerId")),
+                     Number::New(isolate, workerId));
 }
 
 int Worker::GetWorkerId(Isolate* isolate, Local<Object> global) {
-    Local<Value> value;
+  Local<Value> value;
 
-    Local<Context> context = isolate->GetCurrentContext();
-    bool success = global->GetPrivate(context, Private::ForApi(isolate, tns::ToV8String(isolate, "workerId"))).ToLocal(&value);
-    tns::Assert(success && value->IsNumber(), isolate);
+  Local<Context> context = isolate->GetCurrentContext();
+  bool success =
+      global->GetPrivate(context, Private::ForApi(isolate, tns::ToV8String(isolate, "workerId")))
+          .ToLocal(&value);
+  tns::Assert(success && value->IsNumber(), isolate);
 
-    Local<Number> number = value.As<Number>();
-    return number->Value();
+  Local<Number> number = value.As<Number>();
+  return number->Value();
 }
 
 }
diff --git a/package.json b/package.json
index c07f440c..05dfdb09 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "8.9.2",
+  "version": "9.0.0-esm.2",
   "keywords": [
     "NativeScript",
     "iOS",
@@ -44,4 +44,4 @@
       "clang-format -i"
     ]
   }
-}
+}
\ No newline at end of file
diff --git a/v8ios.xcodeproj/project.pbxproj b/v8ios.xcodeproj/project.pbxproj
index 54f685c8..e7c57d2d 100644
--- a/v8ios.xcodeproj/project.pbxproj
+++ b/v8ios.xcodeproj/project.pbxproj
@@ -9,7 +9,6 @@
 /* Begin PBXBuildFile section */
 		2B5088A62BBEB92300F6EB68 /* metadata-arm64.bin in Resources */ = {isa = PBXBuildFile; fileRef = 2BFE21ED2AC1AC3100307752 /* metadata-arm64.bin */; };
 		2B5088A72BBEC1BC00F6EB68 /* TNSWidgets.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = C20525A72577D86600C12A5C /* TNSWidgets.xcframework */; };
-		2B5088A82BBEC1BC00F6EB68 /* TNSWidgets.xcframework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = C20525A72577D86600C12A5C /* TNSWidgets.xcframework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
 		2B7EA6AF2353477000E5184E /* NativeScriptException.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2B7EA6AD2353476F00E5184E /* NativeScriptException.mm */; };
 		2B7EA6B02353477000E5184E /* NativeScriptException.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7EA6AE2353477000E5184E /* NativeScriptException.h */; };
 		2BFE22062AC1C93100307752 /* metadata-arm64.bin in Resources */ = {isa = PBXBuildFile; fileRef = 2BFE22052AC1C93100307752 /* metadata-arm64.bin */; };
@@ -49,6 +48,8 @@
 		9160C065291ED41F000641C0 /* SpinLock.h in Headers */ = {isa = PBXBuildFile; fileRef = 9160C064291ED41F000641C0 /* SpinLock.h */; };
 		91B25A0A29DAC83D00E3CE04 /* ns-v8-tracing-agent-impl.mm in Sources */ = {isa = PBXBuildFile; fileRef = 91B25A0829DAC83D00E3CE04 /* ns-v8-tracing-agent-impl.mm */; };
 		91B25A0B29DAC83D00E3CE04 /* ns-v8-tracing-agent-impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 91B25A0929DAC83D00E3CE04 /* ns-v8-tracing-agent-impl.h */; };
+		AA8C47B12E27114300649BF5 /* ModuleInternalCallbacks.h in Headers */ = {isa = PBXBuildFile; fileRef = AA8C47AF2E27114300649BF5 /* ModuleInternalCallbacks.h */; };
+		AA8C47B22E27114300649BF5 /* ModuleInternalCallbacks.mm in Sources */ = {isa = PBXBuildFile; fileRef = AA8C47B02E27114300649BF5 /* ModuleInternalCallbacks.mm */; };
 		C205257F2577D6F900C12A5C /* NativeScript.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C2DDEB32229EAB3B00345BFE /* NativeScript.framework */; };
 		C20525802577D6F900C12A5C /* NativeScript.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = C2DDEB32229EAB3B00345BFE /* NativeScript.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
 		C20AB5E626E1015300E2B41D /* OneByteStringResource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C20AB5E426E1015200E2B41D /* OneByteStringResource.cpp */; };
@@ -482,6 +483,8 @@
 		9160C064291ED41F000641C0 /* SpinLock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SpinLock.h; path = NativeScript/runtime/SpinLock.h; sourceTree = "<group>"; };
 		91B25A0829DAC83D00E3CE04 /* ns-v8-tracing-agent-impl.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = "ns-v8-tracing-agent-impl.mm"; sourceTree = "<group>"; };
 		91B25A0929DAC83D00E3CE04 /* ns-v8-tracing-agent-impl.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ns-v8-tracing-agent-impl.h"; sourceTree = "<group>"; };
+		AA8C47AF2E27114300649BF5 /* ModuleInternalCallbacks.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ModuleInternalCallbacks.h; sourceTree = "<group>"; };
+		AA8C47B02E27114300649BF5 /* ModuleInternalCallbacks.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ModuleInternalCallbacks.mm; sourceTree = "<group>"; };
 		C2003F9E23FA78CD0043B815 /* TNSDerivedClass.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TNSDerivedClass.h; sourceTree = "<group>"; };
 		C20525A72577D86600C12A5C /* TNSWidgets.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; path = TNSWidgets.xcframework; sourceTree = "<group>"; };
 		C20AB5E426E1015200E2B41D /* OneByteStringResource.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = OneByteStringResource.cpp; sourceTree = "<group>"; };
@@ -1426,6 +1429,8 @@
 				C2DDEB67229EAC8100345BFE /* MetadataBuilder.h */,
 				C2DDEB71229EAC8200345BFE /* MetadataBuilder.mm */,
 				C2DDEB89229EAC8300345BFE /* ModuleInternal.h */,
+				AA8C47AF2E27114300649BF5 /* ModuleInternalCallbacks.h */,
+				AA8C47B02E27114300649BF5 /* ModuleInternalCallbacks.mm */,
 				C2DDEB81229EAC8200345BFE /* ModuleInternal.mm */,
 				2B7EA6AE2353477000E5184E /* NativeScriptException.h */,
 				2B7EA6AD2353476F00E5184E /* NativeScriptException.mm */,
@@ -1621,6 +1626,7 @@
 				C2C8EE7B22CF64E4001F8CEC /* SimpleAllocator.h in Headers */,
 				C247C16822F82842001D2CA2 /* libplatform-export.h in Headers */,
 				F1F30E762B58FC74006A62C0 /* URLSearchParamsImpl.h in Headers */,
+				AA8C47B12E27114300649BF5 /* ModuleInternalCallbacks.h in Headers */,
 				C2DDEBA7229EAC8300345BFE /* ClassBuilder.h in Headers */,
 				6573B9ED291FE5B700B0ED7C /* JSIRuntime.h in Headers */,
 				C2DDEB98229EAC8300345BFE /* ArrayAdapter.h in Headers */,
@@ -2183,6 +2189,7 @@
 				6573B9CE291FE29F00B0ED7C /* JSIV8ValueConverter.cpp in Sources */,
 				C2DDEB92229EAC8300345BFE /* WeakRef.cpp in Sources */,
 				C2A5F86A2359AEB600074AFA /* ExtVector.cpp in Sources */,
+				AA8C47B22E27114300649BF5 /* ModuleInternalCallbacks.mm in Sources */,
 				C2DDEBAF229EAC8300345BFE /* ObjectManager.mm in Sources */,
 				F6191AB029C0FCE8003F588F /* JsV8InspectorClient.mm in Sources */,
 				C2DDEB9C229EAC8300345BFE /* ClassBuilder.cpp in Sources */,