if (source.size() >= 2 && source[0] == '#' && source[1] == '!') {

size_t lineEnd = source.find('\n');

if (lineEnd != std::string::npos) {

return source.substr(lineEnd + 1);

}

return ""; // Entire file is just a shebang

}

return source;

std::filesystem::path current = startDir;

while (!current.empty() && current != current.root_path()) {

std::filesystem::path packagePath = current / "package.json";

std::error_code ec;

if (std::filesystem::exists(packagePath, ec) && !ec) {

return packagePath.string();

}

current = current.parent_path();

}

return "";

auto cacheIt = g_packageTypeCache.find(packageJsonPath);

if (cacheIt != g_packageTypeCache.end()) {

return cacheIt->second;

}

bool isModule = false;

std::ifstream file(packageJsonPath);

if (file.is_open()) {

std::string content((std::istreambuf_iterator<char>(file)),

std::istreambuf_iterator<char>());

file.close();

// Simple JSON parsing for "type": "module"

// Look for "type" followed by : and "module"

size_t typePos = content.find("\"type\"");

if (typePos != std::string::npos) {

size_t colonPos = content.find(':', typePos + 6);

if (colonPos != std::string::npos) {

size_t valueStart = content.find('"', colonPos + 1);

if (valueStart != std::string::npos) {

size_t valueEnd = content.find('"', valueStart + 1);

if (valueEnd != std::string::npos) {

std::string typeValue =

content.substr(valueStart + 1, valueEnd - valueStart - 1);

isModule = (typeValue == "module");

}

}

}

}

}

g_packageTypeCache[packageJsonPath] = isModule;

return isModule;

std::filesystem::path filePath(path);

std::string packageJson = FindPackageJson(filePath.parent_path());

if (!packageJson.empty()) {

return IsPackageTypeModule(packageJson);

}

return false; // Default to CommonJS

std::error_code ec;

auto absolutePath = std::filesystem::absolute(path, ec);

if (ec) {

ec.clear();

absolutePath = path;

}

auto normalizedPath = absolutePath.lexically_normal();

auto canonicalPath = std::filesystem::weakly_canonical(normalizedPath, ec);

if (!ec) {

return canonicalPath.string();

}

return normalizedPath.string();

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

for (auto& kv : g_moduleRegistry) {

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

if (registered == module) {

return kv.first;

}

}

return "";

if (modulePath.rfind("file://", 0) == 0) {

return modulePath;

}

if (modulePath.rfind("nativescript:", 0) == 0) {

return modulePath;

}

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

return "file://" + modulePath;

}

return "file:///" + modulePath;

static const std::unordered_set<std::string> kBuiltins = {

"url", "node:url", "fs", "node:fs", "fs/promises", "node:fs/promises",

"path", "node:path", "web", "node:web", "stream/web", "node:stream/web"};

return kBuiltins.contains(specifier);

if (specifier.rfind("node:", 0) == 0) {

return specifier.substr(5);

}

return specifier;

std::string escaped;

escaped.reserve(value.size());

for (char c : value) {

switch (c) {

case '\\':

escaped += "\\\\";

break;

case '\'':

escaped += "\\'";

break;

case '\n':

escaped += "\\n";

break;

case '\r':

escaped += "\\r";

break;

default:

escaped += c;

break;

}

}

return escaped;

const std::string& specifier) {

auto it = nativescript::napiModuleRegistry.find(specifier);

if (it != nativescript::napiModuleRegistry.end() && it->second != nullptr) {

return specifier;

}

if (specifier.rfind("node:", 0) == 0) {

std::string withoutPrefix = specifier.substr(5);

it = nativescript::napiModuleRegistry.find(withoutPrefix);

if (it != nativescript::napiModuleRegistry.end() && it->second != nullptr) {

return withoutPrefix;

}

}

return "";

std::string normalized = NormalizeRegisteredNapiModuleSpecifier(specifier);

if (normalized.empty()) {

return "";

}

std::string escapedSpecifier = EscapeForSingleQuotedJsString(normalized);

return R"(

const __nativeModule = __load(')" +

escapedSpecifier + R"(');

)";

const auto builtinName = NormalizeNodeBuiltinSpecifier(specifier);

if (builtinName == "url") {

return R"(

)";

}

