diff --git a/NativeScript/NativeScript-Prefix.pch b/NativeScript/NativeScript-Prefix.pch
index 1ce57293..e9875cc1 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.3"
+#define NATIVESCRIPT_VERSION "9.0.0-alpha.10"
 
 #ifdef DEBUG
 #define SIZEOF_OFF_T 8
diff --git a/NativeScript/runtime/DevFlags.h b/NativeScript/runtime/DevFlags.h
new file mode 100644
index 00000000..ac2b7ede
--- /dev/null
+++ b/NativeScript/runtime/DevFlags.h
@@ -0,0 +1,13 @@
+#pragma once
+
+// Centralized development/runtime flags helpers usable across runtime sources.
+// These read from app package.json via Runtime::GetAppConfigValue and other
+// runtime configuration to determine behavior of dev features.
+
+namespace tns {
+
+// Returns true when verbose script/module loading logs should be emitted.
+// Controlled by package.json setting: "logScriptLoading": true|false
+bool IsScriptLoadingLogEnabled();
+
+} // namespace tns
diff --git a/NativeScript/runtime/DevFlags.mm b/NativeScript/runtime/DevFlags.mm
new file mode 100644
index 00000000..55cf8634
--- /dev/null
+++ b/NativeScript/runtime/DevFlags.mm
@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+#include "DevFlags.h"
+#include "Runtime.h"
+#include "RuntimeConfig.h"
+
+namespace tns {
+
+bool IsScriptLoadingLogEnabled() {
+  id value = Runtime::GetAppConfigValue("logScriptLoading");
+  return value ? [value boolValue] : false;
+}
+
+} // namespace tns
diff --git a/NativeScript/runtime/HMRSupport.h b/NativeScript/runtime/HMRSupport.h
new file mode 100644
index 00000000..cf8af2a1
--- /dev/null
+++ b/NativeScript/runtime/HMRSupport.h
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+// Forward declare v8 types to keep this header lightweight and avoid
+// requiring V8 headers at include sites.
+namespace v8 {
+class Isolate;
+template <class T> class Local;
+class Object;
+class Function;
+class Context;
+}
+
+namespace tns {
+
+// HMRSupport: Isolated helpers for minimal HMR (import.meta.hot) support.
+//
+// This module contains:
+// - Per-module hot data store
+// - Registration for accept/disable callbacks
+// - Initializer to attach import.meta.hot to a module's import.meta
+//
+// Note: Triggering/dispatch is handled by the HMR system elsewhere.
+
+// Retrieve or create the per-module hot data object.
+v8::Local<v8::Object> GetOrCreateHotData(v8::Isolate* isolate, const std::string& key);
+
+// Register accept and dispose callbacks for a module key.
+void RegisterHotAccept(v8::Isolate* isolate, const std::string& key, v8::Local<v8::Function> cb);
+void RegisterHotDispose(v8::Isolate* isolate, const std::string& key, v8::Local<v8::Function> cb);
+
+// Optional: expose read helpers (may be useful for debugging/integration)
+std::vector<v8::Local<v8::Function>> GetHotAcceptCallbacks(v8::Isolate* isolate, const std::string& key);
+std::vector<v8::Local<v8::Function>> GetHotDisposeCallbacks(v8::Isolate* isolate, const std::string& key);
+
+// Attach a minimal import.meta.hot object to the provided import.meta object.
+// The modulePath should be the canonical path used to key callback/data maps.
+void InitializeImportMetaHot(v8::Isolate* isolate,
+                             v8::Local<v8::Context> context,
+                             v8::Local<v8::Object> importMeta,
+                             const std::string& modulePath);
+
+// ─────────────────────────────────────────────────────────────
+// Dev HTTP loader helpers (used during HMR only)
+// These are isolated here so ModuleInternalCallbacks stays lean.
+//
+// Normalize HTTP(S) URLs for module registry keys.
+// - Preserves versioning params for SFC endpoints (/@ns/sfc, /@ns/asm)
+// - Drops cache-busting segments for /@ns/rt and /@ns/core
+// - Drops query params for general app modules (/@ns/m)
+std::string CanonicalizeHttpUrlKey(const std::string& url);
+
+// Minimal text fetch for dev HTTP ESM loader. Returns true on 2xx with non-empty body.
+// - out: response body
+// - contentType: Content-Type header if present
+// - status: HTTP status code
+bool HttpFetchText(const std::string& url, std::string& out, std::string& contentType, int& status);
+
+} // namespace tns
diff --git a/NativeScript/runtime/HMRSupport.mm b/NativeScript/runtime/HMRSupport.mm
new file mode 100644
index 00000000..55fa21e4
--- /dev/null
+++ b/NativeScript/runtime/HMRSupport.mm
@@ -0,0 +1,330 @@
+#include "HMRSupport.h"
+#import <Foundation/Foundation.h>
+#include <algorithm>
+#include "DevFlags.h"
+
+#include <unordered_map>
+#include <vector>
+#include <string>
+#include "Helpers.h"
+
+// Use centralized dev flags helper for logging
+
+namespace tns {
+
+static inline bool StartsWith(const std::string& s, const char* prefix) {
+  size_t n = strlen(prefix);
+  return s.size() >= n && s.compare(0, n, prefix) == 0;
+}
+
+// Per-module hot data and callbacks. Keyed by canonical module path.
+static std::unordered_map<std::string, v8::Global<v8::Object>> g_hotData;
+static std::unordered_map<std::string, std::vector<v8::Global<v8::Function>>> g_hotAccept;
+static std::unordered_map<std::string, std::vector<v8::Global<v8::Function>>> g_hotDispose;
+
+v8::Local<v8::Object> GetOrCreateHotData(v8::Isolate* isolate, const std::string& key) {
+  auto it = g_hotData.find(key);
+  if (it != g_hotData.end()) {
+    if (!it->second.IsEmpty()) {
+      return it->second.Get(isolate);
+    }
+  }
+  v8::Local<v8::Object> obj = v8::Object::New(isolate);
+  g_hotData[key].Reset(isolate, obj);
+  return obj;
+}
+
+void RegisterHotAccept(v8::Isolate* isolate, const std::string& key, v8::Local<v8::Function> cb) {
+  if (cb.IsEmpty()) return;
+  g_hotAccept[key].emplace_back(v8::Global<v8::Function>(isolate, cb));
+}
+
+void RegisterHotDispose(v8::Isolate* isolate, const std::string& key, v8::Local<v8::Function> cb) {
+  if (cb.IsEmpty()) return;
+  g_hotDispose[key].emplace_back(v8::Global<v8::Function>(isolate, cb));
+}
+
+std::vector<v8::Local<v8::Function>> GetHotAcceptCallbacks(v8::Isolate* isolate, const std::string& key) {
+  std::vector<v8::Local<v8::Function>> out;
+  auto it = g_hotAccept.find(key);
+  if (it != g_hotAccept.end()) {
+    for (auto& gfn : it->second) {
+      if (!gfn.IsEmpty()) out.push_back(gfn.Get(isolate));
+    }
+  }
+  return out;
+}
+
+std::vector<v8::Local<v8::Function>> GetHotDisposeCallbacks(v8::Isolate* isolate, const std::string& key) {
+  std::vector<v8::Local<v8::Function>> out;
+  auto it = g_hotDispose.find(key);
+  if (it != g_hotDispose.end()) {
+    for (auto& gfn : it->second) {
+      if (!gfn.IsEmpty()) out.push_back(gfn.Get(isolate));
+    }
+  }
+  return out;
+}
+
+void InitializeImportMetaHot(v8::Isolate* isolate,
+                             v8::Local<v8::Context> context,
+                             v8::Local<v8::Object> importMeta,
+                             const std::string& modulePath) {
+  using v8::Function;
+  using v8::FunctionCallbackInfo;
+  using v8::Local;
+  using v8::Object;
+  using v8::String;
+  using v8::Value;
+
+  // Ensure context scope for property creation
+  v8::HandleScope scope(isolate);
+
+  // Helper to capture key in function data
+  auto makeKeyData = [&](const std::string& key) -> Local<Value> {
+    return tns::ToV8String(isolate, key.c_str());
+  };
+
+  // accept([deps], cb?) — we register cb if provided; deps ignored for now
+  auto acceptCb = [](const FunctionCallbackInfo<Value>& info) {
+    v8::Isolate* iso = info.GetIsolate();
+    Local<Value> data = info.Data();
+    std::string key;
+    if (!data.IsEmpty()) {
+      v8::String::Utf8Value s(iso, data);
+      key = *s ? *s : "";
+    }
+    v8::Local<v8::Function> cb;
+    if (info.Length() >= 1 && info[0]->IsFunction()) {
+      cb = info[0].As<v8::Function>();
+    } else if (info.Length() >= 2 && info[1]->IsFunction()) {
+      cb = info[1].As<v8::Function>();
+    }
+    if (!cb.IsEmpty()) {
+      RegisterHotAccept(iso, key, cb);
+    }
+    // Return undefined
+    info.GetReturnValue().Set(v8::Undefined(iso));
+  };
+
+  // dispose(cb) — register disposer
+  auto disposeCb = [](const FunctionCallbackInfo<Value>& info) {
+    v8::Isolate* iso = info.GetIsolate();
+    Local<Value> data = info.Data();
+    std::string key;
+    if (!data.IsEmpty()) { v8::String::Utf8Value s(iso, data); key = *s ? *s : ""; }
+    if (info.Length() >= 1 && info[0]->IsFunction()) {
+      RegisterHotDispose(iso, key, info[0].As<v8::Function>());
+    }
+    info.GetReturnValue().Set(v8::Undefined(iso));
+  };
+
+  // decline() — mark declined (no-op for now)
+  auto declineCb = [](const FunctionCallbackInfo<Value>& info) {
+    info.GetReturnValue().Set(v8::Undefined(info.GetIsolate()));
+  };
+
+  // invalidate() — no-op for now
+  auto invalidateCb = [](const FunctionCallbackInfo<Value>& info) {
+    info.GetReturnValue().Set(v8::Undefined(info.GetIsolate()));
+  };
+
+  Local<Object> hot = Object::New(isolate);
+  // Stable flags
+  hot->CreateDataProperty(context, tns::ToV8String(isolate, "data"),
+                          GetOrCreateHotData(isolate, modulePath)).Check();
+  hot->CreateDataProperty(context, tns::ToV8String(isolate, "prune"),
+                          v8::Boolean::New(isolate, false)).Check();
+  // Methods
+  hot->CreateDataProperty(
+    context, tns::ToV8String(isolate, "accept"),
+      v8::Function::New(context, acceptCb, makeKeyData(modulePath)).ToLocalChecked()).Check();
+  hot->CreateDataProperty(
+    context, tns::ToV8String(isolate, "dispose"),
+      v8::Function::New(context, disposeCb, makeKeyData(modulePath)).ToLocalChecked()).Check();
+  hot->CreateDataProperty(
+    context, tns::ToV8String(isolate, "decline"),
+      v8::Function::New(context, declineCb, makeKeyData(modulePath)).ToLocalChecked()).Check();
+  hot->CreateDataProperty(
+    context, tns::ToV8String(isolate, "invalidate"),
+      v8::Function::New(context, invalidateCb, makeKeyData(modulePath)).ToLocalChecked()).Check();
+
+  // Attach to import.meta
+  importMeta->CreateDataProperty(
+    context, tns::ToV8String(isolate, "hot"),
+    hot).Check();
+}
+
+// ─────────────────────────────────────────────────────────────
+// Dev HTTP loader helpers
+
+std::string CanonicalizeHttpUrlKey(const std::string& url) {
+  if (!(StartsWith(url, "http://") || StartsWith(url, "https://"))) {
+    return url;
+  }
+  // Drop fragment entirely
+  size_t hashPos = url.find('#');
+  std::string noHash = (hashPos == std::string::npos) ? url : url.substr(0, hashPos);
+
+  // Locate path start and query start
+  size_t schemePos = noHash.find("://");
+  if (schemePos == std::string::npos) {
+    // Unexpected shape; fall back to removing whole query
+    size_t q = noHash.find('?');
+    return (q == std::string::npos) ? noHash : noHash.substr(0, q);
+  }
+  size_t pathStart = noHash.find('/', schemePos + 3);
+  if (pathStart == std::string::npos) {
+    // No path; nothing to normalize
+    return noHash;
+  }
+  size_t qPos = noHash.find('?', pathStart);
+  std::string originAndPath = (qPos == std::string::npos) ? noHash : noHash.substr(0, qPos);
+  std::string query = (qPos == std::string::npos) ? std::string() : noHash.substr(qPos + 1);
+
+  // Decide behavior based on path prefix
+  std::string pathOnly = noHash.substr(pathStart, (qPos == std::string::npos) ? std::string::npos : (qPos - pathStart));
+  bool isAppMod = pathOnly.find("/ns/m") != std::string::npos;
+  bool isSfcMod = pathOnly.find("/ns/sfc") != std::string::npos;
+  bool isSfcAsm = pathOnly.find("/ns/asm") != std::string::npos;
+  bool isRt = pathOnly.find("/ns/rt") != std::string::npos;
+  bool isCore = pathOnly.find("/ns/core") != std::string::npos;
+
+  if (query.empty()) return originAndPath;
+
+  if (isAppMod) {
+    return originAndPath;
+  }
+
+  if (isRt || isCore) {
+    std::string canonical = originAndPath;
+    const char* needle = isRt ? "/ns/rt" : "/ns/core";
+    size_t pos = canonical.find(needle);
+    if (pos != std::string::npos) {
+      canonical = canonical.substr(0, pos) + std::string(needle);
+    }
+    return canonical;
+  }
+
+  if (isSfcMod || isSfcAsm) {
+    std::vector<std::string> keptParams;
+    size_t startPos = 0;
+    while (startPos <= query.size()) {
+      size_t amp = query.find('&', startPos);
+      std::string pair = (amp == std::string::npos) ? query.substr(startPos) : query.substr(startPos, amp - startPos);
+      if (!pair.empty()) {
+        size_t eq = pair.find('=');
+        std::string name = (eq == std::string::npos) ? pair : pair.substr(0, eq);
+        if (!(name == "import")) {
+          keptParams.push_back(pair);
+        }
+      }
+      if (amp == std::string::npos) break;
+      startPos = amp + 1;
+    }
+    if (keptParams.empty()) return originAndPath;
+    std::string rebuilt = originAndPath + "?";
+    for (size_t i = 0; i < keptParams.size(); i++) {
+      rebuilt += keptParams[i];
+      if (i + 1 < keptParams.size()) rebuilt += "&";
+    }
+    return rebuilt;
+  }
+
+  // Other URLs: keep all params except Vite's import marker; sort for stability
+  std::vector<std::string> kept;
+  size_t start = 0;
+  while (start <= query.size()) {
+    size_t amp = query.find('&', start);
+    std::string pair = (amp == std::string::npos) ? query.substr(start) : query.substr(start, amp - start);
+    if (!pair.empty()) {
+      size_t eq = pair.find('=');
+      std::string name = (eq == std::string::npos) ? pair : pair.substr(0, eq);
+      if (!(name == "import")) kept.push_back(pair);
+    }
+    if (amp == std::string::npos) break;
+    start = amp + 1;
+  }
+  if (kept.empty()) return originAndPath;
+  std::sort(kept.begin(), kept.end());
+  std::string rebuilt = originAndPath + "?";
+  for (size_t i = 0; i < kept.size(); i++) {
+    if (i > 0) rebuilt += "&";
+    rebuilt += kept[i];
+  }
+  return rebuilt;
+}
+
+bool HttpFetchText(const std::string& url, std::string& out, std::string& contentType, int& status) {
+  @autoreleasepool {
+    NSURL* u = [NSURL URLWithString:[NSString stringWithUTF8String:url.c_str()]];
+    if (!u) { status = 0; return false; }
+
+    __block NSError* err = nil;
+    __block NSInteger httpStatusLocal = 0;
+    __block std::string contentTypeLocal;
+    __block std::string bodyLocal;
+
+    auto fetchOnce = ^BOOL(NSURL* reqUrl) {
+      bodyLocal.clear();
+      err = nil;
+      httpStatusLocal = 0;
+      contentTypeLocal.clear();
+      NSURLSessionConfiguration* cfg = [NSURLSessionConfiguration defaultSessionConfiguration];
+      cfg.HTTPAdditionalHeaders = @{ @"Accept": @"application/javascript, text/javascript, */*;q=0.1",
+                                     @"Accept-Encoding": @"identity" };
+      cfg.timeoutIntervalForRequest = 5.0;
+      cfg.timeoutIntervalForResource = 5.0;
+      NSURLSession* session = [NSURLSession sessionWithConfiguration:cfg];
+      dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+      NSURLSessionDataTask* task = [session dataTaskWithURL:reqUrl
+                                          completionHandler:^(NSData* data, NSURLResponse* response, NSError* error) {
+        @autoreleasepool {
+          err = error;
+          if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+            httpStatusLocal = ((NSHTTPURLResponse*)response).statusCode;
+            NSString* ct = ((NSHTTPURLResponse*)response).allHeaderFields[@"Content-Type"];
+            if (ct) { contentTypeLocal = std::string([ct UTF8String] ?: ""); }
+          }
+          if (data) {
+            const void* bytes = [data bytes];
+            NSUInteger len = [data length];
+            if (bytes && len > 0) {
+              bodyLocal.assign(static_cast<const char*>(bytes), static_cast<size_t>(len));
+            }
+          }
+        }
+        dispatch_semaphore_signal(sema);
+      }];
+      [task resume];
+      dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(6 * NSEC_PER_SEC));
+      dispatch_semaphore_wait(sema, timeout);
+      [session finishTasksAndInvalidate];
+      return err == nil && !bodyLocal.empty();
+    };
+
+    BOOL ok = fetchOnce(u);
+    if (!ok) {
+      if (tns::IsScriptLoadingLogEnabled()) { Log(@"[http-loader] retrying %s after initial fetch error", url.c_str()); }
+      usleep(120 * 1000);
+      ok = fetchOnce(u);
+    }
+
+    status = (int)httpStatusLocal;
+    contentType = contentTypeLocal;
+    if (!ok || status < 200 || status >= 300) {
+      return false;
+    }
+
+    out.swap(bodyLocal);
+    if (out.empty()) return false;
+    if (tns::IsScriptLoadingLogEnabled()) {
+      unsigned long long blen = (unsigned long long)out.size();
+      const char* ctstr = contentType.empty() ? "<none>" : contentType.c_str();
+      Log(@"[http-loader] fetched status=%ld content-type=%s bytes=%llu", (long)status, ctstr, blen);
+    }
+    return true;
+  }
+}
+
+} // namespace tns
diff --git a/NativeScript/runtime/ModuleInternal.mm b/NativeScript/runtime/ModuleInternal.mm
index 810a673a..ad7533de 100644
--- a/NativeScript/runtime/ModuleInternal.mm
+++ b/NativeScript/runtime/ModuleInternal.mm
@@ -1,5 +1,5 @@
 #include "ModuleInternal.h"
-#include <Foundation/Foundation.h>
+#import <Foundation/Foundation.h>
 #include <sys/stat.h>
 #include <time.h>
 #include <unistd.h>
@@ -9,6 +9,7 @@
 #include "Helpers.h"
 #include "ModuleInternalCallbacks.h"  // for ResolveModuleCallback
 #include "NativeScriptException.h"
+#include "DevFlags.h"
 #include "Runtime.h"  // for GetAppConfigValue
 #include "RuntimeConfig.h"
 
@@ -35,6 +36,26 @@ bool IsESModule(const std::string& path) {
          !(path.size() >= 8 && path.compare(path.size() - 8, 8, ".mjs.map") == 0);
 }
 
+// Normalize file system paths to a canonical representation so lookups in
+// g_moduleRegistry remain consistent regardless of how the path was provided.
+static std::string NormalizePath(const std::string& path) {
+  if (path.empty()) {
+    return path;
+  }
+
+  NSString* nsPath = [NSString stringWithUTF8String:path.c_str()];
+  if (nsPath == nil) {
+    return path;
+  }
+
+  NSString* standardized = [nsPath stringByStandardizingPath];
+  if (standardized == nil) {
+    return path;
+  }
+
+  return std::string([standardized UTF8String]);
+}
+
 // Helper function to resolve main entry from package.json with proper extension handling
 std::string ResolveMainEntryFromPackageJson(const std::string& baseDir) {
   // Get the main value from package.json
@@ -144,12 +165,10 @@ bool IsESModule(const std::string& path) {
     }
   }
 
-  // Check if this is an ES module (.mjs) and handle it directly
+  // ES module fast path
   if (IsESModule(path)) {
-    // For ES modules, use LoadESModule directly instead of require()
     TryCatch tc(isolate);
     Local<Value> moduleNamespace;
-
     try {
       moduleNamespace = ModuleInternal::LoadESModule(isolate, path);
     } catch (const NativeScriptException& ex) {
@@ -158,23 +177,20 @@ bool IsESModule(const std::string& path) {
         Log(@"Error loading ES module: %s", path.c_str());
         Log(@"Exception: %s", ex.getMessage().c_str());
         Log(@"***** End stack trace - continuing execution *****");
-        Log(@"Debug mode - ES module loading failed, but telling iOS it succeeded to prevent "
-            @"app termination");
-        return true;  // LIE TO iOS - return success to prevent app termination
+        Log(@"Debug mode - ES module loading failed, but telling iOS it succeeded to prevent app termination");
+        return true;  // avoid termination in debug
       } else {
         return false;
       }
     }
-
     if (moduleNamespace.IsEmpty()) {
       if (RuntimeConfig.IsDebug) {
         Log(@"Debug mode - ES module returned empty namespace, but telling iOS it succeeded");
-        return true;  // LIE TO iOS - return success to prevent app termination
+        return true;
       } else {
         return false;
       }
     }
-
     return true;  // ES module loaded successfully
   }
 
