perf(runtime): move this branch's hash containers to robin_hood

Maintainer feedback: std::unordered_map should not be used here at all —
the repo vendors robin_hood.h (already the convention in Caches.h,
MetadataBuilder.mm, SetTimeout.cpp, ModuleInternal.h) and this branch's
new containers were the stragglers. Swapped: the per-isolate module
registry maps and state table, the import map, the module/dynamic-import
waiter maps, the re-entry guard sets, the prewarm cache, and the
cache-bust key set. ModuleHandleMap moves into ModuleInternalCallbacks.h
so the registry accessor's public signature names one type.

robin_hood picks its node-based, reference-stable layout automatically
for value types that are not nothrow-movable (v8::Global), and the
waiter maps are used strictly find/drain/erase, so no usage pattern
relies on stability the flat layout would lose.

std::unordered_map uses that predate the branch (Runtime.mm, Interop.mm,
Metadata.mm, ...) are main's to sweep separately.

Author: NathanWalker

NativeScript/runtime/HMRSupport.mm

@@ -8,14 +8,13 @@
 #include <atomic>
 #include <mutex>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>
 #include "Helpers.h"
 #include "ModuleInternalCallbacks.h"
 #include "Runtime.h"
 #include "RuntimeConfig.h"
 #include "Worker.h"
+#include "robin_hood.h"
 
 // Use centralized dev flags helper for logging
 
@@ -165,7 +164,8 @@ void SetDevBootComplete(v8::Isolate* isolate, v8::Local<v8::Context> context, bo
   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);