if (builtinName == "fs") {

return R"(

)";

}

if (builtinName == "fs/promises") {

return R"(

)";

}

if (builtinName == "path") {

return R"(

)";

}

if (builtinName == "web") {

return R"(

)";

}

if (builtinName == "stream/web") {

return R"(

)";

}

return "";

// .mjs is always ESM

if (path.size() >= 4 && path.compare(path.size() - 4, 4, ".mjs") == 0) {

return true;

}

// .cjs is always CommonJS

if (IsCJSModule(path)) {

return false;

}

// .js files: check package.json "type" field

if (path.size() >= 3 && path.compare(path.size() - 3, 3, ".js") == 0) {

return ShouldTreatAsESModule(path);

}

return false;

std::ifstream file(path);

if (!file.is_open()) {

throw std::runtime_error("Cannot open file: " + path);

}

std::stringstream buffer;

buffer << file.rdbuf();

return StripShebang(buffer.str());

const std::string& path) {

std::string sourceText = ReadFileContent(path);

if (IsJSONModule(path)) {

std::string wrappedJsonModule = "export default " + sourceText + ";";

return v8::String::NewFromUtf8(isolate, wrappedJsonModule.c_str())

.ToLocalChecked();

}

if (IsESModule(path)) {

// For ES modules, return source as-is to preserve import/export syntax

return v8::String::NewFromUtf8(isolate, sourceText.c_str())

.ToLocalChecked();

}

// For CommonJS modules, wrap in factory function

std::string wrappedSource =

"(function (exports, require, module, __filename, __dirname) { " +

sourceText + "\n});";

return v8::String::NewFromUtf8(isolate, wrappedSource.c_str())

.ToLocalChecked();

const std::string& baseDir,

const std::string& moduleName) {

std::string moduleNameCopy = moduleName;

// Keep "~" alias behavior aligned with CommonJS resolution.

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

moduleNameCopy = RuntimeConfig.ApplicationPath + moduleNameCopy.substr(1);

}

std::filesystem::path baseDirPath(baseDir);

std::filesystem::path moduleNamePath(moduleNameCopy);

std::filesystem::path fullPath = baseDirPath / moduleNamePath;

// Check if file exists as-is

if (std::filesystem::exists(fullPath) &&

std::filesystem::is_regular_file(fullPath)) {

return NormalizeModulePath(fullPath);

}

// Try with .mjs extension first (ES modules have priority)

std::filesystem::path mjsPath = fullPath.string() + ".mjs";

if (std::filesystem::exists(mjsPath) &&

std::filesystem::is_regular_file(mjsPath)) {

return NormalizeModulePath(mjsPath);

}

// Try with .js extension

std::filesystem::path jsPath = fullPath.string() + ".js";

if (std::filesystem::exists(jsPath) &&

std::filesystem::is_regular_file(jsPath)) {

return NormalizeModulePath(jsPath);

}

// Try with .cjs extension (explicit CommonJS)

std::filesystem::path cjsPath = fullPath.string() + ".cjs";

if (std::filesystem::exists(cjsPath) &&

std::filesystem::is_regular_file(cjsPath)) {

return NormalizeModulePath(cjsPath);

}

// Try directory with index.mjs