@@ -280,6 +296,17 @@ bool IsESModule(const std::string& path) {
   NSString* fullPath = nil;
 
   try {
+    // Guard: URL-based modules must be loaded via dynamic import() in dev HTTP ESM mode.
+    if (info.Length() > 0 && info[0]->IsString()) {
+      v8::String::Utf8Value s(isolate, info[0]);
+      if (*s) {
+        moduleName.assign(*s, s.length());
+        if (moduleName.rfind("http://", 0) == 0 || moduleName.rfind("https://", 0) == 0) {
+          std::string msg = std::string("NativeScript: require() of URL module is not supported: ") + moduleName + ". Use dynamic import() instead.";
+          throw NativeScriptException(msg.c_str());
+        }
+      }
+    }
     ModuleInternal* moduleInternal =
         static_cast<ModuleInternal*>(info.Data().As<External>()->Value());
 
@@ -307,6 +334,7 @@ bool IsESModule(const std::string& path) {
         fullPath = [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()]
             stringByAppendingPathComponent:[NSString stringWithUTF8String:moduleName.c_str()]];
       } else {
+        // Default: resolve in tns_modules (shared folder override removed)
         NSString* tnsModulesPath =
             [[NSString stringWithUTF8String:RuntimeConfig.ApplicationPath.c_str()]
                 stringByAppendingPathComponent:@"tns_modules"];
@@ -329,6 +357,7 @@ bool IsESModule(const std::string& path) {
       fullPath = [NSString stringWithUTF8String:moduleName.c_str()];
     }
 
+
     NSString* fileNameOnly = [fullPath lastPathComponent];
     NSString* pathOnly = [fullPath stringByDeletingLastPathComponent];
 
@@ -668,21 +697,23 @@ throw NativeScriptException(isolate,
 }
 
 Local<Value> ModuleInternal::LoadScript(Isolate* isolate, const std::string& path) {
-  if (IsESModule(path)) {
+  std::string canonicalPath = NormalizePath(path);
+
+  if (IsESModule(canonicalPath)) {
     // Treat all .mjs files as standard ES modules.
-    return ModuleInternal::LoadESModule(isolate, path);
+    return ModuleInternal::LoadESModule(isolate, canonicalPath);
   }
 
-  Local<Script> script = ModuleInternal::LoadClassicScript(isolate, path);
+  Local<Script> script = ModuleInternal::LoadClassicScript(isolate, canonicalPath);
 
   // Check if script compilation failed (debug mode graceful returns)
   if (script.IsEmpty()) {
     if (RuntimeConfig.IsDebug) {
       Log(@"Debug mode - Classic script compilation returned empty, returning gracefully: %s",
-          path.c_str());
+          canonicalPath.c_str());
       return Local<Value>();
     } else {
-      throw NativeScriptException(isolate, "Classic script compilation failed for " + path);
+      throw NativeScriptException(isolate, "Classic script compilation failed for " + canonicalPath);
     }
   }
 
@@ -699,7 +730,7 @@ throw NativeScriptException(isolate,
 
       // Log the detailed JavaScript error with full stack trace
       Log(@"***** JavaScript exception occurred - detailed stack trace follows *****");
-      Log(@"Error executing script: %s", path.c_str());
+      Log(@"Error executing script: %s", canonicalPath.c_str());
       if (tc.HasCaught()) {
         tns::LogError(isolate, tc);
       }
@@ -730,9 +761,9 @@ throw NativeScriptException(isolate,
       return Local<Value>();
     } else {
       if (tc.HasCaught()) {
-        throw NativeScriptException(isolate, tc, "Cannot execute script " + path);
+        throw NativeScriptException(isolate, tc, "Cannot execute script " + canonicalPath);
       } else {
-        throw NativeScriptException(isolate, "Script execution failed for " + path);
+        throw NativeScriptException(isolate, "Script execution failed for " + canonicalPath);
       }
     }
   }
@@ -741,27 +772,29 @@ throw NativeScriptException(isolate,
 }
 
 Local<Script> ModuleInternal::LoadClassicScript(Isolate* isolate, const std::string& path) {
+  std::string canonicalPath = NormalizePath(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);
+  if (stat(canonicalPath.c_str(), &st) != 0 || !S_ISREG(st.st_mode)) {
+    throw NativeScriptException("Cannot find module " + canonicalPath);
   }
 
   auto context = isolate->GetCurrentContext();
   // build URL
-  std::string base = ReplaceAll(path, RuntimeConfig.BaseDir, "");
+  std::string base = ReplaceAll(canonicalPath, RuntimeConfig.BaseDir, "");
   std::string url = "file://" + base;
 
   // wrap & cache lookup
-  Local<v8::String> sourceText = ModuleInternal::WrapModuleContent(isolate, path);
-  auto* cacheData = ModuleInternal::LoadScriptCache(path);
+  Local<v8::String> sourceText = ModuleInternal::WrapModuleContent(isolate, canonicalPath);
+  auto* cacheData = ModuleInternal::LoadScriptCache(canonicalPath);
 
   // note: is_module=false here
   Local<v8::String> urlString;
   if (!v8::String::NewFromUtf8(isolate, url.c_str(), NewStringType::kNormal).ToLocal(&urlString)) {
-    throw NativeScriptException(isolate, "Failed to create URL string for script " + path);
+    throw NativeScriptException(isolate, "Failed to create URL string for script " + canonicalPath);
   }
 
   ScriptOrigin origin(isolate, urlString,
@@ -787,38 +820,39 @@ ScriptOrigin origin(isolate, urlString,
 
       // Log the detailed JavaScript error with full stack trace
       Log(@"***** JavaScript exception occurred - detailed stack trace follows *****");
-      Log(@"Error compiling classic script: %s", path.c_str());
+      Log(@"Error compiling classic script: %s", canonicalPath.c_str());
       if (tc.HasCaught()) {
         tns::LogError(isolate, tc);
       }
       Log(@"***** End stack trace - continuing execution *****");
-      Log(@"Debug mode - Script compilation failed, returning gracefully: %s", path.c_str());
+      Log(@"Debug mode - Script compilation failed, returning gracefully: %s", canonicalPath.c_str());
       // Return empty script to prevent crashes
       return Local<Script>();
     } else {
-      throw NativeScriptException(isolate, tc, "Cannot compile script " + path);
+      throw NativeScriptException(isolate, tc, "Cannot compile script " + canonicalPath);
     }
   }
 
   if (cacheData == nullptr) {
-    ModuleInternal::SaveScriptCache(script, path);
+    ModuleInternal::SaveScriptCache(script, canonicalPath);
   }
 
   return script;
 }
 
 Local<Value> ModuleInternal::LoadESModule(Isolate* isolate, const std::string& path) {
+  std::string canonicalPath = NormalizePath(path);
   auto context = isolate->GetCurrentContext();
 
   // 1) Prepare URL & source
-  std::string base = ReplaceAll(path, RuntimeConfig.BaseDir, "");
+  std::string base = ReplaceAll(canonicalPath, RuntimeConfig.BaseDir, "");
   std::string url = "file://" + base;
-  v8::Local<v8::String> sourceText = ModuleInternal::WrapModuleContent(isolate, path);
-  auto* cacheData = ModuleInternal::LoadScriptCache(path);
+  v8::Local<v8::String> sourceText = ModuleInternal::WrapModuleContent(isolate, canonicalPath);
+  auto* cacheData = ModuleInternal::LoadScriptCache(canonicalPath);
 
   Local<v8::String> urlString;
   if (!v8::String::NewFromUtf8(isolate, url.c_str(), NewStringType::kNormal).ToLocal(&urlString)) {
-    throw NativeScriptException(isolate, "Failed to create URL string for ES module " + path);
+    throw NativeScriptException(isolate, "Failed to create URL string for ES module " + canonicalPath);
   }
 
   ScriptOrigin origin(isolate, urlString, 0, 0, false, -1, Local<Value>(), false, false,
@@ -827,6 +861,25 @@ ScriptOrigin origin(isolate, urlString, 0, 0, false, -1, Local<Value>(), false,
   ScriptCompiler::Source source(sourceText, origin, cacheData);
 
   // 2) Compile with its own TryCatch
+  // Phase diagnostics helper (local lambda) – only active in debug builds when logScriptLoading is enabled
+  auto logPhase = [&](const char* phase, const char* status, const char* classification = "", const char* extra = "") {
+    if (RuntimeConfig.IsDebug && IsScriptLoadingLogEnabled()) {
+      if (classification && classification[0] != '\0') {
+        if (extra && extra[0] != '\0') {
+          Log(@"[esm][%s][%s][%s] %s %s", phase, status, classification, canonicalPath.c_str(), extra);
+        } else {
+          Log(@"[esm][%s][%s][%s] %s", phase, status, classification, canonicalPath.c_str());
+        }
+      } else {
+        if (extra && extra[0] != '\0') {
+          Log(@"[esm][%s][%s] %s %s", phase, status, canonicalPath.c_str(), extra);
+        } else {
+          Log(@"[esm][%s][%s] %s", phase, status, canonicalPath.c_str());
+        }
+      }
+    }
+  };
+  logPhase("compile", "begin");
   Local<Module> module;
   {
     TryCatch tcCompile(isolate);
@@ -835,134 +888,171 @@ ScriptOrigin origin(isolate, urlString, 0, 0, false, -1, Local<Value>(), false,
         cacheData ? ScriptCompiler::kConsumeCodeCache : ScriptCompiler::kNoCompileOptions);
 
     if (!maybeMod.ToLocal(&module)) {
+      // Attempt classification heuristics
+      const char* classification = "unknown";
+      if (tcCompile.HasCaught()) {
+        Local<Message> msg = tcCompile.Message();
+        if (!msg.IsEmpty()) {
+          v8::String::Utf8Value w(isolate, msg->Get());
+          if (*w) {
+            std::string m(*w);
+            if (m.find("Unexpected token") != std::string::npos || m.find("SyntaxError") != std::string::npos) classification = "syntax";
+            else if (m.find("Cannot use import statement outside a module") != std::string::npos) classification = "not-a-module";
+          }
+        }
+      }
+      logPhase("compile", "fail", classification);
       // V8 threw a syntax error or similar
       if (RuntimeConfig.IsDebug) {
         // Log the detailed JavaScript error with full stack trace
-        Log(@"***** JavaScript exception occurred - detailed stack trace follows *****");
-        Log(@"Error compiling ES module: %s", path.c_str());
+        Log(@"***** JavaScript exception occurred *****");
+        Log(@"Error compiling ES module: %s", canonicalPath.c_str());
         if (tcCompile.HasCaught()) {
           tns::LogError(isolate, tcCompile);
         }
-        Log(@"***** End stack trace - continuing execution *****");
-        Log(@"Debug mode - ES module compilation failed, returning gracefully: %s", path.c_str());
+        Log(@"***** Debug mode - continuing execution *****");
+        Log(@"ES module compilation failed: %s", canonicalPath.c_str());
         // Return empty to prevent crashes
         return Local<Value>();
       } else {
-        throw NativeScriptException(isolate, tcCompile, "Cannot compile ES module " + path);
+        throw NativeScriptException(isolate, tcCompile, "Cannot compile ES module " + canonicalPath);
       }
     }
   }
+  logPhase("compile", "ok");
 
   // 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);
+  auto it = g_moduleRegistry.find(canonicalPath);
   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);
+  g_moduleRegistry[canonicalPath].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);
+    ModuleInternal::SaveScriptCache(generatedCache, canonicalPath);
   }
 
   // 5) Instantiate (link) with its own TryCatch
+  logPhase("instantiate", "begin");
   {
     TryCatch tcLink(isolate);
     bool linked = module->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false);
 
     if (!linked) {
+      RemoveModuleFromRegistry(canonicalPath);
+      const char* classification = "unknown";
+      if (tcLink.HasCaught()) {
+        Local<Message> msg = tcLink.Message();
+        if (!msg.IsEmpty()) {
+          v8::String::Utf8Value w(isolate, msg->Get());
+          if (*w) {
+            std::string m(*w);
+            if (m.find("Cannot find module") != std::string::npos || m.find("failed to resolve module specifier") != std::string::npos) classification = "resolve";
+            else if (m.find("does not provide an export named") != std::string::npos) classification = "link-export";
+          }
+        }
+      }
+      logPhase("instantiate", "fail", classification);
       if (RuntimeConfig.IsDebug) {
         // Log the detailed JavaScript error with full stack trace
-        Log(@"***** JavaScript exception occurred - detailed stack trace follows *****");
-        Log(@"Error instantiating module: %s", path.c_str());
+        Log(@"***** JavaScript exception occurred *****");
+        Log(@"Error instantiating module: %s", canonicalPath.c_str());
         if (tcLink.HasCaught()) {
           tns::LogError(isolate, tcLink);
         }
-        Log(@"***** End stack trace - continuing execution *****");
-        Log(@"Debug mode - Module instantiation failed, returning gracefully: %s", path.c_str());
+        Log(@"***** Debug mode - continuing execution *****");
+        Log(@"Module instantiation failed: %s", canonicalPath.c_str());
         return Local<Value>();
       } else {
         if (tcLink.HasCaught()) {
-          throw NativeScriptException(isolate, tcLink, "Cannot instantiate module " + path);
+          throw NativeScriptException(isolate, tcLink, "Cannot instantiate module " + canonicalPath);
         } else {
           // V8 gave no exception object—throw plain text
-          throw NativeScriptException(isolate, "Cannot instantiate module " + path);
+          throw NativeScriptException(isolate, "Cannot instantiate module " + canonicalPath);
         }
       }
     }
   }
+  logPhase("instantiate", "ok");
 
   // 6) Evaluate with its own TryCatch
+  logPhase("evaluate", "begin");
   Local<Value> result;
   {
     TryCatch tcEval(isolate);
-    printf("LoadESModule: About to evaluate module: %s\n", path.c_str());
+    // Keep existing debug print minimal; phase logger already outputs
     if (!module->Evaluate(context).ToLocal(&result)) {
-      printf("LoadESModule: Evaluation failed for module: %s\n", path.c_str());
+      RemoveModuleFromRegistry(canonicalPath);
+      const char* classification = "unknown";
+      if (tcEval.HasCaught()) {
+        Local<Message> msg = tcEval.Message();
+        if (!msg.IsEmpty()) {
+          v8::String::Utf8Value w(isolate, msg->Get());
+          if (*w) {
+            std::string m(*w);
+            if (m.find("is not defined") != std::string::npos) classification = "reference";
+            else if (m.find("TypeError") != std::string::npos) classification = "type";
+            else if (m.find("Cannot read properties") != std::string::npos) classification = "type-nullish";
+          }
+        }
+      }
+      logPhase("evaluate", "fail", classification);
       if (RuntimeConfig.IsDebug) {
         // Log the detailed JavaScript error with full stack trace
-        Log(@"***** JavaScript exception occurred - detailed stack trace follows *****");
-        Log(@"Error evaluating ES module: %s", path.c_str());
+        Log(@"***** JavaScript exception occurred *****");
+        Log(@"Error evaluating ES module: %s", canonicalPath.c_str());
         if (tcEval.HasCaught()) {
           tns::LogError(isolate, tcEval);
         }
-        Log(@"***** End stack trace - continuing execution *****");
-        Log(@"Debug mode - Module evaluation failed, returning gracefully: %s", path.c_str());
+        Log(@"***** Debug mode - continuing execution *****");
+        Log(@"Module evaluation failed: %s", canonicalPath.c_str());
         return Local<Value>();
       } else {
-        throw NativeScriptException(isolate, tcEval, "Cannot evaluate module " + path);
+        throw NativeScriptException(isolate, tcEval, "Cannot evaluate module " + canonicalPath);
       }
     }
-    printf("LoadESModule: Evaluation completed successfully for module: %s\n", path.c_str());
+    logPhase("evaluate", "ok");
 
     // Handle the case where evaluation returns a Promise (for top-level await)
     if (result->IsPromise()) {
-      printf("LoadESModule: Module evaluation returned a Promise, processing...\n");
+      logPhase("evaluate", "promise");
 
-      // 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");
+            RemoveModuleFromRegistry(canonicalPath);
+            logPhase("evaluate", "promise-rejected");
             if (RuntimeConfig.IsDebug) {
-              // Mark that a JavaScript error occurred
+              // In debug mode, show modal and continue without throwing
               jsErrorOccurred = true;
 
-              // First log the detailed JavaScript error with full stack trace
-              Log(@"***** JavaScript exception occurred - detailed stack trace follows *****");
-
               std::string errorTitle = "Uncaught JavaScript Exception";
               std::string errorMessage = "Module evaluation promise rejected";
               std::string stackTrace = "";
-
+              
               // Try to get the promise result (the actual error)
               Local<Value> reason = promise->Result();
               if (!reason.IsEmpty()) {
@@ -970,25 +1060,20 @@ ScriptOrigin origin(isolate, urlString, 0, 0, false, -1, Local<Value>(), false,
                   Local<Context> context = isolate->GetCurrentContext();
                   Local<Object> errorObj = reason.As<Object>();
 
-                  // Get error message
                   auto messageKey = tns::ToV8String(isolate, "message");
                   Local<Value> messageVal;
-                  if (errorObj->Get(context, messageKey).ToLocal(&messageVal) &&
-                      messageVal->IsString()) {
+                  if (errorObj->Get(context, messageKey).ToLocal(&messageVal) && messageVal->IsString()) {
                     v8::String::Utf8Value messageUtf8(isolate, messageVal);
-                    if (*messageUtf8) {
-                      errorMessage = std::string(*messageUtf8);
-                    }
+                    if (*messageUtf8) errorMessage = std::string(*messageUtf8);
                   }
 
-                  // Get stack trace
+                  // get stack trace
                   auto stackKey = tns::ToV8String(isolate, "stack");
                   Local<Value> stackVal;
                   if (errorObj->Get(context, stackKey).ToLocal(&stackVal) && stackVal->IsString()) {
                     v8::String::Utf8Value stackUtf8(isolate, stackVal);
                     if (*stackUtf8) {
                       stackTrace = std::string(*stackUtf8);
-                      // Clean up the stack trace path
                       stackTrace = ReplaceAll(stackTrace, RuntimeConfig.BaseDir, "");
                     }
                   }
@@ -1026,7 +1111,15 @@ ScriptOrigin origin(isolate, urlString, 0, 0, false, -1, Local<Value>(), false,
                 stackTrace = tns::RemapStackTraceIfAvailable(isolate, stackTrace);
               }
 
+              if (IsScriptLoadingLogEnabled()) {
+                // Emit a concise summary of the rejection for diagnostics
+                std::string stackPreview = stackTrace.size() > 240 ? stackTrace.substr(0, 240) + "…" : stackTrace;
+                Log(@"[esm][evaluate][promise-rejected:detail] path=%s message=%s stack=%s",
+                    canonicalPath.c_str(), errorMessage.c_str(), stackPreview.c_str());
+              }
+
               NativeScriptException::ShowErrorModal(isolate, errorTitle, errorMessage, stackTrace);
+              logPhase("evaluate", "promise-rejected-handled");
 
               // In debug mode, don't throw any exceptions - just return empty value
               return Local<Value>();
@@ -1039,19 +1132,23 @@ ScriptOrigin origin(isolate, urlString, 0, 0, false, -1, Local<Value>(), false,
               throw NativeScriptException(isolate, promiseTc, "Module evaluation promise rejected");
             }
           }
-          printf("LoadESModule: Promise resolved successfully\n");
+          if (IsScriptLoadingLogEnabled()) {
+            Log("LoadESModule: Promise resolved successfully\n");
+          }
           break;
         }
 
         attempts++;
         usleep(100);  // 0.1ms delay
       }
+      // Timeout: continue; the host event loop will settle microtasks later
 
       if (attempts >= maxAttempts) {
         printf("LoadESModule: Promise resolution timeout, continuing anyway\n");
       }
     }
   }
+  tns::UpdateModuleFallback(isolate, canonicalPath, module);
 
   // 7) Return the namespace
   return module->GetModuleNamespace();
@@ -1380,17 +1477,18 @@ throw NativeScriptException(
 }
 
 ScriptCompiler::CachedData* ModuleInternal::LoadScriptCache(const std::string& path) {
+  std::string canonicalPath = NormalizePath(path);
   if (RuntimeConfig.IsDebug) {
     return nullptr;
   }
 
   long length = 0;
-  std::string cachePath = ModuleInternal::GetCacheFileName(path + ".cache");
+  std::string cachePath = ModuleInternal::GetCacheFileName(canonicalPath + ".cache");
 
   struct stat result;
   if (stat(cachePath.c_str(), &result) == 0) {
     auto cacheLastModifiedTime = result.st_mtime;
-    if (stat(path.c_str(), &result) == 0) {
+    if (stat(canonicalPath.c_str(), &result) == 0) {
       auto jsLastModifiedTime = result.st_mtime;
       if (jsLastModifiedTime != cacheLastModifiedTime) {
         // files have different dates, ignore the cache file (this is enforced by the
@@ -1413,7 +1511,8 @@ throw NativeScriptException(
 
 void ModuleInternal::SaveScriptCache(const ScriptCompiler::CachedData* cache,
                                      const std::string& path) {
-  std::string cachePath = ModuleInternal::GetCacheFileName(path + ".cache");
+  std::string canonicalPath = NormalizePath(path);
+  std::string cachePath = ModuleInternal::GetCacheFileName(canonicalPath + ".cache");
 
   // std::ofstream ofs(cachePath, std::ios::binary);
   // if (!ofs) return;  // or throw
@@ -1431,7 +1530,7 @@ throw NativeScriptException(
   struct utimbuf new_times;
   new_times.actime = time(nullptr);
   new_times.modtime = time(nullptr);
-  if (stat(path.c_str(), &result) == 0) {
+  if (stat(canonicalPath.c_str(), &result) == 0) {
     auto jsLastModifiedTime = result.st_mtime;
     new_times.modtime = jsLastModifiedTime;
   }
@@ -1443,12 +1542,14 @@ throw NativeScriptException(
     return;
   }
 
+  std::string canonicalPath = NormalizePath(path);
+
   Local<UnboundScript> unboundScript = script->GetUnboundScript();
   // CachedData returned by this function should be owned by the caller (v8 docs)
   ScriptCompiler::CachedData* cachedData = ScriptCompiler::CreateCodeCache(unboundScript);
 
   int length = cachedData->length;
-  std::string cachePath = ModuleInternal::GetCacheFileName(path + ".cache");
+  std::string cachePath = ModuleInternal::GetCacheFileName(canonicalPath + ".cache");
   tns::WriteBinary(cachePath, cachedData->data, length);
   delete cachedData;
 
@@ -1457,7 +1558,7 @@ throw NativeScriptException(
   struct utimbuf new_times;
   new_times.actime = time(nullptr);
   new_times.modtime = time(nullptr);
-  if (stat(path.c_str(), &result) == 0) {
+  if (stat(canonicalPath.c_str(), &result) == 0) {
     auto jsLastModifiedTime = result.st_mtime;
     new_times.modtime = jsLastModifiedTime;
   }
diff --git a/NativeScript/runtime/ModuleInternalCallbacks.h b/NativeScript/runtime/ModuleInternalCallbacks.h
index 676824a7..3d0df014 100644
--- a/NativeScript/runtime/ModuleInternalCallbacks.h
+++ b/NativeScript/runtime/ModuleInternalCallbacks.h
@@ -10,6 +10,13 @@ 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;
 
+// Utility to drop modules from the registry when compilation/instantiation fails
+void RemoveModuleFromRegistry(const std::string& canonicalPath);
+
+// Keep a fallback copy of the last evaluated module so could be served while reloading if needed
+void UpdateModuleFallback(v8::Isolate* isolate, const std::string& canonicalPath,
+                          v8::Local<v8::Module> module);
+
 // Resolve callback signature (with import‑assertions slot)
 v8::MaybeLocal<v8::Module> ResolveModuleCallback(
     v8::Local<v8::Context> context, v8::Local<v8::String> specifier,
diff --git a/NativeScript/runtime/ModuleInternalCallbacks.mm b/NativeScript/runtime/ModuleInternalCallbacks.mm
index 2ba4c65e..e0366333 100644
--- a/NativeScript/runtime/ModuleInternalCallbacks.mm
+++ b/NativeScript/runtime/ModuleInternalCallbacks.mm
@@ -1,13 +1,21 @@
 // ModuleInternalCallbacks.mm
 #include "ModuleInternalCallbacks.h"
+#import <Foundation/Foundation.h>
 #include <sys/stat.h>
 #include <v8.h>
+#include <dispatch/dispatch.h>
+#include <algorithm>
+#include <cstddef>
 #include <queue>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
+#include <vector>
 #include "Helpers.h"         // for tns::Exists
 #include "ModuleInternal.h"  // for LoadScript(...)
 #include "NativeScriptException.h"
+#include "HMRSupport.h"
+#include "DevFlags.h"
 #include "Runtime.h"  // for GetAppConfigValue
 #include "RuntimeConfig.h"
 
@@ -17,16 +25,6 @@
 
 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)
@@ -47,9 +45,631 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
   return moduleName.rfind("node:", 0) == 0;
 }
 
+// Normalize absolute paths so we avoid duplicate registry entries caused by
+// differing path representations (e.g. duplicate slashes, "./" segments).
+static std::string NormalizePath(const std::string& path) {
+  if (path.empty()) {
+    return path;
+  }
+
+  NSString* nsPath = [NSString stringWithUTF8String:path.c_str()];
+  if (nsPath == nil) {
+    return path;
+  }
+
+  NSString* standardized = [nsPath stringByStandardizingPath];
+  if (standardized == nil) {
+    return path;
+  }
+
+  return std::string([standardized UTF8String]);
+}
+
+// Convert a file:// URL to a filesystem path using NSURL for correct decoding.
+static std::string FileURLToPath(const std::string& url) {
+  if (url.empty()) {
+    return url;
+  }
+  if (url.rfind("file://", 0) != 0) {
+    return url; // not a file URL; return as-is
+  }
+  @autoreleasepool {
+    NSString* ns = [NSString stringWithUTF8String:url.c_str()];
+    if (!ns) {
+      return url;
+    }
+    NSURL* u = [NSURL URLWithString:ns];
+    if (u && u.isFileURL) {
+      NSString* p = [u path];
+      if (p) {
+        return std::string([[p stringByStandardizingPath] UTF8String]);
+      }
+    }
+  }
+  return url;
+}
+
+
+// Simple suffix check utility
+static inline bool EndsWith(const std::string& value, const std::string& suffix) {
+  if (suffix.size() > value.size()) return false;
+  return std::equal(suffix.rbegin(), suffix.rend(), value.rbegin());
+}
+
+// Dev-only HTTP ESM loader helpers
+
+static inline bool StartsWith(const std::string& s, const char* prefix) {
+  size_t n = strlen(prefix);
+  return s.size() >= n && s.compare(0, n, prefix) == 0;
+}
+
+
+static v8::MaybeLocal<v8::Module> CompileModuleFromSource(v8::Isolate* isolate, v8::Local<v8::Context> context,
+                                                          const std::string& code, const std::string& urlStr) {
+  v8::EscapableHandleScope hs(isolate);
+  v8::Local<v8::String> sourceText = tns::ToV8String(isolate, code.c_str());
+  v8::Local<v8::String> urlV8;
+  if (!v8::String::NewFromUtf8(isolate, urlStr.c_str(), v8::NewStringType::kNormal).ToLocal(&urlV8)) {
+    return v8::MaybeLocal<v8::Module>();
+  }
+  v8::ScriptOrigin origin(isolate, urlV8, 0, 0, false, -1, v8::Local<v8::Value>(), false, false, true);
+  v8::ScriptCompiler::Source src(sourceText, origin);
+  v8::Local<v8::Module> mod;
+  if (!v8::ScriptCompiler::CompileModule(isolate, &src).ToLocal(&mod)) {
+    return v8::MaybeLocal<v8::Module>();
+  }
+  if (mod->GetStatus() == v8::Module::kUninstantiated) {
+    if (!mod->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false)) {
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+  if (mod->GetStatus() != v8::Module::kEvaluated) {
+    if (mod->Evaluate(context).IsEmpty()) {
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+  return hs.Escape(mod);
+}
+
+// Like CompileModuleFromSource, but registers the module into g_moduleRegistry under urlStr
+// immediately after compilation and before instantiation. This allows cyclic imports to
+// resolve to the same in-progress module instance without refetching.
+static v8::MaybeLocal<v8::Module> CompileModuleFromSourceRegisterFirst(v8::Isolate* isolate,
+                                                                       v8::Local<v8::Context> context,
+                                                                       const std::string& code,
+                                                                       const std::string& urlStr) {
+  v8::EscapableHandleScope hs(isolate);
+  v8::TryCatch tc(isolate);
+  v8::Local<v8::String> sourceText = tns::ToV8String(isolate, code.c_str());
+  v8::Local<v8::String> urlV8;
+  if (!v8::String::NewFromUtf8(isolate, urlStr.c_str(), v8::NewStringType::kNormal).ToLocal(&urlV8)) {
+    return v8::MaybeLocal<v8::Module>();
+  }
+  v8::ScriptOrigin origin(isolate, urlV8, 0, 0, false, -1, v8::Local<v8::Value>(), false, false, true);
+  v8::ScriptCompiler::Source src(sourceText, origin);
+  v8::Local<v8::Module> mod;
+  if (!v8::ScriptCompiler::CompileModule(isolate, &src).ToLocal(&mod)) {
+    return v8::MaybeLocal<v8::Module>();
+  }
+  // If an entry already exists for urlStr, do not overwrite it—use that module instead
+  auto itExisting = g_moduleRegistry.find(urlStr);
+  if (itExisting != g_moduleRegistry.end()) {
+    v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+    if (!existing.IsEmpty()) {
+      return hs.Escape(existing);
+    }
+  }
+  // Register immediately so cycles see the same instance
+  g_moduleRegistry[urlStr].Reset(isolate, mod);
+  // Instantiate
+  if (mod->GetStatus() == v8::Module::kUninstantiated) {
+    if (!mod->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false)) {
+      // Cleanup on failure to avoid leaving broken entries
+      RemoveModuleFromRegistry(urlStr);
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+  // Evaluate if needed
+  if (mod->GetStatus() != v8::Module::kEvaluated) {
+    if (mod->Evaluate(context).IsEmpty()) {
+      RemoveModuleFromRegistry(urlStr);
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+  // If any exception was caught, clean and bail
+  if (tc.HasCaught()) {
+    RemoveModuleFromRegistry(urlStr);
+    return v8::MaybeLocal<v8::Module>();
+  }
+  return hs.Escape(mod);
+}
+
+// Compile-only variant for use inside ResolveModuleCallback. It compiles a v8::Module and
+// registers it under urlStr but does NOT instantiate or evaluate. V8 is currently instantiating
+// the importer and will handle instantiation of this dependency.
+static v8::MaybeLocal<v8::Module> CompileModuleForResolveRegisterOnly(v8::Isolate* isolate,
+                                                                      v8::Local<v8::Context> context,
+                                                                      const std::string& code,
+                                                                      const std::string& urlStr) {
+  v8::EscapableHandleScope hs(isolate);
+  v8::Local<v8::String> sourceText = tns::ToV8String(isolate, code.c_str());
+  v8::Local<v8::String> urlV8;
+  if (!v8::String::NewFromUtf8(isolate, urlStr.c_str(), v8::NewStringType::kNormal).ToLocal(&urlV8)) {
+    return v8::MaybeLocal<v8::Module>();
+  }
+  v8::ScriptOrigin origin(isolate, urlV8, 0, 0, false, -1, v8::Local<v8::Value>(), false, false, true);
+  v8::ScriptCompiler::Source src(sourceText, origin);
+  v8::Local<v8::Module> mod;
+  {
+    v8::TryCatch tcCompile(isolate);
+    if (!v8::ScriptCompiler::CompileModule(isolate, &src).ToLocal(&mod)) {
+      if (RuntimeConfig.IsDebug) {
+        uint64_t h = 1469598103934665603ull; // FNV-1a 64-bit
+        for (unsigned char c : code) { h ^= c; h *= 1099511628211ull; }
+        std::string snippet = code.substr(0, 600);
+        for (char& ch : snippet) { if (ch == '\n' || ch == '\r') ch = ' '; }
+        const char* classification = "unknown";
+        v8::Local<v8::Message> message = tcCompile.Message();
+        std::string msgStr = ""; std::string srcLineStr = ""; int lineNum = 0; int startCol = 0; int endCol = 0;
+        if (!message.IsEmpty()) {
+          v8::String::Utf8Value m8(isolate, message->Get()); if (*m8) msgStr = *m8;
+          lineNum = message->GetLineNumber(context).FromMaybe(0);
+          startCol = message->GetStartColumn(); endCol = message->GetEndColumn();
+          v8::MaybeLocal<v8::String> maybeLine = message->GetSourceLine(context);
+            if (!maybeLine.IsEmpty()) { v8::String::Utf8Value l8(isolate, maybeLine.ToLocalChecked()); if (*l8) srcLineStr = *l8; }
+          // Classification heuristics based on message
+          if (msgStr.find("Unexpected identifier") != std::string::npos || msgStr.find("Unexpected token") != std::string::npos) {
+            // refine unexpected token categories
+            if (msgStr.find("export") != std::string::npos && code.find("export default") == std::string::npos && code.find("__sfc__") != std::string::npos) classification = "missing-export-default";
+            else classification = "syntax";
+          } else if (msgStr.find("Cannot use import statement") != std::string::npos) {
+            classification = "wrap-error";
+          }
+        }
+        if (classification == std::string("unknown")) {
+          if (code.find("export default") == std::string::npos && code.find("__sfc__") != std::string::npos) classification = "missing-export-default";
+          else if (code.find("__sfc__") != std::string::npos && code.find("export {") == std::string::npos && code.find("export ") == std::string::npos) classification = "no-exports";
+          else if (code.find("import ") == std::string::npos && code.find("export ") == std::string::npos) classification = "not-module";
+          else if (code.find("_openBlock") != std::string::npos && code.find("openBlock") == std::string::npos) classification = "underscore-helper-unmapped";
+        }
+        // Trim srcLineStr
+        if (srcLineStr.size() > 240) srcLineStr = srcLineStr.substr(0, 240);
+        Log(@"[http-esm][compile][v8-error][%s] %s line=%d col=%d..%d hash=%llx bytes=%lu msg=%s srcLine=%s snippet=%s",
+            classification, urlStr.c_str(), lineNum, startCol, endCol, (unsigned long long)h, (unsigned long)code.size(), msgStr.c_str(), srcLineStr.c_str(), snippet.c_str());
+      }
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+  // If an entry already exists, reuse it
+  auto itExisting = g_moduleRegistry.find(urlStr);
+  if (itExisting != g_moduleRegistry.end()) {
+    v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+    if (!existing.IsEmpty()) {
+      return hs.Escape(existing);
+    }
+  }
+  g_moduleRegistry[urlStr].Reset(isolate, mod);
+  return hs.Escape(mod);
+}
+
 // ────────────────────────────────────────────────────────────────────────────
 // Simple in-process registry: maps absolute file paths → compiled Module handles
 std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleRegistry;
+static std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleFallbackRegistry;
+static std::unordered_map<std::string, v8::Global<v8::Module>> g_moduleFallbackByRelative;
+// g_modulesInFlight is defined later in this translation unit (thread_local static); no extern needed here.
+
+static bool IsDocumentsPath(const std::string& path);
+static std::vector<std::string> DocumentsPathAliases(const std::string& path);
+static std::string ExtractRelativePath(const std::string& path);
+
+// Returns the normalized iOS Documents directory (cached). Empty string if unavailable.
+static const std::string& GetDocumentsDirectory() {
+  static std::string s_docsDir; // normalized without trailing slash
+  if (s_docsDir.empty()) {
+    @autoreleasepool {
+      NSString* docsDir = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
+      if (docsDir) {
+        std::string raw = [docsDir UTF8String];
+        std::string norm = NormalizePath(raw);
+        // Remove trailing slash if NormalizePath produced one, to have canonical base form
+        if (!norm.empty() && norm.back() == '/') {
+          norm.pop_back();
+        }
+        s_docsDir = norm;
+      }
+    }
+  }
+  return s_docsDir;
+}
+
+void RemoveModuleFromRegistry(const std::string& canonicalPath) {
+  // Defensive: never operate on an anomalous/sentinel key.
+  // This covers the bare "@" anomaly and the special invalid-at stub module used by the dev HTTP loader.
+  auto isSentinel = [](const std::string& s) -> bool {
+    if (s == "@") return true;
+    // Match any path or URL that includes the invalid-at stub filename
+    return s.find("__invalid_at__.mjs") != std::string::npos;
+  };
+  if (isSentinel(canonicalPath)) {
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver][guard-v3] ignore remove for sentinel %s", canonicalPath.c_str());
+    }
+    return;
+  }
+
+  // Classification helper for diagnostics
+  auto classify = [](const std::string& s) -> const char* {
+    if (s == "@") return "sentinel:@";
+    if (s.find("__invalid_at__.mjs") != std::string::npos) return "sentinel:invalid_at";
+    bool http = StartsWith(s, "http://") || StartsWith(s, "https://");
+    if (http) {
+      if (s.find("/@ns/sfc/") != std::string::npos) return "http:sfc";
+      if (s.find("/@ns/m/") != std::string::npos) return "http:m";
+      return "http:other";
+    }
+    if (StartsWith(s, "file://")) return "file-url";
+    return "path";
+  };
+
+  if (IsScriptLoadingLogEnabled()) {
+    Log(@"[resolver][remove:pre] key=%s class=%s", canonicalPath.c_str(), classify(canonicalPath));
+  }
+
+  size_t regPre = g_moduleRegistry.size();
+  size_t fbPre = g_moduleFallbackRegistry.size();
+  size_t relPre = g_moduleFallbackByRelative.size();
+
+  auto it = g_moduleRegistry.find(canonicalPath);
+  if (it != g_moduleRegistry.end()) {
+    // Only log stale removal for non-HTTP keys to avoid noisy dev HTTP churn.
+    bool isHttpKey = StartsWith(canonicalPath, "http://") || StartsWith(canonicalPath, "https://");
+    if (IsScriptLoadingLogEnabled() && !isHttpKey) {
+      Log(@"[resolver] removing stale module %@", [NSString stringWithUTF8String:canonicalPath.c_str()]);
+    }
+    it->second.Reset();
+    g_moduleRegistry.erase(it);
+  }
+  else if (IsScriptLoadingLogEnabled()) {
+    Log(@"[resolver][remove:miss] key not found, proceed to clear fallbacks (%s)", canonicalPath.c_str());
+  }
+  // Also clear fallbacks linked to this path
+  auto fb = g_moduleFallbackRegistry.find(canonicalPath);
+  if (fb != g_moduleFallbackRegistry.end()) {
+    fb->second.Reset();
+    g_moduleFallbackRegistry.erase(fb);
+  }
+  std::string rel = ExtractRelativePath(canonicalPath);
+  if (!rel.empty()) {
+    auto fbr = g_moduleFallbackByRelative.find(rel);
+    if (fbr != g_moduleFallbackByRelative.end()) {
+      fbr->second.Reset();
+      g_moduleFallbackByRelative.erase(fbr);
+    }
+  }
+
+  if (IsScriptLoadingLogEnabled()) {
+    size_t regPost = g_moduleRegistry.size();
+    size_t fbPost = g_moduleFallbackRegistry.size();
+    size_t relPost = g_moduleFallbackByRelative.size();
+    Log(@"[resolver][remove:post] reg %lu→%lu fb %lu→%lu rel %lu→%lu",
+        (unsigned long)regPre, (unsigned long)regPost,
+        (unsigned long)fbPre, (unsigned long)fbPost,
+        (unsigned long)relPre, (unsigned long)relPost);
+  }
+}
+
+void UpdateModuleFallback(v8::Isolate* isolate, const std::string& canonicalPath,
+                          v8::Local<v8::Module> module) {
+  auto fallbackIt = g_moduleFallbackRegistry.find(canonicalPath);
+  if (fallbackIt != g_moduleFallbackRegistry.end()) {
+    fallbackIt->second.Reset();
+  }
+  if (!module.IsEmpty()) {
+    g_moduleFallbackRegistry[canonicalPath].Reset(isolate, module);
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver] fallback updated for %s from evaluated module",
+          canonicalPath.c_str());
+    }
+
+    std::string relative = ExtractRelativePath(canonicalPath);
+    if (!relative.empty()) {
+      auto relativeIt = g_moduleFallbackByRelative.find(relative);
+      if (relativeIt != g_moduleFallbackByRelative.end()) {
+        relativeIt->second.Reset();
+      }
+      g_moduleFallbackByRelative[relative].Reset(isolate, module);
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[resolver] fallback relative updated for %s", relative.c_str());
+      }
+    }
+
+    if (IsDocumentsPath(canonicalPath)) {
+      for (const std::string& appAlias : DocumentsPathAliases(canonicalPath)) {
+        auto aliasIt = g_moduleFallbackRegistry.find(appAlias);
+        if (aliasIt != g_moduleFallbackRegistry.end()) {
+          aliasIt->second.Reset();
+        }
+        g_moduleFallbackRegistry[appAlias].Reset(isolate, module);
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[resolver] fallback alias updated for %s (alias of %s)", appAlias.c_str(),
+              canonicalPath.c_str());
+        }
+
+        std::string aliasRelative = ExtractRelativePath(appAlias);
+        if (!aliasRelative.empty()) {
+          auto aliasRelativeIt = g_moduleFallbackByRelative.find(aliasRelative);
+          if (aliasRelativeIt != g_moduleFallbackByRelative.end()) {
+            aliasRelativeIt->second.Reset();
+          }
+          g_moduleFallbackByRelative[aliasRelative].Reset(isolate, module);
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] fallback relative updated for %s (alias of %s)",
+                aliasRelative.c_str(), canonicalPath.c_str());
+          }
+        }
+      }
+    }
+  }
+}
+
+// Track active resolution stack to detect and short-circuit self-recursive module loads
+static thread_local std::vector<std::string> g_moduleResolutionStack;
+static thread_local std::unordered_map<std::string, size_t> g_moduleReentryCounts;
+static thread_local std::unordered_map<std::string, std::unordered_set<std::string>>
+  g_moduleReentryParents;
+static thread_local std::unordered_map<std::string, std::string> g_modulePrimaryImporters;
+static thread_local std::unordered_set<std::string> g_modulesInFlight;
+static thread_local std::unordered_set<std::string> g_modulesPendingReset;
+static constexpr size_t kMaxModuleReentryCount = 256;
+// Waiters: module path -> list of Promise resolvers waiting for completion (instantiated/evaluated or errored)
+static std::unordered_map<std::string, std::vector<v8::Global<v8::Promise::Resolver>>> g_moduleWaiters;
+// Dynamic HTTP import waiters: resolve to module namespace when available.
+static thread_local std::unordered_map<std::string, std::vector<v8::Global<v8::Promise::Resolver>>> g_httpDynamicWaiters;
+
+// Bulk await state + callbacks (non-capturing for V8 function compatibility)
+struct BulkWaitState {
+  size_t remaining;
+  bool rejected;
+  v8::Global<v8::Promise::Resolver> master;
+};
+
+static bool IsDocumentsPath(const std::string& path) {
+  if (path.empty()) return false;
+  const std::string& docs = GetDocumentsDirectory();
+  if (docs.empty()) {
+    // Fallback heuristic (legacy) if we cannot resolve the real Documents dir.
+    return path.find("/Documents/") != std::string::npos || path.find("\\Documents\\") != std::string::npos;
+  }
+  std::string normalizedInput = NormalizePath(path);
+  // Fast exact match
+  if (normalizedInput == docs) return true;
+  // Compare with prefix docs + '/'
+  std::string docsPrefix = docs + "/";
+  if (normalizedInput.rfind(docsPrefix, 0) == 0) return true;
+  return false;
+}
+
+static std::vector<std::string> DocumentsPathAliases(const std::string& path) {
+  const std::string marker = "/Documents/";
+  size_t pos = path.find(marker);
+  if (pos == std::string::npos) {
+    return {};
+  }
+
+  std::string relative = path.substr(pos + marker.size());
+  if (relative.empty()) {
+    return {};
+  }
+
+  std::vector<std::string> candidates;
+  auto tryPush = [&candidates](const std::string& p) {
+    if (!p.empty()) {
+      std::string normalized = NormalizePath(p);
+      if (std::find(candidates.begin(), candidates.end(), normalized) == candidates.end()) {
+        candidates.push_back(normalized);
+      }
+    }
+  };
+
+  tryPush(RuntimeConfig.ApplicationPath + "/" + relative);
+  tryPush(RuntimeConfig.ApplicationPath + "/app/" + relative);
+
+  return candidates;
+}
+
+static std::string ExtractRelativePath(const std::string& path) {
+  const std::string documentsMarker = "/Documents/";
+  size_t docPos = path.find(documentsMarker);
+  if (docPos != std::string::npos) {
+    return path.substr(docPos + documentsMarker.size());
+  }
+
+  std::string appPrefix = NormalizePath(RuntimeConfig.ApplicationPath);
+  if (!appPrefix.empty()) {
+    // Direct prefix
+    std::string directPrefix = appPrefix + "/";
+    if (path.rfind(directPrefix, 0) == 0) {
+      return path.substr(directPrefix.size());
+    }
+
+    // With bundled app folder (…/app/...)
+    std::string appFolderPrefix = appPrefix + "/app/";
+    if (path.rfind(appFolderPrefix, 0) == 0) {
+      return path.substr(appFolderPrefix.size());
+    }
+  }
+
+  return "";
+}
+
+static const char* ModuleStatusToString(v8::Module::Status status) {
+  switch (status) {
+    case v8::Module::kUninstantiated:
+      return "Uninstantiated";
+    case v8::Module::kInstantiating:
+      return "Instantiating";
+    case v8::Module::kInstantiated:
+      return "Instantiated";
+    case v8::Module::kEvaluating:
+      return "Evaluating";
+    case v8::Module::kEvaluated:
+      return "Evaluated";
+    case v8::Module::kErrored:
+      return "Errored";
+  }
+  return "Unknown";
+}
+
+namespace {
+
+struct ResolutionStackGuard {
+  ResolutionStackGuard(v8::Isolate* isolate, std::vector<std::string>& stack,
+                       const std::string& entry)
+      : isolate_(isolate), stack_(stack), entry_(entry), active_(true) {
+    stack_.push_back(entry_);
+    g_moduleReentryCounts[entry_] = 0;
+    g_moduleReentryParents.erase(entry_);
+    if (stack_.size() > 1) {
+      g_modulePrimaryImporters[entry_] = stack_[stack_.size() - 2];
+    } else {
+      g_modulePrimaryImporters.erase(entry_);
+    }
+    g_modulesInFlight.insert(entry_);
+    g_modulesPendingReset.erase(entry_);
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver][stack] push (%lu) %s",
+          static_cast<unsigned long>(stack_.size()), entry_.c_str());
+      if (stack_.size() > 1) {
+        Log(@"  ↳ parent: %s", stack_[stack_.size() - 2].c_str());
+      }
+    }
+  }
+
+  ~ResolutionStackGuard() {
+    if (active_ && !stack_.empty()) {
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[resolver][stack] pop (%lu) %s",
+            static_cast<unsigned long>(stack_.size()), entry_.c_str());
+      }
+      g_moduleReentryCounts.erase(entry_);
+      g_moduleReentryParents.erase(entry_);
+      g_modulePrimaryImporters.erase(entry_);
+      g_modulesInFlight.erase(entry_);
+      // Determine final status for waiter resolution / rejection
+      v8::Module::Status finalStatus = v8::Module::kErrored;
+      auto regIt = g_moduleRegistry.find(entry_);
+      if (regIt != g_moduleRegistry.end()) {
+        v8::Local<v8::Module> m = regIt->second.Get(isolate_);
+        if (!m.IsEmpty()) {
+          finalStatus = m->GetStatus();
+        }
+      }
+      bool isError = finalStatus == v8::Module::kErrored;
+      auto waitIt = g_moduleWaiters.find(entry_);
+      if (waitIt != g_moduleWaiters.end()) {
+        std::vector<v8::Global<v8::Promise::Resolver>> resolvers;
+        resolvers.swap(waitIt->second);
+        g_moduleWaiters.erase(waitIt);
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[resolver][await] resolving %lu waiter(s) for %s status=%s",
+              (unsigned long)resolvers.size(), entry_.c_str(), ModuleStatusToString(finalStatus));
+        }
+        for (auto &resGlobal : resolvers) {
+          v8::Local<v8::Promise::Resolver> r = resGlobal.Get(isolate_);
+          if (!r.IsEmpty()) {
+            if (isError) {
+              v8::Local<v8::String> errMsg = tns::ToV8String(isolate_, ("Module evaluation failed: " + entry_).c_str());
+              v8::Local<v8::Value> errObj = v8::Exception::Error(errMsg);
+              r->Reject(isolate_->GetCurrentContext(), errObj).FromMaybe(false);
+            } else {
+              if (IsScriptLoadingLogEnabled()) {
+                Log(@"[resolver][await] module now evaluated; fulfilling waiter: %s", entry_.c_str());
+              }
+              r->Resolve(isolate_->GetCurrentContext(), v8::Undefined(isolate_)).FromMaybe(false);
+            }
+          }
+          resGlobal.Reset();
+        }
+      }
+      stack_.pop_back();
+      auto pendingIt = g_modulesPendingReset.find(entry_);
+      if (pendingIt != g_modulesPendingReset.end()) {
+        bool removedFromRegistry = false;
+        auto it = g_moduleRegistry.find(entry_);
+        if (it != g_moduleRegistry.end()) {
+          v8::Local<v8::Module> module = it->second.Get(isolate_);
+          v8::Module::Status status = module.IsEmpty() ? v8::Module::kErrored : module->GetStatus();
+          if (status != v8::Module::kEvaluated && status != v8::Module::kErrored) {
+            if (IsScriptLoadingLogEnabled()) {
+              Log(@"[resolver] dropping incomplete module after unwind %s (status=%s)",
+                  entry_.c_str(), ModuleStatusToString(status));
+            }
+            RemoveModuleFromRegistry(entry_);
+            removedFromRegistry = true;
+          } else if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] module %s marked for reset completed evaluation (status=%s) – keeping for next importer",
+                entry_.c_str(), ModuleStatusToString(status));
+          }
+        } else if (IsScriptLoadingLogEnabled()) {
+          Log(@"[resolver] pending reset module %s already removed from registry", entry_.c_str());
+        }
+
+        g_modulesPendingReset.erase(pendingIt);
+        if (!removedFromRegistry && IsScriptLoadingLogEnabled()) {
+          Log(@"[resolver] cleared pending reset flag for %s", entry_.c_str());
+        }
+      }
+
+      auto fallbackIt = g_moduleFallbackRegistry.find(entry_);
+      auto activeIt = g_moduleRegistry.find(entry_);
+      v8::Local<v8::Module> activeModule;
+      v8::Module::Status activeStatus = v8::Module::kErrored;
+      bool hasActiveModule = false;
+      if (activeIt != g_moduleRegistry.end()) {
+        activeModule = activeIt->second.Get(isolate_);
+        activeStatus = activeModule.IsEmpty() ? v8::Module::kErrored : activeModule->GetStatus();
+        hasActiveModule = true;
+      }
+
+      if (hasActiveModule) {
+        if (activeStatus == v8::Module::kEvaluated) {
+          g_moduleFallbackRegistry[entry_].Reset(isolate_, activeModule);
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] updated fallback module for %s after successful evaluation",
+                entry_.c_str());
+          }
+        } else if (activeStatus == v8::Module::kErrored && fallbackIt != g_moduleFallbackRegistry.end()) {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] retaining fallback module for %s because active evaluation errored",
+                entry_.c_str());
+          }
+        }
+      } else if (fallbackIt != g_moduleFallbackRegistry.end()) {
+        v8::Local<v8::Module> fallback = fallbackIt->second.Get(isolate_);
+        if (!fallback.IsEmpty()) {
+          g_moduleRegistry[entry_].Reset(isolate_, fallback);
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] restored fallback module for %s after in-flight reload failed",
+                entry_.c_str());
+          }
+        }
+        // Keep the fallback entry so that subsequent imports still have a stable copy.
+      }
+    }
+  }
+
+  // Disable automatic pop if ownership gets transferred (not used currently, but keeps guard safe)
+  void Release() { active_ = false; }
+
+ private:
+  v8::Isolate* isolate_;
+  std::vector<std::string>& stack_;
+  std::string entry_;
+  bool active_;
+};
+
+}  // namespace
 
 // Callback invoked by V8 to resolve `import X from 'specifier';`
 v8::MaybeLocal<v8::Module> ResolveModuleCallback(v8::Local<v8::Context> context,
@@ -65,10 +685,100 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     return v8::MaybeLocal<v8::Module>();
   }
 
