// ModuleInternalCallbacks.mm

#include "ModuleInternalCallbacks.h"

#import <Foundation/Foundation.h>

#include <dispatch/dispatch.h>

#include <sys/stat.h>

#include <v8.h>

#include <algorithm>

#include <cstddef>

#include <queue>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <vector>

#include "DevFlags.h"

#include "HMRSupport.h"

#include "Helpers.h" // for tns::Exists

#include "ModuleInternal.h" // for LoadScript(...)

#include "NativeScriptException.h"

#include "NsBuiltinModules.h"

#include "Runtime.h" // for GetAppConfigValue

#include "RuntimeConfig.h"

// Do NOT pull all v8 symbols into namespace here; String would clash with

// other typedefs inside the NativeScript codebase. We refer to v8 symbols

// with explicit `v8::` qualification to avoid ambiguities.

namespace tns {

// Helper function to check if a module name is a Node.js built-in module

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());

}

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(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(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(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;

// 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.

// If a module is re-entered more than this limit, module loading is aborted and

// an error is reported to prevent stack overflow or infinite loops.

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,

v8::Local<v8::String> specifier,

v8::Local<v8::FixedArray> import_assertions,

v8::Local<v8::Module> referrer) {

v8::Isolate* isolate = v8::Isolate::GetCurrent();

// 1) Turn the specifier literal into a std::string:

v8::String::Utf8Value specUtf8(isolate, specifier);

const std::string rawSpec = *specUtf8 ? *specUtf8 : "";

if (rawSpec.empty()) {

return v8::MaybeLocal<v8::Module>();

}

// Builtin modules resolve before any path handling. Unshimmed "node:" names

// fall through to the legacy node:url polyfill below.

if (NsBuiltinModules::IsRegistered(rawSpec) || NsBuiltinModules::IsNsScheme(rawSpec)) {

v8::Local<v8::Module> builtin;

if (NsBuiltinModules::GetModule(context, rawSpec).ToLocal(&builtin)) {

return v8::MaybeLocal<v8::Module>(builtin);

}

if (!NsBuiltinModules::IsRegistered(rawSpec)) {

isolate->ThrowException(v8::Exception::Error(

tns::ToV8String(isolate, NsBuiltinModules::NotFoundMessage(rawSpec))));

}

return v8::MaybeLocal<v8::Module>();

}

std::string normalizedSpec = rawSpec;

// 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 (normalizedSpec.rfind("http:/", 0) == 0 && normalizedSpec.rfind("http://", 0) != 0) {

normalizedSpec.insert(5, "/"); // http:/ -> http://

} else if (normalizedSpec.rfind("https:/", 0) == 0 && normalizedSpec.rfind("https://", 0) != 0) {

normalizedSpec.insert(6, "/"); // https:/ -> https://

}

if (IsScriptLoadingLogEnabled()) {

Log(@"[resolver][spec] %s", normalizedSpec.c_str());

}

// Normalize '@/' alias to '/src/' for static imports (mirrors client dynamic import

// normalization)

if (normalizedSpec.rfind("@/", 0) == 0) {

std::string orig = normalizedSpec;

normalizedSpec = std::string("/src/") + normalizedSpec.substr(2);

if (IsScriptLoadingLogEnabled()) {

Log(@"[resolver][normalize] %@ -> %@", [NSString stringWithUTF8String:orig.c_str()],

[NSString stringWithUTF8String:normalizedSpec.c_str()]);

}

}

// Guard against a bare '@' spec showing up (invalid); return empty to avoid poisoning registry

// with '@'

if (normalizedSpec == "@") {

if (IsScriptLoadingLogEnabled()) {

Log(@"[resolver][normalize] ignoring invalid '@' static spec");

}

return v8::MaybeLocal<v8::Module>();

}

const std::string& spec =

normalizedSpec; // use normalized spec for the rest of the resolution logic

// ── Early absolute-HTTP fast path ─────────────────────────────

// If the specifier itself is an absolute HTTP(S) URL, resolve it immediately via

// the HTTP loader and return before any filesystem candidate logic runs.

// Security: HttpFetchText gates remote module access centrally.

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) {

if (IsScriptLoadingLogEnabled()) {

Log("ResolveModuleCallback: Worker trying to resolve '%s'\n", spec.c_str());

}

}

// 2) Find which filepath the referrer was compiled under

std::string referrerPath;

for (auto& kv : g_moduleRegistry) {

v8::Local<v8::Module> registered = kv.second.Get(isolate);

if (registered == referrer) {

referrerPath = kv.first;

break;

}

}

// If we couldn't identify the referrer (e.g. coming from a dynamic import

// where the embedder did not pass the compiled Module), we can still proceed

// for absolute and application-rooted specifiers. Only bail out early when

// the specifier is clearly relative (starts with "./" or "../") and we

// would need the referrer's directory to resolve it.

bool specIsRelative = !spec.empty() && spec[0] == '.';

if (referrerPath.empty() && specIsRelative) {

// For dynamic imports, assume the base directory is the application root

// This handles cases where runtime.mjs calls import("./chunk.mjs")

// but the referrer module isn't properly registered

if (IsScriptLoadingLogEnabled()) {

Log(@"[resolver] No referrer found for relative import '%s', assuming app root",

spec.c_str());

}

referrerPath =

RuntimeConfig.ApplicationPath + "/runtime.mjs"; // Default to runtime.mjs as referrer

}

// 3) Compute its directory

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.

// Security: HttpFetchText gates remote module access centrally.

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://"))) {

// Security: HttpFetchText gates remote module access centrally.

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

// the most common cases so that we locate the actual .mjs file on disk

// before handing the path to LoadScript.

// ────────────────────────────────────────────────

// Build initial absolute path candidates

// ────────────────────────────────────────────────

std::vector<std::string> candidateBases;

if (!spec.empty() && spec[0] == '.') {

// Relative import (./ or ../)

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(),

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

std::string tail = spec.substr(7); // strip file://

if (tail.rfind("/", 0) != 0) {

tail = "/" + tail;

}

// If starts with /app/... drop the leading /app

const std::string appPrefix = "/app/";

std::string tailNoApp = tail;

if (tail.rfind(appPrefix, 0) == 0) {

tailNoApp = tail.substr(appPrefix.size());

}

// Candidate that keeps /app/ prefix stripped

std::string baseNoApp = NormalizePath(RuntimeConfig.ApplicationPath + "/" + tailNoApp);