feat: workers

Author: NathanWalker

NativeScript/runtime/ModuleInternal.mm

@@ -2,6 +2,7 @@
 #include <Foundation/Foundation.h>
 #include <sys/stat.h>
 #include <time.h>
+#include <unistd.h>
 #include <utime.h>
 #include <string>
 #include "Caches.h"
@@ -71,6 +72,9 @@ bool IsLikelyOptionalModule(const std::string& moduleName) {
 }
 
 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();
@@ -309,12 +313,45 @@ bool IsLikelyOptionalModule(const std::string& moduleName) {
 
   bool isESM = modulePath.size() >= 4 && modulePath.compare(modulePath.size() - 4, 4, ".mjs") == 0;
 
+  // Debug: Log ES module 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 module namespace object, not a
     // factory function. Wire it as the exports and skip CommonJS invocation.
+    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");
+      }
+    }
+
     exportsObj = scriptValue.As<Object>();
     bool succ =
         moduleObj->Set(context, tns::ToV8String(isolate, "exports"), exportsObj).FromMaybe(false);
@@ -513,9 +550,41 @@ ScriptOrigin origin(
   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, waiting for resolution\n");
+      Local<Promise> promise = result.As<Promise>();
+
+      // For worker context, we need to wait for the promise to resolve
+      // This is important for modules that use top-level await or have async initialization
+      std::shared_ptr<Caches> cache = Caches::Get(isolate);
+      if (cache->isWorker) {
+        printf("LoadESModule: In worker context, processing promise resolution\n");
+
+        // Run the microtask queue to allow the promise to resolve
+        while (promise->State() == Promise::kPending) {
+          isolate->PerformMicrotaskCheckpoint();
+          // Add a small delay to prevent busy waiting
+          usleep(1000);  // 1ms
+        }
+
+        if (promise->State() == Promise::kRejected) {
+          printf("LoadESModule: Promise was rejected\n");
+          Local<Value> reason = promise->Result();
+          isolate->ThrowException(reason);
+          throw NativeScriptException(isolate, tcEval, "Module evaluation promise rejected");
+        }
+
+        printf("LoadESModule: Promise resolved successfully\n");
+      }
+    }
   }
 
   // 7) Return the namespace
@@ -554,6 +623,22 @@ ScriptOrigin origin(
   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
+    std::shared_ptr<Caches> cache = Caches::Get(isolate);
+    if (cache && cache->isWorker) {
+      // 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);
   }
 

NativeScript/runtime/ModuleInternalCallbacks.mm

@@ -65,6 +65,12 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     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) {
@@ -129,6 +135,12 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     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);
@@ -213,9 +225,15 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
   // 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
+  // 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
@@ -326,9 +344,20 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
   // 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 + ";";
 
@@ -367,16 +396,28 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     return v8::MaybeLocal<v8::Module>(jsonModule);
   }
 
-  // 5) If we’ve already compiled that module (non-JSON case), return it
+  // 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>();
   }