+  // Normalize malformed HTTP(S) schemes that sometimes appear as 'http:/host' (single slash)
+  // due to upstream path joins or standardization. This ensures our HTTP loader fast-path
+  // is used and avoids filesystem fallback attempts like '/app/http:/host'.
+  if (spec.rfind("http:/", 0) == 0 && spec.rfind("http://", 0) != 0) {
+    spec.insert(5, "/"); // http:/ -> http://
+  } else if (spec.rfind("https:/", 0) == 0 && spec.rfind("https://", 0) != 0) {
+    spec.insert(6, "/"); // https:/ -> https://
+  }
+
+  if (IsScriptLoadingLogEnabled()) {
+    Log(@"[resolver][spec] %s", spec.c_str());
+  }
+
+  // Normalize '@/' alias to '/src/' for static imports (mirrors client dynamic import normalization)
+  if (spec.rfind("@/", 0) == 0) {
+    std::string orig = spec;
+    spec = std::string("/src/") + spec.substr(2);
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver][normalize] %@ -> %@", [NSString stringWithUTF8String:orig.c_str()], [NSString stringWithUTF8String:spec.c_str()]);
+    }
+  }
+  // Guard against a bare '@' spec showing up (invalid); return empty to avoid poisoning registry with '@'
+  if (spec == "@") {
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver][normalize] ignoring invalid '@' static spec");
+    }
+    return v8::MaybeLocal<v8::Module>();
+  }
+
+  // ── Early absolute-HTTP fast path ─────────────────────────────
+  // If the specifier itself is an absolute HTTP(S) URL, resolve it immediately via
+  // the HTTP dev loader and return before any filesystem candidate logic runs.
+  if (StartsWith(spec, "http://") || StartsWith(spec, "https://")) {
+    std::string key = CanonicalizeHttpUrlKey(spec);
+    // Added instrumentation for unified phase logging
+    Log(@"[http-esm][compile][begin] %s", key.c_str());
+    // Reuse compiled module if present and healthy
+    auto itExisting = g_moduleRegistry.find(key);
+    if (itExisting != g_moduleRegistry.end()) {
+      v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+      if (!existing.IsEmpty()) {
+        v8::Module::Status st = existing->GetStatus();
+        if (st == v8::Module::kErrored) {
+          if (IsScriptLoadingLogEnabled()) { 
+            Log(@"[resolver][http-cache] dropping errored %s", key.c_str()); 
+          }
+          RemoveModuleFromRegistry(key);
+        } else {
+          if (IsScriptLoadingLogEnabled()) { 
+            Log(@"[http-esm][compile][cache-hit] %s", key.c_str());
+          }
+          return v8::MaybeLocal<v8::Module>(existing);
+        }
+      }
+    }
+    std::string body; std::string ct; int status = 0;
+    if (HttpFetchText(spec, body, ct, status) && !body.empty()) {
+      v8::MaybeLocal<v8::Module> m = CompileModuleForResolveRegisterOnly(isolate, context, body, key);
+      if (!m.IsEmpty()) {
+        v8::Local<v8::Module> mod;
+        if (m.ToLocal(&mod)) {
+          if (IsScriptLoadingLogEnabled()) { 
+            Log(@"[http-esm][compile][ok] %s bytes=%zu", key.c_str(), body.size());
+          }
+          return m;
+        }
+      }
+      if (IsScriptLoadingLogEnabled()) { 
+        Log(@"[http-esm][compile][fail][unknown] %s bytes=%zu", key.c_str(), body.size());
+      }
+      if (RuntimeConfig.IsDebug) {
+        std::string msg = "HTTP import compile failed: " + spec;
+        isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())));
+        return v8::MaybeLocal<v8::Module>();
+      }
+    } else {
+      if (RuntimeConfig.IsDebug) {
+        std::string msg = "HTTP import failed: " + spec + " (status=" + std::to_string(status) + ")";
+        isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())));
+        return v8::MaybeLocal<v8::Module>();
+      }
+      if (IsScriptLoadingLogEnabled()) { 
+        Log(@"[http-esm][compile][fail][network] %s status=%d", key.c_str(), status);
+      }
+    }
+    // In release, fall through to normal path if HTTP load failed
+  }
+
   // 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());