if (std::filesystem::exists(fullPath) &&

std::filesystem::is_directory(fullPath)) {

std::filesystem::path indexMjs = fullPath / "index.mjs";

if (std::filesystem::exists(indexMjs) &&

std::filesystem::is_regular_file(indexMjs)) {

return NormalizeModulePath(indexMjs);

}

// Try directory with index.js

std::filesystem::path indexJs = fullPath / "index.js";

if (std::filesystem::exists(indexJs) &&

std::filesystem::is_regular_file(indexJs)) {

return NormalizeModulePath(indexJs);

}

// Try directory with index.cjs

std::filesystem::path indexCjs = fullPath / "index.cjs";

if (std::filesystem::exists(indexCjs) &&

std::filesystem::is_regular_file(indexCjs)) {

return NormalizeModulePath(indexCjs);

}

}

throw std::runtime_error("Module not found: " + moduleName);

const std::string& path) {

const std::string absPath = NormalizeModulePath(path);

// Check if already compiled

auto it = g_moduleRegistry.find(absPath);

if (it != g_moduleRegistry.end()) {

v8::Local<v8::Module> existing = it->second.Get(isolate);

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

}

// Prepare URL & source - use the absolute path consistently

v8::Local<v8::String> sourceText = WrapModuleContent(isolate, absPath);

#if V8_MAJOR_VERSION >= 14

v8::ScriptOrigin origin(

v8::String::NewFromUtf8(isolate, absPath.c_str()).ToLocalChecked(), 0, 0,

false, -1, v8::Local<v8::Value>(), false, false,

true // is_module

);

#else

v8::ScriptOrigin origin(

isolate,

v8::String::NewFromUtf8(isolate, absPath.c_str()).ToLocalChecked(), 0, 0,

false, -1, v8::Local<v8::Value>(), false, false,

true // is_module

);

#endif

v8::ScriptCompiler::Source source(sourceText, origin);

// Compile ES module

v8::Local<v8::Module> module;

v8::MaybeLocal<v8::Module> maybeMod = v8::ScriptCompiler::CompileModule(

isolate, &source, v8::ScriptCompiler::kNoCompileOptions);

if (!maybeMod.ToLocal(&module)) {

// Compilation failed - return empty MaybeLocal, let V8 handle the

// JavaScript exception

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

}

// Register in global registry with absolute path

g_moduleRegistry[absPath].Reset(isolate, module);

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

const std::string& moduleId,

const std::string& source) {

auto it = g_moduleRegistry.find(moduleId);

if (it != g_moduleRegistry.end()) {

v8::Local<v8::Module> existing = it->second.Get(isolate);

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

}

v8::Local<v8::String> sourceText =

v8::String::NewFromUtf8(isolate, source.c_str()).ToLocalChecked();

#if V8_MAJOR_VERSION >= 14

v8::ScriptOrigin origin(

v8::String::NewFromUtf8(isolate, moduleId.c_str()).ToLocalChecked(), 0, 0,

false, -1, v8::Local<v8::Value>(), false, false, true);

#else

v8::ScriptOrigin origin(

isolate,

v8::String::NewFromUtf8(isolate, moduleId.c_str()).ToLocalChecked(), 0, 0,

false, -1, v8::Local<v8::Value>(), false, false, true);

#endif

v8::ScriptCompiler::Source scriptSource(sourceText, origin);

v8::Local<v8::Module> module;

v8::MaybeLocal<v8::Module> maybeMod = v8::ScriptCompiler::CompileModule(

isolate, &scriptSource, v8::ScriptCompiler::kNoCompileOptions);

if (!maybeMod.ToLocal(&module)) {

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

}

g_moduleRegistry[moduleId].Reset(isolate, module);

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

const std::string& path) {

auto context = isolate->GetCurrentContext();

const std::string absPath = NormalizeModulePath(path);

// First, compile the module and all its dependencies

v8::MaybeLocal<v8::Module> maybeModule = CompileESModule(isolate, absPath);

v8::Local<v8::Module> module;

if (!maybeModule.ToLocal(&module)) {

// Compilation failed - throw exception

throw std::runtime_error("Cannot compile ES module: " + absPath);

}

// Instantiate (link) - this will recursively resolve dependencies

v8::TryCatch tcLink(isolate);

bool linked = module->InstantiateModule(context, &ResolveModuleCallback)

.FromMaybe(false);

if (!linked) {

if (tcLink.HasCaught()) {

v8::String::Utf8Value error(isolate, tcLink.Exception());

throw std::runtime_error("Cannot instantiate module " + absPath + ": " +

std::string(*error));

} else {

throw std::runtime_error("Cannot instantiate module " + absPath);

}

}

// Evaluate

v8::Local<v8::Value> result;

v8::TryCatch tcEval(isolate);

if (!module->Evaluate(context).ToLocal(&result)) {

if (tcEval.HasCaught()) {

v8::String::Utf8Value error(isolate, tcEval.Exception());

throw std::runtime_error("Cannot evaluate module " + absPath + ": " +

std::string(*error));

} else {

throw std::runtime_error("Cannot evaluate module " + absPath);

}

}

// Handle top-level await (if result is a Promise)

if (result->IsPromise()) {

v8::Local<v8::Promise> promise = result.As<v8::Promise>();

// Process microtasks to allow Promise resolution

int maxAttempts = 100;

int attempts = 0;

while (attempts < maxAttempts) {

isolate->PerformMicrotaskCheckpoint();

v8::Promise::PromiseState state = promise->State();

if (state != v8::Promise::kPending) {

if (state == v8::Promise::kRejected) {

v8::Local<v8::Value> reason = promise->Result();

isolate->ThrowException(reason);

throw std::runtime_error("Module evaluation promise rejected");

}

break;

}

attempts++;

usleep(100); // 0.1ms delay

}

}

// Return the namespace

return module->GetModuleNamespace();

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

// Convert specifier to std::string

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

std::string spec = *specUtf8 ? *specUtf8 : "";

if (spec.empty()) {

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

}

if (IsNodeBuiltinSpecifier(spec)) {

const auto builtinName = NormalizeNodeBuiltinSpecifier(spec);

const auto source = GetBuiltinESModuleSource(spec);

if (source.empty()) {

std::string errorMsg = "Unsupported builtin module '" + spec + "'";

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

v8::String::NewFromUtf8(isolate, errorMsg.c_str()).ToLocalChecked()));

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

}

