feat: enhance module resolution and memory management

- Improved module resolution by normalizing module paths and supporting extensionless "main" entries in package.json.
- Enhanced memory management in Cif and Reference classes, ensuring proper cleanup of allocated resources.
- Added functionality to handle JSON modules and built-in Node.js module specifiers.
- Refactored code for better clarity and maintainability, including updates to error handling and path management.

Author: DjDeveloperr

NativeScript/cli/main.cpp

@@ -32,6 +32,16 @@ void bootFromBytecode(std::string baseDir, const void* data, size_t size) {
 
 void bootFromModuleSpec(std::string baseDir, std::string spec) {
   RuntimeConfig.BaseDir = baseDir;
+  RuntimeConfig.ApplicationPath = baseDir;
+
+  // In CLI mode, map "~" imports to the directory of the entry file when
+  // possible so app bundles that use "~/package.json" resolve consistently.
+  std::error_code ec;
+  std::filesystem::path specPath(spec);
+  auto absoluteSpecPath = std::filesystem::absolute(specPath, ec);
+  if (!ec && !absoluteSpecPath.empty()) {
+    RuntimeConfig.ApplicationPath = absoluteSpecPath.parent_path().string();
+  }
 
   auto runtime = Runtime();
 

NativeScript/ffi/CFunction.mm

@@ -125,10 +125,6 @@
   return cif->returnType->toJS(env, rvalue);
 }
 
-CFunction::~CFunction() {
-  if (cif != nullptr) {
-    delete cif;
-  }
-}
+CFunction::~CFunction() { cif = nullptr; }
 
 }  // namespace nativescript

NativeScript/ffi/Cif.h