+    if (IsScriptLoadingLogEnabled()) { 
+      Log("ResolveModuleCallback: Worker trying to resolve '%s'\n", spec.c_str());
+    }
   }
 
   // 2) Find which filepath the referrer was compiled under
@@ -102,6 +812,73 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
   size_t slash = referrerPath.find_last_of("/\\");
   std::string baseDir = slash == std::string::npos ? "" : referrerPath.substr(0, slash + 1);
 
+  // If the referrer itself was compiled from an HTTP(S) URL, then any relative
+  // ("./" or "../") or root-absolute ("/") specifiers should resolve against the
+  // referrer's URL, not the local filesystem. Mirror browser behavior by using NSURL
+  // to construct the absolute URL, then return an HTTP-loaded module immediately.
+  bool referrerIsHttp = (!referrerPath.empty() && (StartsWith(referrerPath, "http://") || StartsWith(referrerPath, "https://")));
+  bool specIsRootAbs = !spec.empty() && spec[0] == '/';
+  if (referrerIsHttp && (specIsRelative || specIsRootAbs)) {
+    std::string resolvedHttp;
+    @autoreleasepool {
+      NSString* baseStr = [NSString stringWithUTF8String:referrerPath.c_str()];
+      NSString* specStr = [NSString stringWithUTF8String:spec.c_str()];
+      if (baseStr && specStr) {
+        NSURL* baseURL = [NSURL URLWithString:baseStr];
+        NSURL* rel = [NSURL URLWithString:specStr relativeToURL:baseURL];
+        NSURL* absURL = [rel absoluteURL];
+        if (absURL) {
+          NSString* absStr = [absURL absoluteString];
+          if (absStr) {
+            resolvedHttp = std::string([absStr UTF8String] ?: "");
+          }
+        }
+      }
+    }
+    if (!resolvedHttp.empty() && (StartsWith(resolvedHttp, "http://") || StartsWith(resolvedHttp, "https://"))) {
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[resolver][http-rel] base=%s spec=%s -> %s", referrerPath.c_str(), spec.c_str(), resolvedHttp.c_str());
+      }
+      std::string key = CanonicalizeHttpUrlKey(resolvedHttp);
+      // If we've already compiled this URL, return it immediately
+      auto itExisting = g_moduleRegistry.find(key);
+      if (itExisting != g_moduleRegistry.end()) {
+        v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+        if (!existing.IsEmpty()) {
+          v8::Module::Status st = existing->GetStatus();
+          if (st == v8::Module::kErrored) {
+            if (IsScriptLoadingLogEnabled()) {
+              Log(@"[resolver][http-cache] dropping errored %s", key.c_str());
+            }
+            RemoveModuleFromRegistry(key);
+          } else {
+            if (IsScriptLoadingLogEnabled()) {
+              Log(@"[resolver][http-cache] hit %s", key.c_str());
+            }
+            return v8::MaybeLocal<v8::Module>(existing);
+          }
+        }
+      }
+      std::string body; std::string ct; int status = 0;
+      if (HttpFetchText(resolvedHttp, body, ct, status) && !body.empty()) {
+        v8::MaybeLocal<v8::Module> m = CompileModuleForResolveRegisterOnly(isolate, context, body, key);
+        if (!m.IsEmpty()) {
+          v8::Local<v8::Module> mod;
+          if (m.ToLocal(&mod)) {
+            return m;
+          }
+        }
+      } else {
+        if (RuntimeConfig.IsDebug) {
+          std::string msg = "HTTP import failed: " + resolvedHttp + " (status=" + std::to_string(status) + ")";
+          isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())));
+          return v8::MaybeLocal<v8::Module>();
+        }
+      }
+      // In release, fall through to normal resolution if fetch failed
+    }
+  }
+
   // 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
@@ -116,13 +893,28 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
   if (!spec.empty() && spec[0] == '.') {
     // Relative import (./ or ../)
-    std::string cleanSpec = spec.rfind("./", 0) == 0 ? spec.substr(2) : spec;
-    std::string candidate = baseDir + cleanSpec;
-    candidateBases.push_back(candidate);
+      std::string cleanSpec = spec.rfind("./", 0) == 0 ? spec.substr(2) : spec;
+      // Join baseDir and spec using NSString to collapse dot segments reliably
+      @autoreleasepool {
+        NSString* nsBase = [NSString stringWithUTF8String:baseDir.c_str()];
+        NSString* nsRel = [NSString stringWithUTF8String:cleanSpec.c_str()];
+        if (nsBase && nsRel) {
+          NSString* joined = [nsBase stringByAppendingPathComponent:nsRel];
+          NSString* std = [joined stringByStandardizingPath];
+          if (std) {
+            std::string candidate = std.UTF8String;
+            candidate = NormalizePath(candidate);
+            candidateBases.push_back(candidate);
+            if (IsScriptLoadingLogEnabled()) {
+              Log(@"[resolver][normalize-rel] %s + %s -> %s", baseDir.c_str(), cleanSpec.c_str(), candidate.c_str());
+            }
+          }
+        }
+      }
 
     if (IsScriptLoadingLogEnabled()) {
       Log(@"[resolver] Relative import: '%s' + '%s' -> '%s'", baseDir.c_str(), cleanSpec.c_str(),
-          candidate.c_str());
+          candidateBases.empty() ? "<none>" : candidateBases.back().c_str());
     }
   } else if (spec.rfind("file://", 0) == 0) {
     // Absolute file URL, e.g. file:///app/path/to/chunk.mjs
@@ -137,29 +929,60 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
       tailNoApp = tail.substr(appPrefix.size());
     }
     // Candidate that keeps /app/ prefix stripped