const std::string moduleId = "nativescript:node_builtin/" + builtinName;

return CompileVirtualESModule(isolate, moduleId, source);

}

const auto registeredSource = GetRegisteredNapiESModuleSource(spec);

if (!registeredSource.empty()) {

const auto normalized = NormalizeRegisteredNapiModuleSpecifier(spec);

const std::string moduleId = "nativescript:napi_module/" + normalized;

return CompileVirtualESModule(isolate, moduleId, registeredSource);

}

// Find referrer path

std::string referrerPath = GetModulePathFromRegistry(isolate, referrer);

if (referrerPath.empty()) {

// Check if this is a relative import that needs a referrer context

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

if (specIsRelative) {

std::string errorMsg = "Cannot resolve relative module '" + spec +

"': referrer module not found in registry";

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

v8::String::NewFromUtf8(isolate, errorMsg.c_str()).ToLocalChecked()));

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

} else {

char cwd[1024];

if (getcwd(cwd, sizeof(cwd)) != nullptr) {

referrerPath =

std::string(cwd) + "/dummy.mjs"; // Create a dummy referrer path

} else {

std::string errorMsg =

"Cannot resolve module '" + spec +

"': no referrer and cannot get current directory";

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

v8::String::NewFromUtf8(isolate, errorMsg.c_str())

.ToLocalChecked()));

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

}

}

}

// Compute base directory - ensure it's absolute

std::filesystem::path referrerFilePath = NormalizeModulePath(referrerPath);

std::string baseDir = referrerFilePath.parent_path().string();

// Resolve the module path

std::string absPath;

try {

absPath = ResolveESModulePath(isolate, baseDir, spec);

} catch (const std::exception& e) {

std::string errorMsg = "Cannot resolve module '" + spec + "': " + e.what();

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

v8::String::NewFromUtf8(isolate, errorMsg.c_str()).ToLocalChecked()));

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

}