@@ -21,6 +21,9 @@ class Cif {
 
   void* rvalue;
   void** avalues;
+  ffi_type** atypes = nullptr;
+  unsigned int avaluesAllocStart = 0;
+  unsigned int avaluesAllocCount = 0;
 
   std::shared_ptr<TypeConv> returnType;
   std::vector<std::shared_ptr<TypeConv>> argTypes;

NativeScript/ffi/Cif.mm

@@ -7,6 +7,7 @@
 #include "ObjCBridge.h"
 #include "TypeConv.h"
 #include "Util.h"
+#include <cstring>
 
 namespace nativescript {
 
@@ -68,13 +69,13 @@
   this->argc = (int)numberOfArguments - 2;
   this->argv = (napi_value*)malloc(sizeof(napi_value) * this->argc);
 
-  unsigned int argc = (unsigned int)numberOfArguments;
+  unsigned int totalArgc = (unsigned int)numberOfArguments;
 
   const char* returnType = signature.methodReturnType;
   this->returnType = TypeConv::Make(env, &returnType);
 
   ffi_type* rtype = this->returnType->type;
-  ffi_type** atypes = (ffi_type**)malloc(sizeof(ffi_type*) * argc);
+  this->atypes = (ffi_type**)malloc(sizeof(ffi_type*) * totalArgc);
 
   unsigned long methodReturnLength = signature.methodReturnLength;
   unsigned long frameLength = signature.frameLength;
@@ -83,16 +84,19 @@
   this->rvalueLength = methodReturnLength;
   this->frameLength = frameLength;
 
-  this->avalues = (void**)malloc(sizeof(void*) * argc);
+  this->avalues = (void**)malloc(sizeof(void*) * totalArgc);
+  memset(this->avalues, 0, sizeof(void*) * totalArgc);
   this->shouldFree = (bool*)malloc(sizeof(bool) * this->argc);
   memset(this->shouldFree, false, sizeof(bool) * this->argc);
   this->shouldFreeAny = false;
+  this->avaluesAllocStart = 2;
+  this->avaluesAllocCount = 0;
 
   for (int i = 0; i < numberOfArguments; i++) {
     const char* argenc = [signature getArgumentTypeAtIndex:i];
 
     auto argTypeInfo = TypeConv::Make(env, &argenc);
-    atypes[i] = argTypeInfo->type;
+    this->atypes[i] = argTypeInfo->type;
 
     if (i >= 2) {
       this->argTypes.push_back(argTypeInfo);
@@ -101,16 +105,17 @@
 
   [signature release];
 
-  ffi_status status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, argc, rtype, atypes);
-
-  for (int i = 2; i < argc; i++) {
-    this->avalues[i] = malloc(cif.arg_types[i]->size);
-  }
+  ffi_status status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, totalArgc, rtype, this->atypes);
 
   if (status != FFI_OK) {
     std::cout << "Failed to prepare CIF, libffi returned error:" << status << std::endl;
     return;
   }
+
+  for (unsigned int i = 2; i < totalArgc; i++) {
+    this->avalues[i] = malloc(cif.arg_types[i]->size);
+    this->avaluesAllocCount++;
+  }
 }
 
 Cif::Cif(napi_env env, MDMetadataReader* reader, MDSectionOffset offset, bool isMethod,
@@ -121,11 +126,12 @@
 
   returnType = TypeConv::Make(env, reader, &offset);
 
-  ffi_type** atypes = nullptr;
-
   auto implicitArgs = isMethod ? 2 : isBlock ? 1 : 0;
 
   shouldFreeAny = false;
+  atypes = nullptr;
+  avaluesAllocStart = 0;
+  avaluesAllocCount = 0;
 
   if (next || isMethod || isBlock) {
     while (next) {
@@ -146,6 +152,7 @@
 
     atypes = (ffi_type**)malloc(sizeof(ffi_type*) * totalArgc);
     avalues = (void**)malloc(sizeof(void*) * argc);
+    memset(avalues, 0, sizeof(void*) * argc);
 
     if (isMethod) {
       atypes[0] = &ffi_type_pointer;
@@ -177,6 +184,7 @@
 
   for (int i = 0; i < argc; i++) {
     avalues[i] = malloc(cif.arg_types[i + implicitArgs]->size);
+    avaluesAllocCount++;
   }
 
   rvalue = malloc(cif.rtype->size);
@@ -191,8 +199,17 @@
     free(argv);
   }
   if (avalues != nullptr) {
+    for (unsigned int i = 0; i < avaluesAllocCount; i++) {
+      auto index = avaluesAllocStart + i;
+      if (avalues[index] != nullptr) {
+        free(avalues[index]);
+      }
+    }
     free(avalues);
   }
+  if (atypes != nullptr) {
+    free(atypes);
+  }
   if (shouldFree != nullptr) {
     free(shouldFree);
   }

NativeScript/ffi/Interop.h

@@ -60,7 +60,9 @@ class Reference {
   ~Reference();
 
   // data = nullptr means the reference is not initialized.
+  napi_env env = nullptr;
   void* data = nullptr;
+  bool ownsData = false;
   std::shared_ptr<TypeConv> type = nullptr;
   napi_ref initValue = nullptr;
 };

NativeScript/ffi/Interop.mm

@@ -802,7 +802,7 @@ napi_value interop_bufferFromData(napi_env env, napi_callback_info info) {
   napi_get_cb_info(env, info, &argc, argv, &jsThis, nullptr);
 
   Reference* reference = new Reference();
-  bool owned = true;
+  reference->env = env;
 
   if (argc == 1) {
     reference->initValue = make_ref(env, argv[0]);
@@ -816,9 +816,10 @@ napi_value interop_bufferFromData(napi_env env, napi_callback_info info) {
 
     if (argtype == napi_object && Pointer::isInstance(env, argv[1])) {
       reference->data = Pointer::unwrap(env, argv[1])->data;
-      owned = false;
+      reference->ownsData = false;
     } else {
       reference->data = malloc(reference->type->type->size);
+      reference->ownsData = true;
       bool shouldFree;
       reference->type->toNative(env, argv[1], reference->data, &shouldFree, &shouldFree);
     }
@@ -832,12 +833,7 @@ napi_value interop_bufferFromData(napi_env env, napi_callback_info info) {
     return nullptr;
   }
 
-  if (owned) {
-    napi_ref ref;
-    napi_wrap(env, jsThis, reference, Reference::finalize, nullptr, &ref);
-  } else {
-    napi_wrap(env, jsThis, reference, nullptr, nullptr, nullptr);
-  }
+  napi_wrap(env, jsThis, reference, Reference::finalize, nullptr, nullptr);
 
   return jsThis;
 }
@@ -897,8 +893,13 @@ napi_value interop_bufferFromData(napi_env env, napi_callback_info info) {
 }
 
 Reference::~Reference() {
-  if (data != nullptr) {
+  if (initValue != nullptr && env != nullptr) {
+    napi_delete_reference(env, initValue);
+    initValue = nullptr;
+  }
+  if (data != nullptr && ownsData) {
     free(data);
+    data = nullptr;
   }
 }
 
@@ -935,7 +936,17 @@ napi_value interop_bufferFromData(napi_env env, napi_callback_info info) {
   return jsThis;
 }
 
-FunctionReference::~FunctionReference() {}
+FunctionReference::~FunctionReference() {
+  // If closure is already created, it shares the same JS function ref.
+  // Clear it there and delete exactly once here.
+  if (closure != nullptr && closure->func == ref) {
+    closure->func = nullptr;
+  }
+  if (ref != nullptr && env != nullptr) {
+    napi_delete_reference(env, ref);
+    ref = nullptr;
+  }
+}
 
 void* FunctionReference::getFunctionPointer(MDSectionOffset offset) {
   if (closure == nullptr) {

NativeScript/ffi/ObjCBridge.mm

@@ -113,11 +113,6 @@ void finalize_bridge_data(napi_env env, void* data, void* hint) {
   }
   mdBlockSignatureCache.clear();
 
-  for (auto& pair : mdFunctionSignatureCache) {
-    delete pair.second;
-  }
-  mdFunctionSignatureCache.clear();
-
   // Clean up ObjCClass objects
   for (auto& pair : classes) {
     delete pair.second;
@@ -142,6 +137,11 @@ void finalize_bridge_data(napi_env env, void* data, void* hint) {
   }
   cFunctionCache.clear();
 
+  for (auto& pair : mdFunctionSignatureCache) {
+    delete pair.second;
+  }
+  mdFunctionSignatureCache.clear();
+
   // if (objc_autoreleasePool != nullptr)
   //   objc_autoreleasePoolPop(objc_autoreleasePool);
 

NativeScript/ffi/TypeConv.mm

@@ -715,6 +715,7 @@ void toNative(napi_env env, napi_value value, void* result, bool* shouldFree,
           if (ref->data == nullptr) {
             ref->type = pointeeType;
             ref->data = malloc(pointeeType->type->size);
+            ref->ownsData = true;
             if (ref->initValue) {
               napi_value initValue = get_ref_value(env, ref->initValue);
               bool shouldFree;

NativeScript/napi/v8/v8-api.cpp

@@ -1,8 +1,11 @@
 #include <algorithm>
+#include <chrono>
 #include <climits>  // INT_MAX
 #include <cmath>
+#include <filesystem>
 #include <sstream>
 #include <string_view>  // string_view, u16string_view
+#include <thread>
 
 #define NAPI_EXPERIMENTAL
 
@@ -3301,6 +3304,28 @@ napi_status NAPI_CDECL napi_run_script_as_module(napi_env env,
   v8::Isolate* isolate = env->isolate;
 
   v8::TryCatch module_try_catch(isolate);
+  auto set_last_exception = [&](v8::Local<v8::Value> exception) {
+    if (!env->last_exception.IsEmpty()) {
+      env->last_exception.Reset();
+    }
+    env->last_exception.Reset(env->isolate, exception);
+  };
+
+  // Normalize module path to keep cache keys stable across equivalent path
+  // spellings (e.g. ".", "..", and symlink traversals).
+  std::error_code pathError;
+  auto normalizedModulePath = std::filesystem::absolute(source_url, pathError);
+  if (pathError) {
+    pathError.clear();
+    normalizedModulePath = std::filesystem::path(source_url);
+  }
+  normalizedModulePath = normalizedModulePath.lexically_normal();
+  auto canonicalModulePath =
+      std::filesystem::weakly_canonical(normalizedModulePath, pathError);
+  if (!pathError) {
+    normalizedModulePath = canonicalModulePath;
+  }
+  const std::string modulePath = normalizedModulePath.string();
 
   // Initialize ES module system on first use
   static bool es_module_initialized = false;
@@ -3312,7 +3337,7 @@ napi_status NAPI_CDECL napi_run_script_as_module(napi_env env,
   // Create script origin for ES module
   v8::ScriptOrigin origin(
       isolate,
-      v8::String::NewFromUtf8(isolate, source_url, v8::NewStringType::kNormal).ToLocalChecked(),
+      v8::String::NewFromUtf8(isolate, modulePath.c_str(), v8::NewStringType::kNormal).ToLocalChecked(),
       0, 0, false, -1, v8::Local<v8::Value>(), false, false,
       true  // is_module = true for ES modules
   );
@@ -3330,10 +3355,6 @@ napi_status NAPI_CDECL napi_run_script_as_module(napi_env env,
 
   v8::Local<v8::Module> module = maybe_module.ToLocalChecked();
 
-  // Register the module in our module registry for resolution
-  // Use the source_url as the module path
-  std::string modulePath = source_url;
-
   // Safe Global handle management: Clear any existing entry first
   auto it = v8impl::g_moduleRegistry.find(modulePath);
   if (it != v8impl::g_moduleRegistry.end()) {
@@ -3363,20 +3384,55 @@ napi_status NAPI_CDECL napi_run_script_as_module(napi_env env,
   if (!module->InstantiateModule(context, &v8impl::ResolveModuleCallback).FromMaybe(false)) {
     if (instantiate_try_catch.HasCaught()) {
       // Store the exception in env->last_exception instead of throwing
-      v8::Local<v8::Value> exception = instantiate_try_catch.Exception();
-      v8::String::Utf8Value error(isolate, exception);
-      
-      if (!env->last_exception.IsEmpty()) {
-        env->last_exception.Reset();
-      }
-      env->last_exception.Reset(env->isolate, instantiate_try_catch.Exception());
+      set_last_exception(instantiate_try_catch.Exception());
     }
     return napi_set_last_error(env, napi_generic_failure);
   }
 
   // Evaluate the module
+  v8::TryCatch evaluate_try_catch(isolate);
   v8::MaybeLocal<v8::Value> maybe_result = module->Evaluate(context);
-  CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe_result, napi_generic_failure);
+  if (maybe_result.IsEmpty()) {
+    if (evaluate_try_catch.HasCaught()) {
+      set_last_exception(evaluate_try_catch.Exception());
+    } else if (module->GetStatus() == v8::Module::kErrored) {
+      set_last_exception(module->GetException());
+    }
+    return napi_set_last_error(env, napi_generic_failure);
+  }
+
+  v8::Local<v8::Value> evaluate_result = maybe_result.ToLocalChecked();
+
+  // Evaluate may return a promise; surface rejection as module-load failure.
+  if (evaluate_result->IsPromise()) {
+    v8::Local<v8::Promise> promise = evaluate_result.As<v8::Promise>();
+    constexpr int kMaxAttempts = 100;
+    int attempts = 0;
+    while (attempts < kMaxAttempts &&
+           promise->State() == v8::Promise::kPending) {
+      isolate->PerformMicrotaskCheckpoint();
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+      attempts++;
+    }
+
+    if (promise->State() == v8::Promise::kRejected) {
+      set_last_exception(promise->Result());
+      return napi_set_last_error(env, napi_generic_failure);
+    }
+
+    if (promise->State() == v8::Promise::kPending) {
+      set_last_exception(v8::Exception::Error(
+          v8::String::NewFromUtf8(isolate,
+                                  "Module evaluation did not settle")
+              .ToLocalChecked()));
+      return napi_set_last_error(env, napi_generic_failure);
+    }
+  }
+
+  if (module->GetStatus() == v8::Module::kErrored) {
+    set_last_exception(module->GetException());
+    return napi_set_last_error(env, napi_generic_failure);
+  }
 
   // Get the module namespace as the result
   v8::Local<v8::Value> namespace_obj = module->GetModuleNamespace();
@@ -3914,4 +3970,4 @@ napi_status napi_is_host_object(napi_env env, napi_value object, bool* result) {
   *result = true;
 
   return napi_ok;
-}
+}