-    std::string baseNoApp = RuntimeConfig.ApplicationPath + "/" + tailNoApp;
+    std::string baseNoApp = NormalizePath(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 '/'
+    std::string baseWithApp = NormalizePath(RuntimeConfig.ApplicationPath + tail);
     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;
+    std::string base = NormalizePath(RuntimeConfig.ApplicationPath + "/" + tail);
     candidateBases.push_back(base);
 
+    // Also try ApplicationPath/app for projects that bundle JS under an app folder
+    std::string baseApp = NormalizePath(RuntimeConfig.ApplicationPath + "/app/" + tail);
+    if (baseApp != base) {
+      candidateBases.push_back(baseApp);
+    }
+
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver][tilde] spec=%s base=%s appBase=%s",
+          spec.c_str(), base.c_str(), baseApp.c_str());
+    }
+
     // Debug: Log tilde resolution for worker context
     if (cache->isWorker) {
-      printf("ResolveModuleCallback: Worker resolving tilde path '%s' -> '%s'\n", spec.c_str(),
+      if (IsScriptLoadingLogEnabled()) {
+        Log("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);
+    // Absolute path within the bundle (e.g., /app/..., /src/...)
+    // Resolve against the application directory and try both with and without the '/app' prefix.
+    std::string base = NormalizePath(RuntimeConfig.ApplicationPath + spec);
+    candidateBases.push_back(base);
+
+    const std::string appPrefix = "/app/";
+    if (spec.rfind(appPrefix, 0) == 0) {
+      std::string tailNoApp = spec.substr(appPrefix.size() - 1); // keep leading '/'
+      // spec starts with '/app/...', so tailNoApp becomes '/...'
+      std::string baseNoApp = NormalizePath(RuntimeConfig.ApplicationPath + tailNoApp);
+      if (baseNoApp != base) {
+        candidateBases.push_back(baseNoApp);
+      }
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[resolver][abs] spec=%s base=%s baseNoApp=%s",
+            spec.c_str(), base.c_str(), baseNoApp.c_str());
+      }
+    } else if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver][abs] spec=%s base=%s", spec.c_str(), base.c_str());
+    }
   } else {
     // Bare specifier – resolve relative to the application root directory
-    std::string base = RuntimeConfig.ApplicationPath + "/" + spec;
+    std::string base = NormalizePath(RuntimeConfig.ApplicationPath + "/" + spec);
     candidateBases.push_back(base);
 
     // Additional heuristic: bundlers often encode path separators as underscores in
@@ -167,7 +990,7 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     // 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;
+    std::string baseSlashes = NormalizePath(RuntimeConfig.ApplicationPath + "/" + withSlashes);
     if (baseSlashes != base) {
       candidateBases.push_back(baseSlashes);
     }
@@ -176,10 +999,73 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
   // We'll iterate these bases and attempt to resolve to an actual file
   std::string absPath;
 
+  // If the specifier is an HTTP(S) URL, fetch via HTTP loader and return
+  if (StartsWith(spec, "http://") || StartsWith(spec, "https://")) {
+    std::string key = CanonicalizeHttpUrlKey(spec);
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[http-esm][compile][begin] %s", key.c_str());
+    }
+    // If we've already compiled this URL, return it immediately
+    auto itExisting = g_moduleRegistry.find(key);
+    if (itExisting != g_moduleRegistry.end()) {
+      v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+      if (!existing.IsEmpty()) {
+        v8::Module::Status st = existing->GetStatus();
+        if (st == v8::Module::kErrored) {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver][http-cache] dropping errored %s", key.c_str());
+          }
+          RemoveModuleFromRegistry(key);
+          // proceed to refetch/compile below
+        } else {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[http-esm][compile][cache-hit] %s", key.c_str());
+          }
+          return v8::MaybeLocal<v8::Module>(existing);
+        }
+      }
+    }
+    std::string body; std::string ct; int status = 0;
+    if (HttpFetchText(spec, body, ct, status) && !body.empty()) {
+      // IMPORTANT: During static resolution, do not instantiate/evaluate here.
+      // V8 is in the middle of instantiation of the importer and will instantiate this dependency.
+      v8::MaybeLocal<v8::Module> m = CompileModuleForResolveRegisterOnly(isolate, context, body, key);
+      if (!m.IsEmpty()) {
+        v8::Local<v8::Module> mod;
+        if (m.ToLocal(&mod)) {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[http-esm][compile][ok] %s bytes=%zu", key.c_str(), body.size());
+          }
+          return m;
+        }
+      }
+      // Compile failed: avoid misleading filesystem fallback in debug; surface error clearly
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[http-esm][compile][fail][unknown] %s bytes=%zu", key.c_str(), body.size());
+      }
+      if (RuntimeConfig.IsDebug) {
+        std::string msg = "HTTP import compile failed: " + spec;
+        isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())));
+        return v8::MaybeLocal<v8::Module>();
+      }
+    } else {
+      if (RuntimeConfig.IsDebug) {
+        std::string msg = "HTTP import failed: " + spec + " (status=" + std::to_string(status) + ")";
+        isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())));
+      }
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[http-esm][compile][fail][network] %s status=%d", key.c_str(), status);
+      }
+      // Regardless of build, do not fall back to filesystem for absolute HTTP specifiers in dev.
+      return v8::MaybeLocal<v8::Module>();
+    }
+  }
+
   // Utility: returns true iff `p` exists AND is a regular file (not directory)
   auto isFile = [](const std::string& p) -> bool {
+    std::string normalized = NormalizePath(p);
     struct stat st;
-    if (stat(p.c_str(), &st) != 0) {
+    if (stat(normalized.c_str(), &st) != 0) {
       return false;
     }
     return (st.st_mode & S_IFMT) == S_IFREG;
@@ -196,7 +1082,57 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
   //  ── Resolution attempts ───────────────────────────────────────
   // Iterate base candidates until we find a file match
   for (const std::string& baseCandidate : candidateBases) {
-    absPath = baseCandidate;
+    absPath = NormalizePath(baseCandidate);
+
+    // If a candidate accidentally embeds a collapsed HTTP URL like '/app/http:/host/...',
+    // reconstruct the HTTP URL and resolve via the HTTP loader instead of touching the filesystem.
+    auto rerouteHttpIfEmbedded = [&](const std::string& p) -> bool {
+      size_t pos1 = p.find("/http:/");
+      size_t pos2 = p.find("/https:/");
+      size_t pos = std::min(pos1 == std::string::npos ? SIZE_MAX : pos1,
+                            pos2 == std::string::npos ? SIZE_MAX : pos2);
+      if (pos == SIZE_MAX) return false;
+      std::string tail = p.substr(pos + 1); // 'http:/...' or 'https:/...'
+      if (StartsWith(tail, "http:/") && !StartsWith(tail, "http://")) {
+        tail.insert(5, "/");
+      } else if (StartsWith(tail, "https:/") && !StartsWith(tail, "https://")) {
+        tail.insert(6, "/");
+      }
+      if (!(StartsWith(tail, "http://") || StartsWith(tail, "https://"))) return false;
+      if (IsScriptLoadingLogEnabled()) { Log(@"[resolver][http-embedded] %s -> %s", p.c_str(), tail.c_str()); }
+      std::string key = CanonicalizeHttpUrlKey(tail);
+      auto itExisting = g_moduleRegistry.find(key);
+      if (itExisting != g_moduleRegistry.end()) {
+        v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+        if (!existing.IsEmpty() && existing->GetStatus() != v8::Module::kErrored) {
+          return !v8::MaybeLocal<v8::Module>(existing).IsEmpty();
+        }
+      }
+      std::string body; std::string ct; int status = 0;
+      if (HttpFetchText(tail, body, ct, status) && !body.empty()) {
+        v8::MaybeLocal<v8::Module> m = CompileModuleForResolveRegisterOnly(isolate, context, body, key);
+        if (!m.IsEmpty()) {
+          v8::Local<v8::Module> mod; if (m.ToLocal(&mod)) { return true; }
+        }
+      }
+      if (RuntimeConfig.IsDebug) {
+        std::string msg = "HTTP embedded import failed: " + tail;
+        isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())));
+      }
+      return false;
+    };
+    if (rerouteHttpIfEmbedded(absPath)) {
+      // Return the module from registry; V8 will pick it up
+      std::string key = CanonicalizeHttpUrlKey(absPath.substr(absPath.find("http")));
+      auto itExisting = g_moduleRegistry.find(key);
+      if (itExisting != g_moduleRegistry.end()) {
+        v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+        if (!existing.IsEmpty()) {
+          return v8::MaybeLocal<v8::Module>(existing);
+        }
+      }
+      // If not present, fall through to normal checks
+    }
 
     bool existsNow = isFile(absPath);
     if (IsScriptLoadingLogEnabled()) {
@@ -208,7 +1144,7 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
       const char* exts[] = {".mjs", ".js"};
       bool found = false;
       for (const char* e : exts) {
-        std::string cand = withExt(absPath, e);
+        std::string cand = NormalizePath(withExt(absPath, e));
         if (isFile(cand)) {
           absPath = cand;
           found = true;
@@ -219,7 +1155,7 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
         // 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;
+          std::string cand = NormalizePath(absPath + idx);
           if (isFile(cand)) {
             absPath = cand;
             found = true;
@@ -240,6 +1176,47 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
   // 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)) {
+    // Generic dynamic fetch mirror fallback: if spec is absolute (starts with '/') and not in node_modules,
+    // attempt Documents/_ns_hmr + spec (normalized) + .mjs. This does not assume any project folder names.
+    if (!spec.empty() && spec[0] == '/' && spec.find("node_modules") == std::string::npos && spec.find("_ns_hmr") == std::string::npos) {
+      // Generic dynamic fetch mirror fallback: only for logical app-root paths (e.g., /src, /core, /app, /utils, /components)
+      // Avoid misclassifying arbitrary filesystem absolute paths.
+      bool looksLogicalApp = false;
+      if (!spec.empty() && spec[0] == '/' && spec.find("node_modules") == std::string::npos && spec.find("_ns_hmr") == std::string::npos) {
+        if (spec.rfind("/src/", 0) == 0 || spec.rfind("/core/", 0) == 0 || spec.rfind("/app/", 0) == 0 ||
+            spec.rfind("/utils/", 0) == 0 || spec.rfind("/components/", 0) == 0) {
+          looksLogicalApp = true;
+        }
+      }
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[resolver][mirror-consider] spec=%s looksApp=%s", spec.c_str(), looksLogicalApp ? "true" : "false");
+      }
+      if (looksLogicalApp) {
+        std::string logical = spec; // e.g. /whatever/path/file.ts
+        std::string baseNoQuery = logical;
+        size_t qpos = baseNoQuery.find_first_of("?#");
+        if (qpos != std::string::npos) baseNoQuery = baseNoQuery.substr(0, qpos);
+        // Strip a terminal .ts/.js when constructing mirror .mjs candidate
+        std::string noExt = baseNoQuery;
+        if (EndsWith(noExt, ".ts") || EndsWith(noExt, ".js")) {
+          noExt = noExt.substr(0, noExt.size() - 3);
+        }
+        // Use cached Documents directory (generic dynamic fetch mirror fallback)
+        const std::string& docsRootBase = GetDocumentsDirectory();
+        std::string mirrorMjs;
+        if (!docsRootBase.empty()) {
+          mirrorMjs = docsRootBase + "/_ns_hmr" + noExt + ".mjs"; // canonical transform output location
+        }
+        if (isFile(mirrorMjs)) {
+          absPath = mirrorMjs;
+          if (IsScriptLoadingLogEnabled()) { Log(@"[resolver][mirror] generic %s -> %s", spec.c_str(), absPath.c_str()); }
+        }
+      }
+    }
+  }
+  absPath = NormalizePath(absPath);
+
   if (!isFile(absPath)) {
     // Debug: Log resolution failure for worker context
     if (cache->isWorker) {
@@ -251,7 +1228,7 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     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";
+      std::string builtinPath = NormalizePath(RuntimeConfig.ApplicationPath + "/" + builtinName + ".mjs");
 
       // Check if a polyfill file exists
       if (!isFile(builtinPath)) {
@@ -314,15 +1291,17 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
         absPath = builtinPath;
       }
     } else if (IsLikelyOptionalModule(spec)) {
-      // Create a placeholder file on disk that bundler can resolve to
+      // Treat bare specifiers as optional modules by creating a placeholder ES module that
+      // throws on property access. This lets applications guard optional imports at runtime
+      // without crashing during startup, especially in development.
       std::string appPath = RuntimeConfig.ApplicationPath;
-      std::string placeholderPath = appPath + "/" + spec + ".mjs";
+      std::string placeholderPath = NormalizePath(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"
+        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"
@@ -344,11 +1323,11 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
           // File created successfully, now resolve it normally
           absPath = placeholderPath;
         } else {
-          // Failed to create file, fall back to throwing error
+          // Failed to create file. In debug, avoid throwing to keep dev sessions alive; in release
+          // throw to surface the missing optional module.
           std::string msg = "Cannot find module " + spec + " (tried " + absPath + ")";
           if (RuntimeConfig.IsDebug) {
             Log(@"Debug mode - Optional module placeholder creation failed: %s", msg.c_str());
-            // Return empty instead of crashing in debug mode
             return v8::MaybeLocal<v8::Module>();
           } else {
             isolate->ThrowException(v8::Exception::Error(tns::ToV8String(isolate, msg)));
@@ -451,11 +1430,275 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
   // 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());
+    v8::Local<v8::Module> existing = it->second.Get(isolate);
+    v8::Module::Status status = existing.IsEmpty() ? v8::Module::kErrored : existing->GetStatus();
+    bool inCurrentStack =
+        std::find(g_moduleResolutionStack.begin(), g_moduleResolutionStack.end(), absPath) !=
+        g_moduleResolutionStack.end();
+
+    bool shouldReuse = !existing.IsEmpty() && status != v8::Module::kErrored;
+    if (shouldReuse && (status == v8::Module::kUninstantiated || status == v8::Module::kInstantiating ||
+                        status == v8::Module::kEvaluating)) {
+      // If we hit an old cached module that never finished evaluating and we're not currently
+      // instantiating it (no stack entry), drop it so we can rebuild cleanly.
+      if (!inCurrentStack) {
+        shouldReuse = false;
+      }
+    }
+
+    // ───────────────────────────────────────────────────────────────
+    // HMR GATING: Prevent secondary importers from touching in-flight modules.
+    // We consider a module "in-flight" if it is unfinished AND a primary importer
+    // has been recorded. The first importer establishing ownership is allowed.
+    // Subsequent importers are gated until evaluation completes, to avoid V8
+    // resolving partially-instantiated dependency graphs that can crash.
+    // A developer can disable this behavior by setting `hmrAllowConcurrentModules` = true
+    // in nativescript.config (package.json). In that case we fall back to prior logic.
+    bool gatingDisabled = false;
+    {
+      id gatingFlag = Runtime::GetAppConfigValue("hmrAllowConcurrentModules");
+      if (gatingFlag && [gatingFlag respondsToSelector:@selector(boolValue)]) {
+        gatingDisabled = [gatingFlag boolValue];
+      }
+    }
+    static std::atomic<size_t> g_hmrModuleGatedCount {0};
+
+    size_t reentryCount = 0;
+    bool unfinished = status == v8::Module::kUninstantiated || status == v8::Module::kInstantiating ||
+            status == v8::Module::kEvaluating;
+    bool moduleInFlight = g_modulesInFlight.find(absPath) != g_modulesInFlight.end();
+    bool pendingReset = g_modulesPendingReset.find(absPath) != g_modulesPendingReset.end();
+    bool treatAsRecursive = false;
+    const std::string parentKey = referrerPath.empty() ? "<anonymous>" : referrerPath;
+
+    if (shouldReuse && status != v8::Module::kEvaluated) {
+      if (moduleInFlight) {
+        auto& parentSet = g_moduleReentryParents[absPath];
+        bool isSelfImport = !referrerPath.empty() && referrerPath == absPath;
+        bool hasParentInfo = !parentKey.empty() && parentKey != "<anonymous>";
+        bool isDynamicDocumentsModule = IsDocumentsPath(absPath);
+        bool parentAlreadyRecorded = false;
+
+        if (hasParentInfo) {
+          parentAlreadyRecorded = !parentSet.insert(parentKey).second;
+        } else {
+          parentAlreadyRecorded = true;
+        }
+
+        auto primaryIt = g_modulePrimaryImporters.find(absPath);
+        if (hasParentInfo && primaryIt == g_modulePrimaryImporters.end()) {
+          g_modulePrimaryImporters[absPath] = parentKey;
+          primaryIt = g_modulePrimaryImporters.find(absPath);
+        }
+
+        if (isSelfImport) {
+          treatAsRecursive = true;
+        } else if (isDynamicDocumentsModule && hasParentInfo && primaryIt != g_modulePrimaryImporters.end()) {
+          const std::string& primaryImporter = primaryIt->second;
+          if (parentKey == primaryImporter) {
+            parentAlreadyRecorded = false;  // Owner re-entry is expected during evaluation.
+          } else {
+            // NEW: gating block—only applied for dynamic Documents modules when unfinished.
+            if (!gatingDisabled && unfinished) {
+              g_hmrModuleGatedCount.fetch_add(1, std::memory_order_relaxed);
+              if (IsScriptLoadingLogEnabled()) {
+                Log(@"[resolver] ⛔ gating unfinished module %s (status=%s) from secondary importer=%s (owner=%s) gatedCount=%lu",
+                    absPath.c_str(), ModuleStatusToString(status), parentKey.c_str(), primaryImporter.c_str(), (unsigned long)g_hmrModuleGatedCount.load());
+              }
+              // Throw a lightweight, recognizable transient error so JS side can detect and retry.
+              if (RuntimeConfig.IsDebug) {
+                v8::Local<v8::String> msgStr = tns::ToV8String(isolate, ("NS_HMR_MODULE_IN_FLIGHT: " + absPath).c_str());
+                v8::Local<v8::Value> errVal = v8::Exception::Error(msgStr);
+                if (errVal->IsObject()) {
+                  v8::Local<v8::Object> errObj = errVal.As<v8::Object>();
+                  errObj->Set(isolate->GetCurrentContext(), tns::ToV8String(isolate, "__nsModulePath"), tns::ToV8String(isolate, absPath.c_str())).FromMaybe(false);
+                  errObj->Set(isolate->GetCurrentContext(), tns::ToV8String(isolate, "__nsModuleStatus"), tns::ToV8String(isolate, ModuleStatusToString(status))).FromMaybe(false);
+                }
+                isolate->ThrowException(errVal);
+              }
+              // OPTIONAL: if global hook __nsRegisterHmrWaiter(path, fn) exists (JS can set it), we create
+              // a callback holder now; JS may pass a function later. This keeps extension flexible without
+              // hard coupling a JS API right now.
+              // (Future: expose a proper C++ binding to push a resolver promise.)
+              return v8::MaybeLocal<v8::Module>();
+            }
+            if (unfinished && IsScriptLoadingLogEnabled()) {
+              Log(@"[resolver] sharing in-flight HMR module %s with requester=%s (owner=%s)",
+                  absPath.c_str(), parentKey.c_str(), primaryImporter.c_str());
+            }
+            v8::Local<v8::Module> fallback;
+            if (unfinished) {
+              auto fallbackIt = g_moduleFallbackRegistry.find(absPath);
+              if (fallbackIt != g_moduleFallbackRegistry.end()) {
+                fallback = fallbackIt->second.Get(isolate);
+              }
+
+              std::string relative = ExtractRelativePath(absPath);
+              if (fallback.IsEmpty() && !relative.empty()) {
+                auto relativeIt = g_moduleFallbackByRelative.find(relative);
+                if (relativeIt != g_moduleFallbackByRelative.end()) {
+                  fallback = relativeIt->second.Get(isolate);
+                }
+              }
+
+              if (fallback.IsEmpty()) {
+                for (const std::string& alias : DocumentsPathAliases(absPath)) {
+                  if (fallback.IsEmpty()) {
+                    auto aliasFallbackIt = g_moduleFallbackRegistry.find(alias);
+                    if (aliasFallbackIt != g_moduleFallbackRegistry.end()) {
+                      fallback = aliasFallbackIt->second.Get(isolate);
+                    }
+                  }
+
+                  if (fallback.IsEmpty()) {
+                    std::string aliasRelative = ExtractRelativePath(alias);
+                    if (!aliasRelative.empty()) {
+                      auto aliasRelativeIt = g_moduleFallbackByRelative.find(aliasRelative);
+                      if (aliasRelativeIt != g_moduleFallbackByRelative.end()) {
+                        fallback = aliasRelativeIt->second.Get(isolate);
+                      }
+                    }
+                  }
+
+                  if (fallback.IsEmpty()) {
+                    auto aliasRegIt = g_moduleRegistry.find(alias);
+                    if (aliasRegIt != g_moduleRegistry.end()) {
+                      v8::Local<v8::Module> aliasModule = aliasRegIt->second.Get(isolate);
+                      if (!aliasModule.IsEmpty() && aliasModule->GetStatus() == v8::Module::kEvaluated) {
+                        fallback = aliasModule;
+                      }
+                    }
+                  }
+
+                  if (!fallback.IsEmpty()) {
+                    g_moduleFallbackRegistry[absPath].Reset(isolate, fallback);
+                    if (!relative.empty()) {
+                      g_moduleFallbackByRelative[relative].Reset(isolate, fallback);
+                    }
+                    break;
+                  }
+                }
+              }
+            }
+
+            if (unfinished && !fallback.IsEmpty()) {
+              if (IsScriptLoadingLogEnabled()) {
+                Log(@"[resolver] returning fallback module for %s to requester=%s while owner=%s completes",
+                    absPath.c_str(), parentKey.c_str(), primaryImporter.c_str());
+              }
+              return v8::MaybeLocal<v8::Module>(fallback);
+            } else if (unfinished && IsScriptLoadingLogEnabled()) {
+              Log(@"[resolver] no fallback available for %s while owner=%s evaluates – waiting on primary",
+                  absPath.c_str(), primaryImporter.c_str());
+            }
+            parentAlreadyRecorded = false;  // Do not treat as recursion; we will refresh post-eval.
+          }
+        }
+
+        if (!isDynamicDocumentsModule && (parentAlreadyRecorded || !hasParentInfo)) {
+          treatAsRecursive = true;
+        } else if (isDynamicDocumentsModule && !hasParentInfo) {
+          treatAsRecursive = true;
+        }
+      }
+
+      if (treatAsRecursive) {
+        auto reentryIt = g_moduleReentryCounts.find(absPath);
+        if (reentryIt != g_moduleReentryCounts.end()) {
+          reentryCount = ++reentryIt->second;
+        } else {
+          reentryCount = ++g_moduleReentryCounts[absPath];
+        }
+
+        if (reentryCount > kMaxModuleReentryCount) {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] ⚠️ module %s exceeded re-entry limit (%lu) while status=%s",
+                absPath.c_str(), static_cast<unsigned long>(reentryCount), ModuleStatusToString(status));
+          }
+          RemoveModuleFromRegistry(absPath);
+          isolate->ThrowException(v8::Exception::Error(
+              tns::ToV8String(isolate,
+                               ("Detected circular module dependency while loading " + absPath)
+                                   .c_str())));
+          return v8::MaybeLocal<v8::Module>();
+        }
+
+        if (unfinished && moduleInFlight && reentryCount > 0) {
+          g_modulesPendingReset.insert(absPath);
+          pendingReset = true;
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[resolver] scheduling reset for unfinished module %s (status=%s, re-entry=%lu)",
+                absPath.c_str(), ModuleStatusToString(status),
+                static_cast<unsigned long>(reentryCount));
+          }
+        }
+      } else {
+        auto existingCountIt = g_moduleReentryCounts.find(absPath);
+        if (existingCountIt != g_moduleReentryCounts.end()) {
+          reentryCount = existingCountIt->second;
+        }
+      }
+    }
+    if (shouldReuse && pendingReset) {
+      if (moduleInFlight) {
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[resolver] module %s awaiting reset is still in-flight; deferring drop (status=%s)",
+              absPath.c_str(), ModuleStatusToString(status));
+        }
+      } else {
+        shouldReuse = false;
+        g_modulesPendingReset.erase(absPath);
+        g_modulePrimaryImporters.erase(absPath);
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[resolver] dropping module awaiting reset %s (status=%s)", absPath.c_str(),
+              ModuleStatusToString(status));
+        }
+      }
     }