+    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);
@@ -200,7 +200,7 @@ void SetDevBootComplete(v8::Isolate* isolate, v8::Local<v8::Context> context, bo
 // enters the module registry key (identity stays the canonical URL),
 // and the server and the registry never see a varied URL.
 static std::mutex g_bustNextFetchMutex;
-static std::unordered_set<std::string> g_bustNextFetchKeys;
+static robin_hood::unordered_set<std::string> g_bustNextFetchKeys;
 
 void MarkUrlsForCacheBust(const std::vector<std::string>& urls) {
   if (urls.empty()) return;
@@ -277,7 +277,7 @@ static bool PerformHttpFetchOnceSync(const std::string& url, std::string& out,
 static inline void InvokeHttpFetchYield();
 
 static std::mutex g_prefetchMutex;
-static std::unordered_map<std::string, std::string> g_prefetchCache;
+static robin_hood::unordered_map<std::string, std::string> g_prefetchCache;
 
 // Always-on diagnostic counters. These intentionally do NOT gate behind
 // IsScriptLoadingLogEnabled() — without this signal we cannot tell a
@@ -302,11 +302,12 @@ static bool PerformHttpFetchOnceSync(const std::string& url, std::string& out,
 static std::atomic<size_t> g_fetchSyncSlow{0};    // >=100ms
 static constexpr size_t kFetchSyncSummaryEvery = 100;
 
-bool HttpFetchText(const std::string& url, std::string& out, std::string& contentType, int& status) {
+bool HttpFetchText(const std::string& url, std::string& out, std::string& contentType,
+                   int& status) {
   // Security gate: check if remote module loading is allowed before any HTTP fetch.
   // This is the single point of enforcement for all HTTP module loading.
   if (!IsRemoteUrlAllowed(url)) {
-    status = 403; // Forbidden
+    status = 403;  // Forbidden
     if (IsScriptLoadingLogEnabled()) {
       Log(@"[http-esm][security][blocked] %s", url.c_str());
     }
@@ -478,7 +479,10 @@ static bool PerformHttpFetchOnceSync(const std::string& url, std::string& out,
     }
 
     NSURL* u = [NSURL URLWithString:[NSString stringWithUTF8String:fetchUrl.c_str()]];
-    if (!u) { status = 0; return false; }
+    if (!u) {
+      status = 0;
+      return false;
+    }
 
     NSError* err = nil;
     NSInteger httpStatusLocal = 0;
@@ -771,7 +775,7 @@ void ClearHttpModulePrefetchCache() {
 
 struct KickstartContext {
   std::mutex mutex;
-  std::unordered_set<std::string> visited;
+  robin_hood::unordered_set<std::string> visited;
   std::atomic<size_t> fetchedCount{0};
   std::atomic<size_t> bytes{0};
   dispatch_group_t group = nullptr;
@@ -1342,4 +1346,4 @@ void InitializeHmrDevGlobals(v8::Isolate* isolate, v8::Local<v8::Context> contex
   MirrorGlobalOnGlobalThis(isolate, context, "__NS_DEV__");
 }
 
-} // namespace tns
+}  // namespace tns

NativeScript/runtime/ModuleInternalCallbacks.h

@@ -3,19 +3,24 @@
 #include <v8.h>
 
 #include <string>
-#include <unordered_map>
 #include <vector>
 
+#include "robin_hood.h"
+
 namespace tns {
 
+// Canonical module key → compiled-module handle map used by the per-isolate
+// registries below.
+using ModuleHandleMap =
+    robin_hood::unordered_map<std::string, v8::Global<v8::Module>>;
+
 // Per-isolate module registry accessor: map canonical keys → compiled
 // v8::Module handles for `isolate`. Keyed by v8::Isolate* (not thread) because
 // v8::Global<Module> handles are isolate-bound; see the long-form comment above
 // the definition in ModuleInternalCallbacks.mm for the cross-isolate-handle bug
 // this prevents. Callers bind a local alias, e.g.
 // `auto& g_moduleRegistry = tns::ModuleRegistryFor(isolate);`.
-std::unordered_map<std::string, v8::Global<v8::Module>>& ModuleRegistryFor(
-    v8::Isolate* isolate);
+ModuleHandleMap& ModuleRegistryFor(v8::Isolate* isolate);
 
 // Reset + drop every module handle owned by `isolate`. Must be called while the
 // isolate is still alive (the Runtime destructor calls this before disposal).

NativeScript/runtime/ModuleInternalCallbacks.mm

@@ -11,8 +11,6 @@
 #include <mutex>
 #include <queue>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>
 #include "DevFlags.h"
 #include "HMRSupport.h"
@@ -270,8 +268,6 @@ static inline bool StartsWith(const std::string& s, const char* prefix) {
 }
 
 namespace {
-using ModuleHandleMap = std::unordered_map<std::string, v8::Global<v8::Module>>;
-
 // The four module-handle maps for a single isolate. v8::Global<Module> handles
 // are bound to the isolate that created them, so each isolate (main + every
 // Worker) keeps its own set; they are looked up by v8::Isolate* below.
@@ -289,9 +285,10 @@ static inline bool StartsWith(const std::string& s, const char* prefix) {
   return *mutex;
 }
 
-std::unordered_map<v8::Isolate*, std::unique_ptr<PerIsolateModuleState>>& ModuleStateTable() {
+robin_hood::unordered_map<v8::Isolate*, std::unique_ptr<PerIsolateModuleState>>&
+ModuleStateTable() {
   static auto* table =
-      new std::unordered_map<v8::Isolate*, std::unique_ptr<PerIsolateModuleState>>();
+      new robin_hood::unordered_map<v8::Isolate*, std::unique_ptr<PerIsolateModuleState>>();
   return *table;
 }
 
@@ -336,7 +333,7 @@ static inline bool StartsWith(const std::string& s, const char* prefix) {
 // Each access site binds a local reference (e.g.
 // `auto& g_moduleRegistry = ModuleRegistryFor(isolate);`) so existing bodies
 // stay byte-for-byte the same while becoming isolate-correct.
-std::unordered_map<std::string, v8::Global<v8::Module>>& ModuleRegistryFor(v8::Isolate* isolate) {
+ModuleHandleMap& ModuleRegistryFor(v8::Isolate* isolate) {
   return ModuleStateFor(isolate).registry;
 }
 
@@ -378,7 +375,7 @@ void DestroyModuleStateForIsolate(v8::Isolate* isolate) {
 // Instead of rewriting import statements in source code on the Vite side, the runtime
 // resolves bare specifiers through this map to either vendor URLs (ns-vendor://)
 // or HTTP module URLs. Source code is served as Vite transformed it.
-static std::unordered_map<std::string, std::string> g_importMap;
+static robin_hood::unordered_map<std::string, std::string> g_importMap;
 
 // Volatile URL patterns: URLs matching these substrings are always re-fetched
 // (cache is evicted before loading). Configured by Vite at boot instead of
@@ -1100,7 +1097,7 @@ void InvalidateModules(v8::Isolate* isolate, v8::Local<v8::Context> context,
   auto& g_moduleRegistry = ModuleRegistryFor(isolate);
   if (urls.empty()) return;
 
-  std::unordered_set<std::string> seen;
+  robin_hood::unordered_set<std::string> seen;
   std::vector<std::string> uniqueUrls;
   uniqueUrls.reserve(urls.size());
 
@@ -1216,12 +1213,12 @@ void UpdateModuleFallback(v8::Isolate* isolate, const std::string& canonicalPath
 
 // 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>>
+static thread_local robin_hood::unordered_map<std::string, size_t> g_moduleReentryCounts;
+static thread_local robin_hood::unordered_map<std::string, robin_hood::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 thread_local robin_hood::unordered_map<std::string, std::string> g_modulePrimaryImporters;
+static thread_local robin_hood::unordered_set<std::string> g_modulesInFlight;
+static thread_local robin_hood::unordered_set<std::string> g_modulesPendingReset;
 // The threshold for detecting circular dependencies during module resolution.
 // 256 was chosen as a high enough value to allow deep but legitimate module graphs,
 // but low enough to catch runaway recursion or infinite circular imports.
@@ -1230,10 +1227,11 @@ void UpdateModuleFallback(v8::Isolate* isolate, const std::string& canonicalPath
 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>>>
+static robin_hood::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>>>
+static thread_local robin_hood::unordered_map<std::string,
+                                              std::vector<v8::Global<v8::Promise::Resolver>>>
     g_httpDynamicWaiters;
 
 static bool IsModuleEvaluationInProgress(v8::Module::Status status) {