Refactor module handling and add path module support

- Removed unnecessary release call for signature in Cif.mm.
- Added napi_env member to ObjCBridgeState and initialized it in the constructor.
- Implemented cleanup logic for napi references in ObjCBridgeState destructor.
- Enhanced v8-module-loader to support package.json "type" field lookups and shebang stripping.
- Updated module resolution logic to handle .cjs and .mjs extensions for CommonJS and ESM respectively.
- Introduced Path module with methods for path manipulation (basename, dirname, extname, etc.).
- Integrated Path module into Node module for seamless usage.

Author: DjDeveloperr

NativeScript/ffi/Cif.mm

@@ -107,8 +107,6 @@
     }
   }
 
-  [signature release];
-
   ffi_status status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, totalArgc, rtype, this->atypes);
 
   if (status != FFI_OK) {

NativeScript/ffi/ObjCBridge.h

@@ -197,6 +197,7 @@ class ObjCBridgeState {
   }
 
  public:
+  napi_env env = nullptr;
   uint64_t lifetimeToken = 0;
   std::unordered_map<id, napi_ref> objectRefs;
 

NativeScript/ffi/ObjCBridge.mm

@@ -496,6 +496,7 @@ void registerLegacyCompatGlobals(napi_env env, napi_value global, ObjCBridgeStat
 
 ObjCBridgeState::ObjCBridgeState(napi_env env, const char* metadata_path,
                                  const void* metadata_ptr) {
+  this->env = env;
   napi_set_instance_data(env, this, finalize_bridge_data, nil);
   lifetimeToken = RegisterBridgeState(this);
 
@@ -536,6 +537,57 @@ void registerLegacyCompatGlobals(napi_env env, napi_value global, ObjCBridgeStat
 ObjCBridgeState::~ObjCBridgeState() {
   UnregisterBridgeState(this);
 
+  auto deleteRef = [&](napi_ref& ref) {
+    if (env != nullptr && ref != nullptr) {
+      napi_delete_reference(env, ref);
+      ref = nullptr;
+    }
+  };
+
+  for (auto& pair : constructorsByPointer) {
+    deleteRef(pair.second);
+  }
+  constructorsByPointer.clear();
+
+  for (auto& frame : roundTripCacheFrames) {
+    for (auto& entry : frame) {
+      deleteRef(entry.second);
+    }
+  }
+  roundTripCacheFrames.clear();
+
+  for (auto& entry : recentRoundTripCache) {
+    deleteRef(entry.second);
+  }
+  recentRoundTripCache.clear();
+
+  std::unordered_set<napi_ref> classAndProtocolConstructorRefs;
+  classAndProtocolConstructorRefs.reserve(classes.size() + protocols.size());
+  for (const auto& pair : classes) {
+    if (pair.second != nullptr && pair.second->constructor != nullptr) {
+      classAndProtocolConstructorRefs.insert(pair.second->constructor);
+    }
+  }
+  for (const auto& pair : protocols) {
+    if (pair.second != nullptr && pair.second->constructor != nullptr) {
+      classAndProtocolConstructorRefs.insert(pair.second->constructor);
+    }
+  }
+  for (auto& pair : mdValueCache) {
+    napi_ref& ref = pair.second;
+    if (ref != nullptr && classAndProtocolConstructorRefs.find(ref) == classAndProtocolConstructorRefs.end()) {
+      deleteRef(ref);
+    }
+  }
+  mdValueCache.clear();
+
+  deleteRef(pointerClass);
+  deleteRef(referenceClass);
+  deleteRef(functionReferenceClass);
+  deleteRef(createNativeProxy);
+  deleteRef(createFastEnumeratorIterator);
+  deleteRef(transferOwnershipToNative);
+
   // Clean up cached Cif objects
   for (auto& pair : cifs) {
     delete pair.second;

NativeScript/napi/v8/v8-module-loader.cpp

@@ -7,12 +7,104 @@
 #include <filesystem>
 #include <fstream>
 #include <sstream>
+#include <unordered_map>
 #include <unordered_set>
 
 #include "runtime/RuntimeConfig.h"
 
 namespace v8impl {
 
+namespace {
+
+// Cache for package.json "type" field lookups
+std::unordered_map<std::string, bool> g_packageTypeCache;
+
+// Strip shebang line from source code (e.g., #!/usr/bin/env node)
+std::string StripShebang(const std::string& source) {
+  if (source.size() >= 2 && source[0] == '#' && source[1] == '!') {
+    size_t lineEnd = source.find('\n');
+    if (lineEnd != std::string::npos) {
+      return source.substr(lineEnd + 1);
+    }
+    return "";  // Entire file is just a shebang
+  }
+  return source;
+}
+
+// Check if path has .cjs extension (explicitly CommonJS)
+bool IsCJSModule(const std::string& path) {
+  return path.size() >= 4 && path.compare(path.size() - 4, 4, ".cjs") == 0;
+}
+
+// Find nearest package.json by walking up from directory
+std::string FindPackageJson(const std::filesystem::path& startDir) {
+  std::filesystem::path current = startDir;
+
+  while (!current.empty() && current != current.root_path()) {
+    std::filesystem::path packagePath = current / "package.json";
+    std::error_code ec;
+    if (std::filesystem::exists(packagePath, ec) && !ec) {
+      return packagePath.string();
+    }
+    current = current.parent_path();
+  }
+
+  return "";
+}
+
+// Check if package.json has "type": "module"
+bool IsPackageTypeModule(const std::string& packageJsonPath) {
+  auto cacheIt = g_packageTypeCache.find(packageJsonPath);
+  if (cacheIt != g_packageTypeCache.end()) {
+    return cacheIt->second;
+  }
+
+  bool isModule = false;
+
+  std::ifstream file(packageJsonPath);
+  if (file.is_open()) {
+    std::string content((std::istreambuf_iterator<char>(file)),
+                        std::istreambuf_iterator<char>());
+    file.close();
+
+    // Simple JSON parsing for "type": "module"
+    // Look for "type" followed by : and "module"
+    size_t typePos = content.find("\"type\"");
+    if (typePos != std::string::npos) {
+      size_t colonPos = content.find(':', typePos + 6);
+      if (colonPos != std::string::npos) {
+        size_t valueStart = content.find('"', colonPos + 1);
+        if (valueStart != std::string::npos) {
+          size_t valueEnd = content.find('"', valueStart + 1);
+          if (valueEnd != std::string::npos) {
+            std::string typeValue =
+                content.substr(valueStart + 1, valueEnd - valueStart - 1);
+            isModule = (typeValue == "module");
+          }
+        }
+      }
+    }
+  }
+
+  g_packageTypeCache[packageJsonPath] = isModule;
+  return isModule;
+}
+
+// Determine if a .js file should be treated as ESM based on nearest
+// package.json
+bool ShouldTreatAsESModule(const std::string& path) {
+  std::filesystem::path filePath(path);
+  std::string packageJson = FindPackageJson(filePath.parent_path());
+
+  if (!packageJson.empty()) {
+    return IsPackageTypeModule(packageJson);
+  }
+
+  return false;  // Default to CommonJS
+}
+
+}  // namespace
+
 // Global registry for ES modules
 std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
 
@@ -59,9 +151,8 @@ std::string ModulePathToURL(const std::string& modulePath) {
 
 bool IsNodeBuiltinSpecifier(const std::string& specifier) {
   static const std::unordered_set<std::string> kBuiltins = {
-      "url",         "node:url",         "fs",  "node:fs",
-      "fs/promises", "node:fs/promises", "web", "node:web",
-      "stream/web",  "node:stream/web"};
+      "url",  "node:url",  "fs",  "node:fs",  "fs/promises", "node:fs/promises",
+      "path", "node:path", "web", "node:web", "stream/web",  "node:stream/web"};
   return kBuiltins.contains(specifier);
 }
 
@@ -149,6 +240,38 @@ export default __fsp;
 )";
   }
 
+  if (builtinName == "path") {
+    return R"(
+const __load = (name) => {
+  if (typeof globalThis.require === "function") {
+    return globalThis.require(name);
+  }
+  if (typeof globalThis.__nativeRequire === "function") {
+    const dir = typeof globalThis.__approot === "string" ? `${globalThis.__approot}/app` : "";
+    return globalThis.__nativeRequire(name, dir);
+  }
+  throw new Error(`Cannot load builtin module '${name}'`);
+};
+const __path = __load("node:path");
+export const basename = __path.basename;
+export const dirname = __path.dirname;
+export const extname = __path.extname;
+export const isAbsolute = __path.isAbsolute;
+export const join = __path.join;
+export const normalize = __path.normalize;
+export const parse = __path.parse;
+export const format = __path.format;
+export const relative = __path.relative;
+export const resolve = __path.resolve;
+export const toNamespacedPath = __path.toNamespacedPath;
+export const sep = __path.sep;
+export const delimiter = __path.delimiter;
+export const posix = __path.posix;
+export const win32 = __path.win32;
+export default __path;
+)";
+  }
+
   if (builtinName == "web") {
     return R"(
 const __load = (name) => {
@@ -201,7 +324,22 @@ export default __streamWeb;
 }
 
 bool IsESModule(const std::string& path) {
-  return path.size() >= 4 && path.compare(path.size() - 4, 4, ".mjs") == 0;
+  // .mjs is always ESM
+  if (path.size() >= 4 && path.compare(path.size() - 4, 4, ".mjs") == 0) {
+    return true;
+  }
+
+  // .cjs is always CommonJS
+  if (IsCJSModule(path)) {
+    return false;
+  }
+
+  // .js files: check package.json "type" field
+  if (path.size() >= 3 && path.compare(path.size() - 3, 3, ".js") == 0) {
+    return ShouldTreatAsESModule(path);
+  }
+
+  return false;
 }
 
 bool IsJSONModule(const std::string& path) {
@@ -216,7 +354,7 @@ std::string ReadFileContent(const std::string& path) {
 
   std::stringstream buffer;
   buffer << file.rdbuf();
-  return buffer.str();
+  return StripShebang(buffer.str());
 }
 
 v8::Local<v8::String> WrapModuleContent(v8::Isolate* isolate,
@@ -278,6 +416,13 @@ std::string ResolveESModulePath(v8::Isolate* isolate,
     return NormalizeModulePath(jsPath);
   }
 
+  // Try with .cjs extension (explicit CommonJS)
+  std::filesystem::path cjsPath = fullPath.string() + ".cjs";
+  if (std::filesystem::exists(cjsPath) &&
+      std::filesystem::is_regular_file(cjsPath)) {
+    return NormalizeModulePath(cjsPath);
+  }
+
   // Try directory with index.mjs
   if (std::filesystem::exists(fullPath) &&
       std::filesystem::is_directory(fullPath)) {
@@ -293,6 +438,13 @@ std::string ResolveESModulePath(v8::Isolate* isolate,
         std::filesystem::is_regular_file(indexJs)) {
       return NormalizeModulePath(indexJs);
     }
+
+    // Try directory with index.cjs
+    std::filesystem::path indexCjs = fullPath / "index.cjs";
+    if (std::filesystem::exists(indexCjs) &&
+        std::filesystem::is_regular_file(indexCjs)) {
+      return NormalizeModulePath(indexCjs);
+    }
   }
 
   throw std::runtime_error("Module not found: " + moduleName);
@@ -644,6 +796,9 @@ void CleanupESModuleSystem(v8::Isolate* isolate) {
 
   // Clear the registry
   g_moduleRegistry.clear();
+
+  // Clear the package.json type cache
+  g_packageTypeCache.clear();
 }
 
 }  // namespace v8impl