-    return v8::MaybeLocal<v8::Module>(it->second.Get(isolate));
+
+    if (IsScriptLoadingLogEnabled()) {
+      const char* statusStr = existing.IsEmpty() ? "<empty>" : ModuleStatusToString(status);
+      Log(@"[resolver] cache hit %s (status=%s)%s", absPath.c_str(), statusStr,
+          shouldReuse ? "" : " – dropping stale entry");
+      if (!existing.IsEmpty() && existing->GetStatus() != v8::Module::kEvaluated && shouldReuse) {
+        if (reentryCount > 0) {
+          Log(@"  ↳ returning module before evaluation (status=%s, re-entry=%lu)", statusStr,
+              static_cast<unsigned long>(reentryCount));
+        } else {
+          Log(@"  ↳ returning module before evaluation (status=%s)", statusStr);
+        }
+        if (moduleInFlight) {
+          auto primaryIt = g_modulePrimaryImporters.find(absPath);
+          const char* owner = primaryIt != g_modulePrimaryImporters.end() ? primaryIt->second.c_str() : "<unknown>";
+          Log(@"  ↳ module still evaluating; primary importer=%s, requester=%s", owner,
+              parentKey.c_str());
+        }
+      }
+      if (!g_moduleResolutionStack.empty()) {
+        Log(@"  ↳ current stack depth %lu", static_cast<unsigned long>(g_moduleResolutionStack.size()));
+      }
+    }
+
+    if (shouldReuse) {
+      if (cache->isWorker) {
+        printf("ResolveModuleCallback: Worker found cached module '%s' -> '%s'\n", spec.c_str(),
+               absPath.c_str());
+      }
+      return v8::MaybeLocal<v8::Module>(existing);
+    }
+
+    if (!existing.IsEmpty() && status == v8::Module::kEvaluated) {
+      auto fallbackIt = g_moduleFallbackRegistry.find(absPath);
+      if (fallbackIt != g_moduleFallbackRegistry.end()) {
+        fallbackIt->second.Reset();
+      }
+      g_moduleFallbackRegistry[absPath].Reset(isolate, existing);
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[resolver] cached evaluated module as fallback for %s", absPath.c_str());
+      }
+    }
+
+    RemoveModuleFromRegistry(absPath);
   }
 
   // 6) Otherwise, compile & register it
@@ -463,6 +1706,37 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
     printf("ResolveModuleCallback: Worker compiling new module '%s' -> '%s'\n", spec.c_str(),
            absPath.c_str());
   }
+
+  auto cycleIt = std::find(g_moduleResolutionStack.begin(), g_moduleResolutionStack.end(), absPath);
+  if (cycleIt != g_moduleResolutionStack.end()) {
+    if (IsScriptLoadingLogEnabled()) {
+      Log(@"[resolver] Detected recursive load for %s (already in stack length %lu)",
+          absPath.c_str(), static_cast<unsigned long>(g_moduleResolutionStack.size()));
+      for (const auto& entry : g_moduleResolutionStack) {
+        Log(@"  • %s", entry.c_str());
+      }
+    }
+
+    auto existing = g_moduleRegistry.find(absPath);
+    if (existing != g_moduleRegistry.end()) {
+      return v8::MaybeLocal<v8::Module>(existing->second.Get(isolate));
+    }
+
+    // If we somehow hit a cycle before the module was registered, bail gracefully in debug mode
+    if (RuntimeConfig.IsDebug) {
+      Log(@"Debug mode - Returning empty module for recursive load: %s", absPath.c_str());
+      return v8::MaybeLocal<v8::Module>();
+    }
+
+    isolate->ThrowException(v8::Exception::Error(
+        tns::ToV8String(isolate, ("Recursive module resolution detected for " + absPath).c_str())));
+    return v8::MaybeLocal<v8::Module>();
+  }
+
+  ResolutionStackGuard stackGuard(isolate, g_moduleResolutionStack, absPath);
+  if (IsScriptLoadingLogEnabled()) {
+    Log(@"[resolver] → LoadScript %s", absPath.c_str());
+  }
   try {
     tns::ModuleInternal::LoadScript(isolate, absPath);
   } catch (NativeScriptException& ex) {
@@ -494,6 +1768,106 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
   NSString* specStr = [NSString stringWithUTF8String:cSpec];
   if (IsScriptLoadingLogEnabled()) {
     Log(@"[dyn-import] → %@", specStr);
+    // Also log the referrer resource when available to correlate origin of dynamic imports
+    v8::Local<v8::Value> resName = referrer->GetResourceName();
+    if (!resName.IsEmpty() && resName->IsString()) {
+      v8::String::Utf8Value rn(isolate, resName);
+      if (*rn) { Log(@"[dyn-import][referrer] %s", *rn); }
+    }
+  }
+  // ── Early guard: intercept bare "@" immediately to avoid any downstream handling ──
+  // We perform this check again here (in addition to normalization guards below) to ensure
+  // no intermediate path attempts to treat "@" as a real module. This also provides a
+  // distinct marker in logs to verify the new code path is active in the built binary.
+  {
+    v8::EscapableHandleScope scope_immediate(isolate);
+    v8::Local<v8::Promise::Resolver> resolver_immediate;
+    if (!v8::Promise::Resolver::New(context).ToLocal(&resolver_immediate)) {
+      return v8::MaybeLocal<v8::Promise>();
+    }
+    if (cSpec && std::strcmp(cSpec, "@") == 0) {
+      if (IsScriptLoadingLogEnabled()) {
+        // Try to capture referrer and JS stack to identify the source
+        NSString* refName = nil;
+        v8::Local<v8::Value> resName = referrer->GetResourceName();
+        if (!resName.IsEmpty() && resName->IsString()) {
+          v8::String::Utf8Value rn(isolate, resName);
+          if (*rn) { refName = [NSString stringWithUTF8String:*rn]; }
+        }
+        Log(@"[dyn-import][guard] immediate '@' stub (ref=%@)", refName ?: @"<unknown>");
+        // JS stack (best-effort)
+        v8::HandleScope hs2(isolate);
+        v8::TryCatch tc2(isolate);
+        v8::Local<v8::String> evalSrc2 = tns::ToV8String(isolate, "(function(){ try { return (new Error('__dyn_at_v2__')).stack || 'no-stack'; } catch(e){ return 'stack-failed'; } })()");
+        v8::Local<v8::Script> script2;
+        if (v8::Script::Compile(context, evalSrc2).ToLocal(&script2)) {
+          v8::Local<v8::Value> val2;
+          if (script2->Run(context).ToLocal(&val2)) {
+            v8::String::Utf8Value s2(isolate, val2);
+            if (*s2) { Log(@"[dyn-import][guard] '@' stack: %@", [NSString stringWithUTF8String:*s2]); }
+          }
+        }
+      }
+      const char* kEmptySrc = "export {}\n";
+      std::string url = "file:///app/__invalid_at__.mjs";
+      v8::MaybeLocal<v8::Module> modMaybe = CompileModuleFromSource(isolate, context, kEmptySrc, url);
+      v8::Local<v8::Module> mod;
+      if (modMaybe.ToLocal(&mod)) {
+        g_moduleRegistry[url].Reset(isolate, mod);
+        if (mod->GetStatus() != v8::Module::kEvaluated) {
+          if (mod->Evaluate(context).IsEmpty()) {
+            resolver_immediate->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed for empty module"))).FromMaybe(false);
+            return scope_immediate.Escape(resolver_immediate->GetPromise());
+          }
+        }
+        resolver_immediate->Resolve(context, mod->GetModuleNamespace()).FromMaybe(false);
+        return scope_immediate.Escape(resolver_immediate->GetPromise());
+      }
+      // If compilation somehow failed, still resolve with an empty object namespace
+      resolver_immediate->Resolve(context, v8::Object::New(isolate)).FromMaybe(false);
+      return scope_immediate.Escape(resolver_immediate->GetPromise());
+    }
+  }
+  // Normalize spec: expand '@/'; only strip ?query/hash for non-HTTP specs so SFC HTTP keys keep version tags
+  std::string rawSpec = cSpec ? std::string(cSpec) : std::string();
+  std::string normalizedSpec = rawSpec;
+  // remove query/hash ONLY for non-HTTP specs
+  bool isHttpLike = (!normalizedSpec.empty() && (StartsWith(normalizedSpec, "http://") || StartsWith(normalizedSpec, "https://")));
+  if (!isHttpLike) {
+    size_t qpos = normalizedSpec.find_first_of("?#");
+    if (qpos != std::string::npos) {
+      normalizedSpec = normalizedSpec.substr(0, qpos);
+    }
+  }
+  // expand '@/'
+  if (normalizedSpec.rfind("@/", 0) == 0) {
+    normalizedSpec = std::string("/src/") + normalizedSpec.substr(2);
+  }
+  // guard against collapse to '@'
+  if (normalizedSpec == "@") {
+    if (IsScriptLoadingLogEnabled()) { Log(@"[dyn-import][normalize] invalid '@' spec, capturing JS stack"); }
+    // Attempt to capture JS stack by evaluating new Error().stack in JS context
+    v8::HandleScope hs(isolate);
+    v8::TryCatch tc(isolate);
+    v8::Local<v8::String> evalSrc = tns::ToV8String(isolate, "(function(){ try { return (new Error('__dyn_at__')).stack || 'no-stack'; } catch(e){ return 'stack-failed'; } })()");
+    v8::Local<v8::Script> script;
+    if (v8::Script::Compile(context, evalSrc).ToLocal(&script)) {
+      v8::Local<v8::Value> val;
+      if (script->Run(context).ToLocal(&val)) {
+        v8::String::Utf8Value s(isolate, val);
+        if (*s) {
+          NSString* stack = [NSString stringWithUTF8String:*s];
+          if (IsScriptLoadingLogEnabled()) { Log(@"[dyn-import][normalize] '@' stack: %@", stack); }
+        }
+      }
+    }
+    normalizedSpec = rawSpec; // revert to raw
+  }
+  if (normalizedSpec != rawSpec) {
+    // Rebuild V8 string only if changed
+    specifier = tns::ToV8String(isolate, normalizedSpec.c_str());
+    specStr = [NSString stringWithUTF8String:normalizedSpec.c_str()];
+    if (IsScriptLoadingLogEnabled()) { Log(@"[dyn-import][normalize] %@ -> %@", [NSString stringWithUTF8String:rawSpec.c_str()], specStr); }
   }
   v8::EscapableHandleScope scope(isolate);
 
@@ -506,43 +1880,539 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
   // 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;
+    // Defensive guard: some dev-time toolchains may emit a stray import('@') during bootstrap.
+    // Treat it as a no-op module to avoid surfacing a hard failure while continuing with real imports.
+    if (!normalizedSpec.empty() && normalizedSpec == "@") {
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[dyn-import] ignoring invalid '@' spec (returning empty module)");
+      }
+      const char* kEmptySrc = "export {}\n";
+      std::string url = "file:///app/__invalid_at__.mjs";
+      v8::MaybeLocal<v8::Module> modMaybe = CompileModuleFromSource(isolate, context, kEmptySrc, url);
+      v8::Local<v8::Module> mod;
+      if (modMaybe.ToLocal(&mod)) {
+        g_moduleRegistry[url].Reset(isolate, mod);
+        if (mod->GetStatus() != v8::Module::kEvaluated) {
+          if (mod->Evaluate(context).IsEmpty()) {
+            resolver->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed for empty module"))).FromMaybe(false);
+            return scope.Escape(resolver->GetPromise());
+          }
+        }
+        resolver->Resolve(context, mod->GetModuleNamespace()).FromMaybe(false);
+        return scope.Escape(resolver->GetPromise());
+      }
+    }
+
+    // If spec is an HTTP(S) URL, try HTTP fetch+compile directly
+    if (!normalizedSpec.empty() && (StartsWith(normalizedSpec, "http://") || StartsWith(normalizedSpec, "https://"))) {
+      if (IsScriptLoadingLogEnabled()) {
+        Log(@"[dyn-import][http-loader] trying URL %s", normalizedSpec.c_str());
+      }
+      std::string key = CanonicalizeHttpUrlKey(normalizedSpec);
+      // Diagnostic: confirm SFC canonical key retains versioning query
+      if (IsScriptLoadingLogEnabled()) {
+        bool diagIsSfc = normalizedSpec.find("/@ns/sfc/") != std::string::npos;
+        if (diagIsSfc) {
+          Log(@"[dyn-import][sfc-key] spec=%s key=%s", normalizedSpec.c_str(), key.c_str());
+        }
+      }
+      // Classify SFC base vs variant: base is /@ns/sfc without a specific type (script/template/style)
+      bool specIsSfc = normalizedSpec.find("/@ns/sfc/") != std::string::npos;
+      bool specIsAsm = normalizedSpec.find("/@ns/asm/") != std::string::npos;
+      bool specHasTypeScript = normalizedSpec.find("type=script") != std::string::npos;
+      bool specHasTypeTemplate = normalizedSpec.find("type=template") != std::string::npos;
+      bool specHasTypeStyle = normalizedSpec.find("type=style") != std::string::npos;
+      bool isSfcVariant = specIsSfc && (specHasTypeScript || specHasTypeTemplate || specHasTypeStyle);
+      // Base SFC has no explicit type param; variants carry type=script|template|style
+      bool isSfcBase = (specIsSfc && !isSfcVariant) || specIsAsm;
+      if (isSfcBase) {
+        auto ex = g_moduleRegistry.find(key);
+        if (ex != g_moduleRegistry.end()) {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[dyn-import][http-cache] drop SFC %s", key.c_str());
+          }
+          RemoveModuleFromRegistry(key);
+        }
+      }
+      // Coalesce concurrent dynamic imports for the same HTTP key
+      auto inflight = g_modulesInFlight.find(key) != g_modulesInFlight.end();
+      if (inflight) {
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[dyn-import][http] coalesce in-flight %s", key.c_str());
+        }
+        g_httpDynamicWaiters[key].emplace_back(isolate, resolver);
+        return scope.Escape(resolver->GetPromise());
+      }
+      // If module was already compiled, resolve immediately
+      auto itExisting = g_moduleRegistry.find(key);
+      if (itExisting != g_moduleRegistry.end()) {
+        v8::Local<v8::Module> existing = itExisting->second.Get(isolate);
+        if (!existing.IsEmpty()) {
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[dyn-import][http-cache] hit %s", key.c_str());
+            Log(@"  ↳ status=%s", ModuleStatusToString(existing->GetStatus()));
+          }
+          v8::Module::Status st = existing->GetStatus();
+          if (st == v8::Module::kErrored) {
+            // Stale/broken entry; drop and refetch
+            if (IsScriptLoadingLogEnabled()) {
+              Log(@"[dyn-import][http-cache] dropping errored module for %s", key.c_str());
+            }
+            RemoveModuleFromRegistry(key);
+            // fall through to fetch/compile path below
+          } else {
+            // Ensure dynamic import semantics: resolve only after evaluation
+            if (st != v8::Module::kEvaluated) {
+              // mark in-flight while we evaluate
+              g_modulesInFlight.insert(key);
+              if (IsScriptLoadingLogEnabled()) {
+                Log(@"[dyn-import][http-cache] awaiting evaluation %s", key.c_str());
+              }
+              g_httpDynamicWaiters[key].emplace_back(isolate, resolver);
+              // Trigger evaluation. If TLA returns a Promise, attach then-handlers to resolve waiters upon settle.
+              v8::Local<v8::Value> evalResult;
+              if (!existing->Evaluate(context).ToLocal(&evalResult)) {
+                // Failed evaluation: reject all waiters and drop entry
+                auto ws = g_httpDynamicWaiters.find(key);
+                if (ws != g_httpDynamicWaiters.end()) {
+                  for (auto &res : ws->second) {
+                    v8::Local<v8::Promise::Resolver> r = res.Get(isolate);
+                    if (!r.IsEmpty()) r->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed (http-cache hit)"))).FromMaybe(false);
+                  }
+                  g_httpDynamicWaiters.erase(ws);
+                }
+                RemoveModuleFromRegistry(key);
+                g_modulesInFlight.erase(key);
+                return scope.Escape(resolver->GetPromise());
+              }
+              // If Evaluate returned a Promise (top-level await), wait until it settles before resolving waiters.
+              if (!evalResult.IsEmpty() && evalResult->IsPromise()) {
+                v8::Local<v8::Promise> p = evalResult.As<v8::Promise>();
+                struct EvalWaitData { std::string key; v8::Global<v8::Context> ctx; v8::Global<v8::Module> mod; };
+                auto* data = new EvalWaitData{ key, v8::Global<v8::Context>(isolate, context), v8::Global<v8::Module>(isolate, existing) };
+                auto onFulfilled = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+                  v8::Isolate* iso = info.GetIsolate();
+                  v8::HandleScope hs(iso);
+                  if (!info.Data()->IsExternal()) return;
+                  auto* d = static_cast<EvalWaitData*>(info.Data().As<v8::External>()->Value());
+                  v8::Local<v8::Context> ctx = d->ctx.Get(iso);
+                  std::string keyLocal = d->key;
+                  v8::Local<v8::Module> modLocal = d->mod.Get(iso);
+                  auto ws = g_httpDynamicWaiters.find(keyLocal);
+                  if (ws != g_httpDynamicWaiters.end()) {
+                    v8::Local<v8::Value> ns = modLocal->GetModuleNamespace();
+                    for (auto &res : ws->second) {
+                      v8::Local<v8::Promise::Resolver> r = res.Get(iso);
+                      if (!r.IsEmpty()) r->Resolve(ctx, ns).FromMaybe(false);
+                    }
+                    g_httpDynamicWaiters.erase(ws);
+                  }
+                  g_modulesInFlight.erase(keyLocal);
+                  delete d;
+                };
+                auto onRejected = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+                  v8::Isolate* iso = info.GetIsolate();
+                  v8::HandleScope hs(iso);
+                  if (!info.Data()->IsExternal()) return;
+                  auto* d = static_cast<EvalWaitData*>(info.Data().As<v8::External>()->Value());
+                  v8::Local<v8::Context> ctx = d->ctx.Get(iso);
+                  std::string keyLocal = d->key;
+                  v8::Local<v8::Value> reason = (info.Length() > 0) ? info[0] : v8::Exception::Error(tns::ToV8String(iso, "Evaluation failed (http-cache TLA)"));
+                  if (IsScriptLoadingLogEnabled()) {
+                    v8::String::Utf8Value r(iso, reason);
+                    if (*r) { Log(@"[dyn-import][http-cache][tla] rejected: %s", *r); }
+                  }
+                  auto ws = g_httpDynamicWaiters.find(keyLocal);
+                  if (ws != g_httpDynamicWaiters.end()) {
+                    for (auto &res : ws->second) {
+                      v8::Local<v8::Promise::Resolver> r = res.Get(iso);
+                      if (!r.IsEmpty()) r->Reject(ctx, reason).FromMaybe(false);
+                    }
+                    g_httpDynamicWaiters.erase(ws);
+                  }
+                  g_modulesInFlight.erase(keyLocal);
+                  delete d;
+                };
+                v8::Local<v8::FunctionTemplate> thenFulfillTpl = v8::FunctionTemplate::New(isolate, onFulfilled, v8::External::New(isolate, data));
+                v8::Local<v8::Function> thenFulfill = thenFulfillTpl->GetFunction(context).ToLocalChecked();
+                v8::Local<v8::FunctionTemplate> thenRejectTpl = v8::FunctionTemplate::New(isolate, onRejected, v8::External::New(isolate, data));
+                v8::Local<v8::Function> thenReject = thenRejectTpl->GetFunction(context).ToLocalChecked();
+                p->Then(context, thenFulfill, thenReject).ToLocalChecked();
+                return scope.Escape(resolver->GetPromise());
+              }
+              // Successful sync evaluation path: resolve waiters now.
+              {
+                auto ws = g_httpDynamicWaiters.find(key);
+                if (ws != g_httpDynamicWaiters.end()) {
+                  v8::Local<v8::Value> resolveVal = existing->GetModuleNamespace();
+                  for (auto &res : ws->second) {
+                    v8::Local<v8::Promise::Resolver> r = res.Get(isolate);
+                    if (!r.IsEmpty()) r->Resolve(context, resolveVal).FromMaybe(false);
+                  }
+                  g_httpDynamicWaiters.erase(ws);
+                }
+                g_modulesInFlight.erase(key);
+                return scope.Escape(resolver->GetPromise());
+              }
+            }
+            // Always resolve with namespace for cached modules; JS side will read default
+            resolver->Resolve(context, existing->GetModuleNamespace()).FromMaybe(false);
+            return scope.Escape(resolver->GetPromise());
+          }
+        }
+      }
+      // mark in-flight before starting network fetch
+      g_modulesInFlight.insert(key);
+      std::string body; std::string ct; int status = 0;
+      if (HttpFetchText(normalizedSpec, body, ct, status) && !body.empty()) {
+        v8::MaybeLocal<v8::Module> modMaybe = CompileModuleFromSourceRegisterFirst(isolate, context, body, key);
+        v8::Local<v8::Module> mod;
+        if (modMaybe.ToLocal(&mod)) {
+          // Evaluate once compiled so that namespace is valid for dynamic import resolution
+          if (mod->GetStatus() != v8::Module::kEvaluated) {
+            v8::Local<v8::Value> evalResult;
+            if (!mod->Evaluate(context).ToLocal(&evalResult)) {
+              // Remove broken registration and reject
+              RemoveModuleFromRegistry(key);
+              // Reject all waiters
+              auto ws = g_httpDynamicWaiters.find(key);
+              if (ws != g_httpDynamicWaiters.end()) {
+                for (auto &res : ws->second) {
+                  v8::Local<v8::Promise::Resolver> r = res.Get(isolate);
+                  if (!r.IsEmpty()) r->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed (http-loader)"))).FromMaybe(false);
+                }
+                g_httpDynamicWaiters.erase(ws);
+              }
+              resolver->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed (http-loader)"))).FromMaybe(false);
+              g_modulesInFlight.erase(key);
+              return scope.Escape(resolver->GetPromise());
+            }
+            // If Evaluate returned a Promise (top-level await), wait until it settles before resolving
+            if (!evalResult.IsEmpty() && evalResult->IsPromise()) {
+              v8::Local<v8::Promise> p = evalResult.As<v8::Promise>();
+              struct EvalWaitData2 { std::string key; v8::Global<v8::Context> ctx; v8::Global<v8::Module> mod; v8::Global<v8::Promise::Resolver> current; };
+              auto* data2 = new EvalWaitData2{ key, v8::Global<v8::Context>(isolate, context), v8::Global<v8::Module>(isolate, mod), v8::Global<v8::Promise::Resolver>(isolate, resolver) };
+              auto onFulfilled2 = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+                v8::Isolate* iso = info.GetIsolate();
+                v8::HandleScope hs(iso);
+                if (!info.Data()->IsExternal()) return;
+                auto* d = static_cast<EvalWaitData2*>(info.Data().As<v8::External>()->Value());
+                v8::Local<v8::Context> ctx = d->ctx.Get(iso);
+                std::string keyLocal = d->key;
+                v8::Local<v8::Module> modLocal = d->mod.Get(iso);
+                auto ws = g_httpDynamicWaiters.find(keyLocal);
+                v8::Local<v8::Value> ns = modLocal->GetModuleNamespace();
+                if (ws != g_httpDynamicWaiters.end()) {
+                  for (auto &res : ws->second) {
+                    v8::Local<v8::Promise::Resolver> r = res.Get(iso);
+                    if (!r.IsEmpty()) r->Resolve(ctx, ns).FromMaybe(false);
+                  }
+                  g_httpDynamicWaiters.erase(ws);
+                }
+                // Also resolve the current resolver in case it wasn't part of waiters
+                v8::Local<v8::Promise::Resolver> cur = d->current.Get(iso);
+                if (!cur.IsEmpty()) cur->Resolve(ctx, ns).FromMaybe(false);
+                g_modulesInFlight.erase(keyLocal);
+                delete d;
+              };
+              auto onRejected2 = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+                v8::Isolate* iso = info.GetIsolate();
+                v8::HandleScope hs(iso);
+                if (!info.Data()->IsExternal()) return;
+                auto* d = static_cast<EvalWaitData2*>(info.Data().As<v8::External>()->Value());
+                v8::Local<v8::Context> ctx = d->ctx.Get(iso);
+                std::string keyLocal = d->key;
+                v8::Local<v8::Value> reason = (info.Length() > 0) ? info[0] : v8::Exception::Error(tns::ToV8String(iso, "Evaluation failed (http-loader TLA)"));
+                if (IsScriptLoadingLogEnabled()) {
+                  v8::String::Utf8Value r(iso, reason);
+                  if (*r) { Log(@"[dyn-import][http-loader][tla] rejected: %s", *r); }
+                }
+                auto ws = g_httpDynamicWaiters.find(keyLocal);
+                if (ws != g_httpDynamicWaiters.end()) {
+                  for (auto &res : ws->second) {
+                    v8::Local<v8::Promise::Resolver> r = res.Get(iso);
+                    if (!r.IsEmpty()) r->Reject(ctx, reason).FromMaybe(false);
+                  }
+                  g_httpDynamicWaiters.erase(ws);
+                }
+                v8::Local<v8::Promise::Resolver> cur = d->current.Get(iso);
+                if (!cur.IsEmpty()) cur->Reject(ctx, reason).FromMaybe(false);
+                g_modulesInFlight.erase(keyLocal);
+                delete d;
+              };
+              v8::Local<v8::FunctionTemplate> thenFulfillTpl2 = v8::FunctionTemplate::New(isolate, onFulfilled2, v8::External::New(isolate, data2));
+              v8::Local<v8::Function> thenFulfill2 = thenFulfillTpl2->GetFunction(context).ToLocalChecked();
+              v8::Local<v8::FunctionTemplate> thenRejectTpl2 = v8::FunctionTemplate::New(isolate, onRejected2, v8::External::New(isolate, data2));
+              v8::Local<v8::Function> thenReject2 = thenRejectTpl2->GetFunction(context).ToLocalChecked();
+              p->Then(context, thenFulfill2, thenReject2).ToLocalChecked();
+              return scope.Escape(resolver->GetPromise());
+            }
+          }
+          // Do not verify/read default here; JS side handles default access safely.
+          // Resolve all waiters including current
+          // Resolve with the module namespace; JS will read .default when needed
+          v8::Local<v8::Value> resultVal = mod->GetModuleNamespace();
+          auto ws = g_httpDynamicWaiters.find(key);
+          if (ws != g_httpDynamicWaiters.end()) {
+            for (auto &res : ws->second) {
+              v8::Local<v8::Promise::Resolver> r = res.Get(isolate);
+              if (!r.IsEmpty()) r->Resolve(context, resultVal).FromMaybe(false);
+            }
+            g_httpDynamicWaiters.erase(ws);
+          }
+          resolver->Resolve(context, resultVal).FromMaybe(false);
+          g_modulesInFlight.erase(key);
+          return scope.Escape(resolver->GetPromise());
+        }
+      } else if (IsScriptLoadingLogEnabled()) {
+        Log(@"[dyn-import][http-loader] fetch failed %s status=%d", normalizedSpec.c_str(), status);
+      }
+      // On fetch/compile miss: clean inflight and reject queued
+      auto ws = g_httpDynamicWaiters.find(key);
+      if (ws != g_httpDynamicWaiters.end()) {
+        for (auto &res : ws->second) {
+          v8::Local<v8::Promise::Resolver> r = res.Get(isolate);
+          if (!r.IsEmpty()) r->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "HTTP fetch/compile failed"))).FromMaybe(false);
+        }
+        g_httpDynamicWaiters.erase(ws);
+      }
+      g_modulesInFlight.erase(key);
+    }
 
