--- a/js/xpconnect/loader/mozJSModuleLoader.cpp
+++ b/js/xpconnect/loader/mozJSModuleLoader.cpp
@@ -445,16 +445,17 @@ void mozJSModuleLoader::FindTargetObject
     }
   }
 }
 
 void mozJSModuleLoader::InitStatics() {
   MOZ_ASSERT(!sSelf);
   sSelf = new mozJSModuleLoader();
   RegisterWeakMemoryReporter(sSelf);
+  NonSharedGlobalSyncModuleLoaderScope::InitStatics();
 }
 
 void mozJSModuleLoader::UnloadLoaders() {
   if (sSelf) {
     sSelf->Unload();
   }
   if (sDevToolsLoader) {
     sDevToolsLoader->Unload();
@@ -1956,63 +1957,67 @@ size_t mozJSModuleLoader::ModuleEntry::S
   n += aMallocSizeOf(location);
 
   return n;
 }
 
 //----------------------------------------------------------------------
 
 /* static */
-mozJSModuleLoader* NonSharedGlobalSyncModuleLoaderScope::sActiveLoader =
-    nullptr;
+MOZ_THREAD_LOCAL(mozJSModuleLoader*)
+NonSharedGlobalSyncModuleLoaderScope::sTlsActiveLoader;
+
+void NonSharedGlobalSyncModuleLoaderScope::InitStatics() {
+  sTlsActiveLoader.infallibleInit();
+}
 
 NonSharedGlobalSyncModuleLoaderScope::NonSharedGlobalSyncModuleLoaderScope(
     JSContext* aCx, nsIGlobalObject* aGlobal) {
-  // Only the main thread is supported for now.
-  MOZ_ASSERT(NS_IsMainThread());
-  MOZ_ASSERT(!mozJSModuleLoader::IsSharedSystemGlobal(aGlobal));
-  MOZ_ASSERT(!mozJSModuleLoader::IsDevToolsLoaderGlobal(aGlobal));
+  MOZ_ASSERT_IF(NS_IsMainThread(),
+                !mozJSModuleLoader::IsSharedSystemGlobal(aGlobal));
+  MOZ_ASSERT_IF(NS_IsMainThread(),
+                !mozJSModuleLoader::IsDevToolsLoaderGlobal(aGlobal));
 
   mAsyncModuleLoader = aGlobal->GetModuleLoader(aCx);
   MOZ_ASSERT(mAsyncModuleLoader,
              "The consumer should guarantee the global returns non-null module "
              "loader");
 
   mLoader = new mozJSModuleLoader();
   RegisterWeakMemoryReporter(mLoader);
   mLoader->InitSyncModuleLoaderForGlobal(aGlobal);
 
   mAsyncModuleLoader->CopyModulesTo(mLoader->mModuleLoader);
 
   mMaybeOverride.emplace(mAsyncModuleLoader, mLoader->mModuleLoader);
 
-  MOZ_ASSERT(!sActiveLoader);
-  sActiveLoader = mLoader;
+  MOZ_ASSERT(!sTlsActiveLoader.get());
+  sTlsActiveLoader.set(mLoader);
 }
 
 NonSharedGlobalSyncModuleLoaderScope::~NonSharedGlobalSyncModuleLoaderScope() {
-  MOZ_ASSERT(sActiveLoader == mLoader);
-  sActiveLoader = nullptr;
+  MOZ_ASSERT(sTlsActiveLoader.get() == mLoader);
+  sTlsActiveLoader.set(nullptr);
 
   mLoader->DisconnectSyncModuleLoaderFromGlobal();
   UnregisterWeakMemoryReporter(mLoader);
 }
 
 void NonSharedGlobalSyncModuleLoaderScope::Finish() {
   mLoader->mModuleLoader->MoveModulesTo(mAsyncModuleLoader);
 }
 
 /* static */
 bool NonSharedGlobalSyncModuleLoaderScope::IsActive() {
-  return !!sActiveLoader;
+  return !!sTlsActiveLoader.get();
 }
 
-/* static */
+/*static */
 mozJSModuleLoader* NonSharedGlobalSyncModuleLoaderScope::ActiveLoader() {
-  return sActiveLoader;
+  return sTlsActiveLoader.get();
 }
 
 //----------------------------------------------------------------------
 
 JSCLContextHelper::JSCLContextHelper(JSContext* aCx)
     : mContext(aCx), mBuf(nullptr) {}
 
 JSCLContextHelper::~JSCLContextHelper() {

--- a/js/xpconnect/loader/mozJSModuleLoader.h
+++ b/js/xpconnect/loader/mozJSModuleLoader.h
@@ -10,16 +10,17 @@
 #include "SyncModuleLoader.h"
 #include "mozilla/Attributes.h"  // MOZ_STACK_CLASS
 #include "mozilla/dom/ScriptSettings.h"
 #include "mozilla/FileLocation.h"
 #include "mozilla/Maybe.h"  // mozilla::Maybe
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/RefPtr.h"  // RefPtr, mozilla::StaticRefPtr
 #include "mozilla/StaticPtr.h"
+#include "mozilla/ThreadLocal.h"  // MOZ_THREAD_LOCAL
 #include "nsIMemoryReporter.h"
 #include "nsISupports.h"
 #include "nsIURI.h"
 #include "nsClassHashtable.h"
 #include "jsapi.h"
 #include "js/experimental/JSStencil.h"
 #include "SkipCheckForBrokenURLOrZeroSized.h"
 
@@ -310,23 +311,25 @@ class MOZ_STACK_CLASS NonSharedGlobalSyn
   void Finish();
 
   // Returns true if another instance of NonSharedGlobalSyncModuleLoaderScope
   // is on stack.
   static bool IsActive();
 
   static mozJSModuleLoader* ActiveLoader();
 
+  static void InitStatics();
+
  private:
   RefPtr<mozJSModuleLoader> mLoader;
 
-  // The module loader on the stack.
+  // Reference to thread-local module loader on the stack.
   // This is used by another sync module load during a sync module load is
   // ongoing.
-  static mozJSModuleLoader* sActiveLoader;
+  static MOZ_THREAD_LOCAL(mozJSModuleLoader*) sTlsActiveLoader;
 
   // The module loader of the target global.
   RefPtr<JS::loader::ModuleLoaderBase> mAsyncModuleLoader;
 
   mozilla::Maybe<JS::loader::AutoOverrideModuleLoader> mMaybeOverride;
 };
 
 }  // namespace mozilla::loader