v8::MaybeLocal<v8::Module> maybeModule = CompileESModule(isolate, absPath);

if (maybeModule.IsEmpty()) {

// Compilation failed - throw an exception if none exists

std::string errorMsg = "Failed to compile module: " + absPath;

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

v8::String::NewFromUtf8(isolate, errorMsg.c_str()).ToLocalChecked()));

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

}

return maybeModule;

v8::Local<v8::Context> context, v8::Local<v8::Data> host_defined_options,

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

v8::Local<v8::FixedArray> import_assertions) {

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

v8::EscapableHandleScope scope(isolate);

// Create Promise resolver

v8::Local<v8::Promise::Resolver> resolver =

v8::Promise::Resolver::New(context).ToLocalChecked();

try {

// Use the static resolver to locate/compile the module

v8::Local<v8::Module> refMod;

v8::MaybeLocal<v8::Module> maybeModule =

ResolveModuleCallback(context, specifier, import_assertions, refMod);

v8::Local<v8::Module> module;

if (!maybeModule.ToLocal(&module)) {

resolver

->Reject(context,

v8::Exception::Error(v8::String::NewFromUtf8(

isolate, "Failed to resolve module")

.ToLocalChecked()))

.Check();

isolate->PerformMicrotaskCheckpoint();

return scope.Escape(resolver->GetPromise());

}

// If not yet instantiated/evaluated, do it now

if (module->GetStatus() == v8::Module::kUninstantiated) {

if (!module->InstantiateModule(context, &ResolveModuleCallback)

.FromMaybe(false)) {

resolver

->Reject(context, v8::Exception::Error(

v8::String::NewFromUtf8(

isolate, "Failed to instantiate module")

.ToLocalChecked()))

.Check();

isolate->PerformMicrotaskCheckpoint();

return scope.Escape(resolver->GetPromise());

}

}

if (module->GetStatus() != v8::Module::kEvaluated) {

if (module->Evaluate(context).IsEmpty()) {

resolver

->Reject(context, v8::Exception::Error(

v8::String::NewFromUtf8(

isolate, "Failed to evaluate module")

.ToLocalChecked()))

.Check();

isolate->PerformMicrotaskCheckpoint();

return scope.Escape(resolver->GetPromise());

}

}

resolver->Resolve(context, module->GetModuleNamespace()).Check();

isolate->PerformMicrotaskCheckpoint();

} catch (const std::exception& e) {

resolver

->Reject(

context,

v8::Exception::Error(

v8::String::NewFromUtf8(isolate, e.what()).ToLocalChecked()))

.Check();

isolate->PerformMicrotaskCheckpoint();

}

return scope.Escape(resolver->GetPromise());

// Set module resolution and dynamic import callbacks

isolate->SetHostImportModuleDynamicallyCallback(

ImportModuleDynamicallyCallback);

isolate->SetHostInitializeImportMetaObjectCallback(

[](v8::Local<v8::Context> context, v8::Local<v8::Module> module,

v8::Local<v8::Object> meta) {

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

const std::string modulePath =

GetModulePathFromRegistry(isolate, module);

if (modulePath.empty()) {

return;

}

const std::string moduleURL = ModulePathToURL(modulePath);

v8::Local<v8::String> key =

v8::String::NewFromUtf8(isolate, "url").ToLocalChecked();

v8::Local<v8::String> value =

v8::String::NewFromUtf8(isolate, moduleURL.c_str())

.ToLocalChecked();

meta->CreateDataProperty(context, key, value).Check();

});

// Reset all Global handles before V8 isolate cleanup

for (auto& kv : g_moduleRegistry) {

kv.second.Reset();

}

// Clear the registry

g_moduleRegistry.clear();

// Clear the package.json type cache

g_packageTypeCache.clear();