-    v8::MaybeLocal<v8::Module> maybeModule =
-        ResolveModuleCallback(context, specifier, import_assertions, refMod);
+    // Attempt to resolve relative specs against the referrer's resource URL if available.
+    // This reduces reliance on app-root fallback and ensures ../ segments are collapsed.
+    v8::Local<v8::Module> refMod;
+    v8::Local<v8::String> adjustedSpecifier = specifier;
+    if (!normalizedSpec.empty() && (normalizedSpec.rfind("./", 0) == 0 || normalizedSpec.rfind("../", 0) == 0)) {
+      // Try to extract a base directory from referrer->GetResourceName() which is a file:// URL
+      v8::Local<v8::Value> resName = referrer->GetResourceName();
+      if (!resName.IsEmpty() && resName->IsString()) {
+        v8::String::Utf8Value rn(isolate, resName);
+        std::string refUrl = *rn ? *rn : std::string();
+        if (!refUrl.empty()) {
+          std::string refPath = FileURLToPath(refUrl);
+          size_t slash = refPath.find_last_of("/\\");
+          std::string baseDir = slash == std::string::npos ? std::string() : refPath.substr(0, slash + 1);
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[dyn-import][ref] url=%s base=%s spec=%s", refUrl.c_str(), baseDir.c_str(), normalizedSpec.c_str());
+          }
+          // Join and standardize via NSString to collapse dot-segments
+          @autoreleasepool {
+            NSString* nsBase = [NSString stringWithUTF8String:baseDir.c_str()];
+            NSString* nsRel = [NSString stringWithUTF8String:normalizedSpec.c_str()];
+            if (nsBase && nsRel) {
+              NSString* joined = [nsBase stringByAppendingPathComponent:nsRel];
+              NSString* std = [joined stringByStandardizingPath];
+              if (std) {
+                std::string fsPath = std.UTF8String;
+                // Convert back to a path relative to app when applicable
+                // Prefer absolute filesystem path; ResolveModuleCallback can handle it
+                adjustedSpecifier = tns::ToV8String(isolate, fsPath.c_str());
+                if (IsScriptLoadingLogEnabled()) {
+                  Log(@"[dyn-import][normalize-rel] %s + %s -> %s", baseDir.c_str(), normalizedSpec.c_str(), fsPath.c_str());
+                }
+              }
+            }
+          }
+        }
+      } else {
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[dyn-import][ref] missing resource name; cannot normalize relative spec against referrer");
+        }
+      }
+    }
 
-    v8::Local<v8::Module> module;
-    if (!maybeModule.ToLocal(&module)) {
-      // ResolveModuleCallback already threw; forward the V8 exception
+  v8::TryCatch resolveTc(isolate);
+  v8::MaybeLocal<v8::Module> maybeModule =
+    ResolveModuleCallback(context, adjustedSpecifier, import_assertions, refMod);
+  if (IsScriptLoadingLogEnabled()) {
+    // Log the adjusted specifier we sent to the resolver
+    v8::String::Utf8Value adj(isolate, adjustedSpecifier);
+    const char* cAdj = (*adj) ? *adj : "<invalid>";
+    Log(@"[dyn-import][resolver-call] raw=%s normalized=%s adjusted=%s",
+        rawSpec.c_str(), normalizedSpec.c_str(), cAdj);
+  }
+  if (maybeModule.IsEmpty()) {
+    if (resolveTc.HasCaught()) {
+      // Reject the promise with the thrown exception so callers don't hang
+      resolver->Reject(context, resolveTc.Exception()).FromMaybe(false);
+      return scope.Escape(resolver->GetPromise());
+    } else {
+      // No exception thrown (debug path); reject with a helpful error
+      std::string msg = "Module resolution failed for dynamic import: ";
+      msg += normalizedSpec.empty() ? "<empty>" : normalizedSpec;
+      resolver->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, msg.c_str()))).FromMaybe(false);
       return scope.Escape(resolver->GetPromise());
     }
+  }
+
+    // If initial resolution failed AND looks like an application module, attempt on-demand fetch via JS bridge.
+    if (maybeModule.IsEmpty()) {
+      bool looksApp = false;
+      if (!normalizedSpec.empty()) {
+        std::string specCpp(normalizedSpec);
+        // Heuristic: app modules start with /core, /src, /utils or ./ relative forms (not node_modules, not @nativescript/*)
+        if (specCpp.rfind("/core/", 0) == 0 || specCpp.rfind("/src/", 0) == 0 || specCpp.rfind("/utils/", 0) == 0 || specCpp.rfind("./", 0) == 0) {
+          looksApp = true;
+        }
+      }
+      if (looksApp) {
+        if (IsScriptLoadingLogEnabled()) { Log(@"[dyn-import][fetch] attempting runtime fetch for %@", specStr); }
+        v8::TryCatch tc(isolate);
+        // Acquire __nsHmrRequestModule
+        v8::Local<v8::String> fetchKey = tns::ToV8String(isolate, "__nsHmrRequestModule");
+        v8::Local<v8::Value> fetchFnVal;
+        if (context->Global()->Get(context, fetchKey).ToLocal(&fetchFnVal) && fetchFnVal->IsFunction()) {
+          v8::Local<v8::Function> fetchFn = fetchFnVal.As<v8::Function>();
+          v8::Local<v8::Value> argv[1] = { specifier };
+          v8::MaybeLocal<v8::Value> maybePromise = fetchFn->Call(context, context->Global(), 1, argv);
+          v8::Local<v8::Value> promiseVal;
+          if (maybePromise.ToLocal(&promiseVal) && promiseVal->IsPromise()) {
+            // Chain: when JS promise resolves, retry resolution.
+            v8::Local<v8::Promise> jsPromise = promiseVal.As<v8::Promise>();
+            // We attach then() via microtask enqueue style: create functions capturing resolver & spec.
+            struct FetchRetryData { v8::Global<v8::Promise::Resolver> resolver; v8::Global<v8::String> spec; v8::Global<v8::FixedArray> assertions; };
+            auto* data = new FetchRetryData{ v8::Global<v8::Promise::Resolver>(isolate, resolver), v8::Global<v8::String>(isolate, specifier), v8::Global<v8::FixedArray>(isolate, import_assertions) };
+
+            // Success callback
+            auto onFulfilled = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+              v8::Isolate* isolateInner = info.GetIsolate();
+              v8::HandleScope hs(isolateInner);
+              if (!info.Data()->IsExternal()) return;
+              auto* d = static_cast<FetchRetryData*>(info.Data().As<v8::External>()->Value());
+              v8::Local<v8::Context> ctx = isolateInner->GetCurrentContext();
+              v8::Local<v8::Promise::Resolver> res = d->resolver.Get(isolateInner);
+              v8::Local<v8::String> specLocal = d->spec.Get(isolateInner);
+              v8::Local<v8::FixedArray> assertionsLocal = d->assertions.Get(isolateInner);
+              v8::Local<v8::Module> refMod; // empty
+              v8::MaybeLocal<v8::Module> again = ResolveModuleCallback(ctx, specLocal, assertionsLocal, refMod);
+              v8::Local<v8::Module> mod2;
+              if (!again.ToLocal(&mod2)) {
+                res->Reject(ctx, v8::Exception::Error(tns::ToV8String(isolateInner, "Module still unresolved after fetch"))).FromMaybe(false);
+              } else {
+                if (mod2->GetStatus() == v8::Module::kUninstantiated) {
+                  if (!mod2->InstantiateModule(ctx, &ResolveModuleCallback).FromMaybe(false)) {
+                    res->Reject(ctx, v8::Exception::Error(tns::ToV8String(isolateInner, "Instantiate failed after fetch"))).FromMaybe(false);
+                    delete d; return;
+                  }
+                }
+                if (mod2->GetStatus() != v8::Module::kEvaluated) {
+                  if (mod2->Evaluate(ctx).IsEmpty()) {
+                    res->Reject(ctx, v8::Exception::Error(tns::ToV8String(isolateInner, "Evaluation failed after fetch"))).FromMaybe(false);
+                    delete d; return;
+                  }
+                }
+                res->Resolve(ctx, mod2->GetModuleNamespace()).FromMaybe(false);
+              }
+              delete d;
+            };
+
+            // Failure callback
+            auto onRejected = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+              v8::Isolate* isolateInner = info.GetIsolate();
+              v8::HandleScope hs(isolateInner);
+              if (!info.Data()->IsExternal()) return;
+              auto* d = static_cast<FetchRetryData*>(info.Data().As<v8::External>()->Value());
+              v8::Local<v8::Context> ctx = isolateInner->GetCurrentContext();
+              v8::Local<v8::Promise::Resolver> res = d->resolver.Get(isolateInner);
+              v8::Local<v8::Value> reason = info.Length() > 0 ? info[0] : v8::Exception::Error(tns::ToV8String(isolateInner, "Fetch failed"));
+              res->Reject(ctx, reason).FromMaybe(false);
+              delete d;
+            };
+
+            v8::Local<v8::FunctionTemplate> thenFulfillTpl = v8::FunctionTemplate::New(isolate, onFulfilled, v8::External::New(isolate, data));
+            v8::Local<v8::Function> thenFulfill = thenFulfillTpl->GetFunction(context).ToLocalChecked();
+            v8::Local<v8::FunctionTemplate> thenRejectTpl = v8::FunctionTemplate::New(isolate, onRejected, v8::External::New(isolate, data));
+            v8::Local<v8::Function> thenReject = thenRejectTpl->GetFunction(context).ToLocalChecked();
+            v8::Local<v8::Value> thenArgs[2] = { thenFulfill, thenReject };
+            jsPromise->Then(context, thenArgs[0].As<v8::Function>(), thenArgs[1].As<v8::Function>()).ToLocalChecked();
+            return scope.Escape(resolver->GetPromise());
+          }
+        }
+        // If no bridge or not a promise we fall through to normal failure path.
+      }
+    }
+
+    v8::Local<v8::Module> module = maybeModule.ToLocalChecked();
 
     // If not yet instantiated/evaluated, do it now
     if (module->GetStatus() == v8::Module::kUninstantiated) {
+      // Capture detailed V8 exception info if instantiation fails
+      v8::TryCatch ictc(isolate);
       if (!module->InstantiateModule(context, &ResolveModuleCallback).FromMaybe(false)) {
         if (IsScriptLoadingLogEnabled()) {
           Log(@"[dyn-import] ✗ instantiate failed %@", specStr);
         }
+        // Include the spec and V8 exception message (when available) for improved diagnostics upstream
+        std::string msg = std::string("Failed to instantiate module: ") + std::string([specStr UTF8String]);
+        if (ictc.HasCaught()) {
+          std::string exStr = tns::ToString(isolate, ictc.Exception());
+          if (!exStr.empty()) {
+            msg.append(" — ");
+            msg.append(exStr);
+          }
+        }
         resolver
             ->Reject(context,
-                     v8::Exception::Error(tns::ToV8String(isolate, "Failed to instantiate module")))
+                     v8::Exception::Error(tns::ToV8String(isolate, msg.c_str())))
             .Check();
         return scope.Escape(resolver->GetPromise());
       }
     }
 
     if (module->GetStatus() != v8::Module::kEvaluated) {
-      if (module->Evaluate(context).IsEmpty()) {
+      v8::Local<v8::Value> evalResult;
+      if (!module->Evaluate(context).ToLocal(&evalResult)) {
         if (IsScriptLoadingLogEnabled()) {
           Log(@"[dyn-import] ✗ evaluation failed %@", specStr);
         }
-        v8::Local<v8::Value> ex =
-            v8::Exception::Error(tns::ToV8String(isolate, "Evaluation failed"));
+        // Include the spec in the error message for improved diagnostics upstream
+        std::string msg = std::string("Evaluation failed for module: ") + std::string([specStr UTF8String]);
+        v8::Local<v8::Value> ex = v8::Exception::Error(tns::ToV8String(isolate, msg.c_str()));
         resolver->Reject(context, ex).Check();
         return scope.Escape(resolver->GetPromise());
       }
+      // If top-level await returns a Promise, resolve only after it settles
+      if (!evalResult.IsEmpty() && evalResult->IsPromise()) {
+        v8::Local<v8::Promise> p = evalResult.As<v8::Promise>();
+        struct DynEvalData { v8::Global<v8::Context> ctx; v8::Global<v8::Module> mod; v8::Global<v8::Promise::Resolver> res; };
+        auto* d = new DynEvalData{ v8::Global<v8::Context>(isolate, context), v8::Global<v8::Module>(isolate, module), v8::Global<v8::Promise::Resolver>(isolate, resolver) };
+        auto onFulfilled = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+          v8::Isolate* iso = info.GetIsolate();
+          v8::HandleScope hs(iso);
+          if (!info.Data()->IsExternal()) return;
+          auto* d = static_cast<DynEvalData*>(info.Data().As<v8::External>()->Value());
+          v8::Local<v8::Context> ctx = d->ctx.Get(iso);
+          v8::Local<v8::Module> modLocal = d->mod.Get(iso);
+          v8::Local<v8::Promise::Resolver> res = d->res.Get(iso);
+          if (IsScriptLoadingLogEnabled()) {
+            Log(@"[dyn-import][tla] fulfilled, resolving namespace");
+          }
+          if (!res.IsEmpty()) res->Resolve(ctx, modLocal->GetModuleNamespace()).FromMaybe(false);
+          delete d;
+        };
+        auto onRejected = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+          v8::Isolate* iso = info.GetIsolate();
+          v8::HandleScope hs(iso);
+          if (!info.Data()->IsExternal()) return;
+          auto* d = static_cast<DynEvalData*>(info.Data().As<v8::External>()->Value());
+          v8::Local<v8::Context> ctx = d->ctx.Get(iso);
+          v8::Local<v8::Promise::Resolver> res = d->res.Get(iso);
+          v8::Local<v8::Value> reason = (info.Length() > 0) ? info[0] : v8::Exception::Error(tns::ToV8String(iso, "Evaluation failed (TLA)"));
+          if (IsScriptLoadingLogEnabled()) {
+            v8::String::Utf8Value r(iso, reason);
+            if (*r) { Log(@"[dyn-import][tla] rejected: %s", *r); }
+          }
+          if (!res.IsEmpty()) res->Reject(ctx, reason).FromMaybe(false);
+          delete d;
+        };
+        v8::Local<v8::FunctionTemplate> fulfillTpl = v8::FunctionTemplate::New(isolate, onFulfilled, v8::External::New(isolate, d));
+        v8::Local<v8::Function> fulfill = fulfillTpl->GetFunction(context).ToLocalChecked();
+        v8::Local<v8::FunctionTemplate> rejectTpl = v8::FunctionTemplate::New(isolate, onRejected, v8::External::New(isolate, d));
+        v8::Local<v8::Function> reject = rejectTpl->GetFunction(context).ToLocalChecked();
+        p->Then(context, fulfill, reject).ToLocalChecked();
+        return scope.Escape(resolver->GetPromise());
+      }
     }
 
     // Special handling for bundler chunks: check if this is a bundler chunk and install it
@@ -564,7 +2434,7 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
           // 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"),
+          ResolveModuleCallback(context, tns::ToV8String(isolate, "file:///app/runtime.mjs"),
                                     empty_assertions, v8::Local<v8::Module>());
 
           v8::Local<v8::Module> runtimeModule;
@@ -627,6 +2497,20 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
       }
     }
 
+    // Final verify before resolving for non-HTTP paths too
+    v8::Local<v8::Value> nsFinal = module->GetModuleNamespace();
+    if (nsFinal->IsObject()) {
+      v8::Local<v8::Object> o = nsFinal.As<v8::Object>();
+      v8::TryCatch tc3(isolate);
+      v8::Local<v8::Value> defVal;
+      if (!o->Get(context, tns::ToV8String(isolate, "default")).ToLocal(&defVal)) {
+        if (IsScriptLoadingLogEnabled()) {
+          Log(@"[dyn-import][verify] ns.default threw after eval (generic) %s", specStr);
+        }
+        resolver->Reject(context, v8::Exception::Error(tns::ToV8String(isolate, "TDZ on default after eval (generic)"))).Check();
+        return scope.Escape(resolver->GetPromise());
+      }
+    }
     resolver->Resolve(context, module->GetModuleNamespace()).Check();
     if (IsScriptLoadingLogEnabled()) {
       Log(@"[dyn-import] ✓ resolved %@", specStr);
@@ -644,4 +2528,4 @@ static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
   return scope.Escape(resolver->GetPromise());
 }
-}
\ No newline at end of file
+}
diff --git a/NativeScript/runtime/Runtime.mm b/NativeScript/runtime/Runtime.mm
index fb8aefbb..843ccf98 100644
--- a/NativeScript/runtime/Runtime.mm
+++ b/NativeScript/runtime/Runtime.mm
@@ -29,6 +29,10 @@
 #include "URLPatternImpl.h"
 #include "URLSearchParamsImpl.h"
 #include <mutex>
+#include "HMRSupport.h"
+#include "HMRSupport.mm"
+#include "DevFlags.h"
+#include "DevFlags.mm"
 
 #define STRINGIZE(x) #x
 #define STRINGIZE_VALUE_OF(x) STRINGIZE(x)
@@ -110,6 +114,15 @@ static void InitializeImportMetaObject(Local<Context> context, Local<Module> mod
           context, String::NewFromUtf8(isolate, "dirname", NewStringType::kNormal).ToLocalChecked(),
           dirnameStr)
       .Check();
+
+  if (RuntimeConfig.IsDebug) {
+    // Attach minimal import.meta.hot only in dev
+    try {
+      tns::InitializeImportMetaHot(isolate, context, meta, modulePath);
+    } catch (...) {
+      // If anything fails, keep meta without hot to avoid crashing
+    }
+  }
 }
 
 namespace tns {
diff --git a/TestRunner/Info.plist b/TestRunner/Info.plist
index 3bb3fc9f..27e10de0 100644
--- a/TestRunner/Info.plist
+++ b/TestRunner/Info.plist
@@ -1,39 +1,48 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>$(DEVELOPMENT_LANGUAGE)</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-	<key>NSAppleMusicUsageDescription</key>
-	<string>Listen Music</string>
-	<key>UIRequiredDeviceCapabilities</key>
-	<array>
-		<string>armv7</string>
-	</array>
-	<key>UISupportedInterfaceOrientations</key>
-	<array/>
-	<key>UISupportedInterfaceOrientations~ipad</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-</dict>
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>$(DEVELOPMENT_LANGUAGE)</string>
+		<key>CFBundleExecutable</key>
+		<string>$(EXECUTABLE_NAME)</string>
+		<key>CFBundleIdentifier</key>
+		<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundleName</key>
+		<string>$(PRODUCT_NAME)</string>
+		<key>CFBundlePackageType</key>
+		<string>APPL</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+		<key>LSRequiresIPhoneOS</key>
+		<true/>
+		<key>NSAppleMusicUsageDescription</key>
+		<string>Listen Music</string>
+		<key>UIRequiredDeviceCapabilities</key>
+		<array>
+			<string>armv7</string>
+		</array>
+		<key>UISupportedInterfaceOrientations</key>
+		<array/>
+		<key>UISupportedInterfaceOrientations~ipad</key>
+		<array>
+			<string>UIInterfaceOrientationPortrait</string>
+			<string>UIInterfaceOrientationPortraitUpsideDown</string>
+			<string>UIInterfaceOrientationLandscapeLeft</string>
+			<string>UIInterfaceOrientationLandscapeRight</string>
+		</array>
+		<key>NSAppTransportSecurity</key>
+		<dict>
+			<key>NSAllowsArbitraryLoads</key>
+			<true/>
+			<key>NSAllowsArbitraryLoadsForMedia</key>
+			<true/>
+			<key>NSAllowsArbitraryLoadsInWebContent</key>
+			<true/>
+		</dict>
+	</dict>
 </plist>
diff --git a/TestRunner/app/tests/HttpEsmLoaderTests.js b/TestRunner/app/tests/HttpEsmLoaderTests.js
new file mode 100644
index 00000000..50e4c5ab
--- /dev/null
+++ b/TestRunner/app/tests/HttpEsmLoaderTests.js
@@ -0,0 +1,200 @@
+// HTTP ESM Loader Tests
+// Test the dev-only HTTP ESM loader functionality for fetching modules remotely
+
+describe("HTTP ESM Loader", function() {
+    
+    describe("URL Resolution", function() {
+        it("should handle relative imports", function(done) {
+            import("~/tests/esm/relative/entry.mjs").then(function(module) {
+                expect(module.viaDefault).toBe("relative-import-success");
+                expect(module.viaNamed).toBe("relative-import-success");
+                expect(module.readDependencyPayload()).toBe(true);
+                done();
+            }).catch(function(error) {
+                fail("Relative import module should resolve: " + error.message);
+                done();
+            });
+        });
+        it("should surface helpful errors for unresolved bare specifiers", function(done) {
+            import("bare-spec-example").then(function(mod) {
+                // Placeholder modules export a default Proxy. Accessing a property on that proxy
+                // should throw with a helpful error message containing the specifier.
+                let threw = false;
+                try {
+                    // Trigger the proxy's get trap by accessing a property on the default export
+                    // eslint-disable-next-line no-unused-expressions
+                    mod && mod.default && mod.default.__touch__;
+                } catch (useErr) {
+                    threw = true;
+                    const msg = (useErr && useErr.message) ? useErr.message : String(useErr);
+                    expect(msg).toContain("bare-spec-example");
+                }
+                expect(threw).toBe(true);
+                done();
+            }).catch(function(error) {
+                // Other runtimes throw on import; assert message includes the specifier name.
+                const message = (error && error.message) ? error.message : String(error);
+                expect(message).toContain("bare-spec-example");
+                done();
+            });
+        });
+    });
+    
+    describe("HTTP Fetch Integration", function() {
+        
+        it("should attempt HTTP fetch for dev modules", function(done) {
+            // Test by trying to import a module that would trigger HTTP fetch
+            // We'll create a simple test module that the dev server should serve
+            
+            // Test importing a simple ES module from dev server
+            const testModuleSpec = "~/tests/esm/hmr/test-esm-module.mjs";
+            
+            // Use dynamic import to trigger the HTTP ESM loader path
+            import(testModuleSpec).then(function(module) {
+                // If we get here, HTTP fetch + compilation worked
+                expect(module).toBeDefined();
+                done();
+            }).catch(function(error) {
+                // Expected if dev server isn't running or module doesn't exist
+                // The important thing is that it attempted the HTTP path
+                console.log("HTTP ESM fetch failed as expected (no dev server or test module):", error.message);
+                expect(error.message).toContain("Module"); // Should be a module resolution error, not a config error
+                done();
+            });
+        });
+        
+        it("should fall back to filesystem when HTTP fetch fails", function(done) {
+            // Import a simple local ESM module that exists in the bundle but not on dev server
+            import("~/tests/esm/fs-fallback.mjs").then(function(module) {
+                // Should succeed via filesystem fallback
+                expect(module).toBeDefined();
+                expect(module.ok || (module.default && module.default.ok)).toBe(true);
+                done();
+            }).catch(function(error) {
+                // If this fails, it's likely the test module path is wrong
+                fail("Filesystem fallback should have succeeded: " + error.message);
+                done();
+            });
+        });
+    });
+    
+    describe("Module Compilation", function() {
+        
+        it("should compile filesystem-backed ES modules successfully", function(done) {
+            import("~/tests/esm/hmr/test-esm-module.mjs").then(function(module) {
+                expect(module).toBeDefined();
+                expect(module.testValue).toBe("http-esm-loaded");
+                expect(typeof module.default).toBe("function");
+                expect(module.default()).toContain("HTTP ESM loader working");
+                done();
+            }).catch(function(error) {
+                fail("Expected module compilation to succeed: " + error.message);
+                done();
+            });
+        });
+        
+        it("should reuse compiled modules across multiple dynamic imports", function(done) {
+            const spec = "~/tests/esm/hmr/test-esm-module.mjs";
+            Promise.all([import(spec), import(spec)]).then(function(results) {
+                const first = results[0];
+                const second = results[1];
+                expect(first).toBeDefined();
+                expect(second).toBeDefined();
+                expect(first.timestamp).toBe(second.timestamp);
+                done();
+            }).catch(function(error) {
+                fail("Expected module reuse to succeed: " + error.message);
+                done();
+            });
+        });
+    });
+    
+    describe("Error Handling", function() {
+        
+        it("should handle non-200 HTTP responses gracefully", function(done) {
+            // Try to import a module that should return 404
+            import("/nonexistent-module-404.js").then(function(module) {
+                fail("Should not have succeeded for 404 module");
+                done();
+            }).catch(function(error) {
+                // Should gracefully handle HTTP errors and provide meaningful error message
+                expect(error.message).toBeDefined();
+                console.log("404 handling test passed:", error.message);
+                done();
+            });
+        });
+        
+        it("should handle network timeouts", function(done) {
+            // Attempt to import from an unreachable address to test timeout
+            import("http://192.0.2.1:5173/timeout-test.js").then(function(module) {
+                fail("Should not have succeeded for unreachable server");
+                done();
+            }).catch(function(error) {
+                expect(error.message).toBeDefined();
+                console.log("Timeout handling test passed:", error.message);
+                done();
+            });
+        });
+        
+        it("should handle malformed URLs gracefully", function() {
+            // The loader should ignore malformed http specifiers
+            expect(function() {
+                import("http://");
+            }).not.toThrow();
+        });
+    });
+    
+    describe("Integration with HMR", function() {
+        
+        it("should expose import.meta.hot with a working invalidate hook", function(done) {
+            import("~/tests/esm/hmr/test-esm-module.mjs").then(function(module) {
+                const hot = module.getHotContext();
+                if (!hot) {
+                    // In release builds import.meta.hot is stripped; ensure helper reports false.
+                    expect(module.callInvalidateSafe()).toBe(false);
+                    done();
+                    return;
+                }
+                expect(module.callInvalidateSafe()).toBe(true);
+                expect(typeof hot.invalidate).toBe("function");
+                done();
+            }).catch(function(error) {
+                fail("Expected to access HMR helpers: " + error.message);
+                done();
+            });
+        });
+        
+        it("should provide stable accept and dispose hooks", function(done) {
+            import("~/tests/esm/hmr/test-esm-module.mjs").then(function(module) {
+                const hot = module.getHotContext();
+                if (!hot) {
+                    // Nothing to assert in release builds; ensure helper reported correctly.
+                    expect(module.callInvalidateSafe()).toBe(false);
+                    done();
+                    return;
+                }
+                expect(typeof hot.accept).toBe("function");
+                expect(typeof hot.dispose).toBe("function");
+                expect(typeof hot.invalidate).toBe("function");
+                done();
+            }).catch(function(error) {
+                fail("Expected import.meta.hot hook inspection to succeed: " + error.message);
+                done();
+            });
+        });
+    });
+});
+
+// Helper function to create a test dev server module (if dev server is running)
+function createTestDevModule() {
+    return `
+// Test ES module for HTTP ESM loader
+export const testValue = "http-esm-loaded";
+export default function testFunction() {
+    return "HTTP ESM loader working";
+}
+export { testFunction as namedExport };
+`;
+}
+
+console.log("HTTP ESM Loader tests loaded");
\ No newline at end of file
diff --git a/TestRunner/app/tests/Infrastructure/Jasmine/jasmine-reporters/terminal_reporter.js b/TestRunner/app/tests/Infrastructure/Jasmine/jasmine-reporters/terminal_reporter.js
index 77a6bb51..ab31ba2c 100644
--- a/TestRunner/app/tests/Infrastructure/Jasmine/jasmine-reporters/terminal_reporter.js
+++ b/TestRunner/app/tests/Infrastructure/Jasmine/jasmine-reporters/terminal_reporter.js
@@ -127,6 +127,10 @@
             totalSpecsExecuted++;
 
             if (self.verbosity === 2) {
+                // Print the spec name inline before the marker for clarity
+                if (failed) {
+                    log(indentWithLevel(spec._depth, spec.fullName));
+                }
                 resultText = failed ? 'F' : skipped ? 'S' : '';
             } else if (self.verbosity > 2) {
                 resultText = ' ' + (failed ? 'Failed' : skipped ? 'Skipped' : 'Passed');
@@ -134,11 +138,14 @@
             log(inColor(resultText, color));
 
             if (failed) {
+                // Always include the full spec name after a failure so it's clear what failed
                 if (self.verbosity === 1) {
                     log(spec.fullName);
                 } else if (self.verbosity === 2) {
                     log(' ');
                     log(indentWithLevel(spec._depth, spec.fullName));
+                } else if (self.verbosity > 2) {
+                    log(indentWithLevel(spec._depth, spec.fullName));
                 }
 
                 for (var i = 0, failure; i < spec.failedExpectations.length; i++) {
diff --git a/TestRunner/app/tests/esm/fs-fallback.mjs b/TestRunner/app/tests/esm/fs-fallback.mjs
new file mode 100644
index 00000000..5c1bd141
--- /dev/null
+++ b/TestRunner/app/tests/esm/fs-fallback.mjs
@@ -0,0 +1,3 @@
+// Simple ESM module to validate filesystem fallback loading
+export const ok = true;
+export default { ok };
diff --git a/TestRunner/app/tests/esm/hmr/test-esm-module.mjs b/TestRunner/app/tests/esm/hmr/test-esm-module.mjs
new file mode 100644
index 00000000..7d8ee4e2
--- /dev/null
+++ b/TestRunner/app/tests/esm/hmr/test-esm-module.mjs
@@ -0,0 +1,34 @@
+// Test ES module for HTTP ESM loader validation (HMR-specific)
+export const testValue = "http-esm-loaded";
+export const timestamp = Date.now();
+
+const hotContext = (typeof import.meta !== "undefined" && import.meta) ? import.meta.hot : undefined;
+
+if (typeof globalThis !== "undefined") {
+    globalThis.__nsLastHttpEsmHotContext = hotContext;
+}
+
+export function getHotContext() {
+    return hotContext;
+}
+
+export function callInvalidateSafe() {
+    if (!hotContext || typeof hotContext.invalidate !== "function") {
+        return false;
+    }
+    hotContext.invalidate();
+    return true;
+}
+
+export default function testFunction() {
+    return "HTTP ESM loader working at " + new Date().toISOString();
+}
+
+export { testFunction as namedExport };
+
+// For HMR testing
+export function getRandomValue() {
+    return Math.random();
+}
+
+console.log("Test ESM module loaded via HTTP loader (HMR)");
\ No newline at end of file
diff --git a/TestRunner/app/tests/esm/relative/dependency.mjs b/TestRunner/app/tests/esm/relative/dependency.mjs
new file mode 100644
index 00000000..1f34b272
--- /dev/null
+++ b/TestRunner/app/tests/esm/relative/dependency.mjs
@@ -0,0 +1,11 @@
+// Dependency module used to exercise relative import resolution in the HTTP ESM loader tests
+export const relativeValue = "relative-import-success";
+
+export function getDependencyPayload() {
+    return {
+        from: "dependency",
+        timestamp: Date.now(),
+    };
+}
+
+export default relativeValue;
diff --git a/TestRunner/app/tests/esm/relative/entry.mjs b/TestRunner/app/tests/esm/relative/entry.mjs
new file mode 100644
index 00000000..0f11e041
--- /dev/null
+++ b/TestRunner/app/tests/esm/relative/entry.mjs
@@ -0,0 +1,10 @@
+// Entry module that re-exports values from a relative dependency
+import defaultValue, { relativeValue, getDependencyPayload } from "./dependency.mjs";
+
+export const viaDefault = defaultValue;
+export const viaNamed = relativeValue;
+
+export function readDependencyPayload() {
+    const payload = getDependencyPayload();
+    return typeof payload === "object" && payload.from === "dependency";
+}
diff --git a/TestRunner/app/tests/index.js b/TestRunner/app/tests/index.js
index e7e8d9b4..5fd346fb 100644
--- a/TestRunner/app/tests/index.js
+++ b/TestRunner/app/tests/index.js
@@ -84,6 +84,9 @@ require("./URL");
 require("./URLSearchParams");
 require("./URLPattern");
 
+// HTTP ESM Loader tests
+require("./HttpEsmLoaderTests");
+
 // Exception handling tests
 require("./ExceptionHandlingTests");
 
diff --git a/package.json b/package.json
index de9f8062..c7cb3e72 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "8.9.5",
+  "version": "9.0.0-alpha.10",
   "keywords": [
     "NativeScript",
     "iOS",