feat: http loaded es module realms + HMR DX enrichments

test-app/app/src/main/assets/app/mainpage.js

@@ -75,4 +75,4 @@ require('./tests/testQueueMicrotask');
 
 // ES MODULE TESTS
 __log("=== Running ES Modules Tests ===");
-require("./tests/testESModules");
+require("./tests/testESModules.mjs");

test-app/app/src/main/assets/app/tests/testESModules.mjs

@@ -0,0 +1,167 @@
+async function runESModuleTests() {
+  let passed = 0;
+  let failed = 0;
+  const failureDetails = [];
+
+  const recordPass = (message, ...args) => {
+    console.log(`✅ PASS: ${message}`, ...args);
+    passed++;
+  };
+
+  const recordFailure = (message, options = {}) => {
+    const { error, details = [] } = options;
+    const fullMessage = error?.message
+      ? `${message}: ${error.message}`
+      : message;
+    console.log(`❌ FAIL: ${fullMessage}`);
+    details.forEach((detail) => console.log(detail));
+    if (error?.stack) {
+      console.log("Stack trace:", error.stack);
+    }
+    failed++;
+    failureDetails.push(fullMessage);
+  };
+
+  const logFinalSummary = () => {
+    console.log("\n=== ES MODULE TEST RESULTS ===");
+    console.log("Tests passed:", passed);
+    console.log("Tests failed:", failed);
+    console.log("Total tests:", passed + failed);
+
+    if (failed === 0) {
+      console.log("ALL ES MODULE TESTS PASSED!");
+    } else {
+      console.log("SOME ES MODULE TESTS FAILED!");
+      console.log("FAILURE DETECTED: Starting failure logging");
+      failureDetails.forEach((detail) => {
+        console.log(`  ❌ ${detail}`);
+      });
+    }
+  };
+
+  try {
+    // Test 1: Load .mjs files as ES modules
+    console.log("\n--- Test 1: Loading .mjs files as ES modules ---");
+    try {
+      const moduleExports = await import("~/testSimpleESModule.mjs");
+      if (moduleExports && moduleExports !== null) {
+        recordPass("Module exports:", JSON.stringify(moduleExports));
+      } else {
+        recordFailure("ES Module loaded but exports are null");
+      }
+
+      if (moduleExports?.moduleType === "ES Module") {
+        recordPass("moduleType check passed");
+      } else {
+        recordFailure("moduleType check failed");
+      }
+    } catch (e) {
+      recordFailure("Error loading ES module", { error: e });
+    }
+
+    // Test 2: Test import.meta functionality
+    console.log("\n--- Test 2: Testing import.meta functionality ---");
+    try {
+      const importMetaModule = await import("~/testImportMeta.mjs");
+      if (
+        importMetaModule &&
+        importMetaModule.default &&
+        typeof importMetaModule.default === "function"
+      ) {
+        const metaResults = importMetaModule.default();
+        console.log(
+          "import.meta test results:",
+          JSON.stringify(metaResults, null, 2)
+        );
+
+        if (
+          metaResults &&
+          metaResults.hasImportMeta &&
+          metaResults.hasUrl &&
+          metaResults.hasDirname
+        ) {
+          recordPass("import.meta properties present");
+          console.log("   - import.meta.url:", metaResults.url);
+          console.log("   - import.meta.dirname:", metaResults.dirname);
+        } else {
+          recordFailure("import.meta properties missing", {
+            details: [
+              `   - hasImportMeta: ${metaResults?.hasImportMeta}`,
+              `   - hasUrl: ${metaResults?.hasUrl}`,
+              `   - hasDirname: ${metaResults?.hasDirname}`,
+            ],
+          });
+        }
+      } else {
+        recordFailure("import.meta module has no default export function");
+      }
+    } catch (e) {
+      recordFailure("Error testing import.meta", { error: e });
+    }
+
+    // Test 3: Test Worker enhancements
+    console.log("\n--- Test 3: Testing Worker enhancements ---");
+    try {
+      const workerModule = await import("~/testWorkerFeatures.mjs");
+      if (
+        workerModule &&
+        workerModule.testWorkerFeatures &&
+        typeof workerModule.testWorkerFeatures === "function"
+      ) {
+        const workerResults = workerModule.testWorkerFeatures();
+        console.log(
+          "Worker features test results:",
+          JSON.stringify(workerResults, null, 2)
+        );
+
+        if (
+          workerResults &&
+          workerResults.stringPathSupported &&
+          workerResults.urlObjectSupported &&
+          workerResults.tildePathSupported
+        ) {
+          recordPass("Worker enhancement features present");
+          console.log(
+            "   - String path support:",
+            workerResults.stringPathSupported
+          );
+          console.log(
+            "   - URL object support:",
+            workerResults.urlObjectSupported
+          );
+          console.log(
+            "   - Tilde path support:",
+            workerResults.tildePathSupported
+          );
+        } else {
+          recordFailure("Worker enhancement features missing", {
+            details: [
+              `   - stringPathSupported: ${workerResults?.stringPathSupported}`,
+              `   - urlObjectSupported: ${workerResults?.urlObjectSupported}`,
+              `   - tildePathSupported: ${workerResults?.tildePathSupported}`,
+            ],
+          });
+        }
+      } else {
+        recordFailure(
+          "Worker features module has no testWorkerFeatures function"
+        );
+      }
+    } catch (e) {
+      recordFailure("Error testing Worker features", { error: e });
+    }
+  } catch (unexpectedError) {
+    recordFailure("Unexpected ES module test harness failure", {
+      error: unexpectedError,
+    });
+  } finally {
+    logFinalSummary();
+  }
+
+  return { passed, failed };
+}
+
+// Run the tests immediately (avoid top-level await for broader runtime support)
+runESModuleTests().catch((e) => {
+  console.error("ES Module top-level failure:", e && e.message ? e.message : e);
+});

test-app/app/src/main/assets/app/tests/testRuntimeImplementedAPIs.js

@@ -1,30 +1,32 @@
 describe("Runtime exposes", function () {
-  it("__time a low overhead, high resolution, time in ms.", function() {
+  it("__time a low overhead, high resolution, time in ms.", function () {
     // Try to get the times using Date.now and __time and compare the results, expect them to be somewhat "close".
     // Sometimes GC hits after Date.now is captured but before __time or the vice-versa and the test fails,
     // so we are giving it several attempts.
-    for(var i = 0; i < 5; i++) {
+    for (var i = 0; i < 5; i++) {
       try {
         var dateTimeStart = Date.now();
         var timeStart = __time();
         var acc = 0;
         var s = android.os.SystemClock.elapsedRealtime();
         for (var i = 0; i < 1000; i++) {
           var c = android.os.SystemClock.elapsedRealtime();
-          acc += (c - s);
+          acc += c - s;
           s = c;
         }
         var dateTimeEnd = Date.now();
         var timeEnd = __time();
         var dateDelta = dateTimeEnd - dateTimeStart;
         var timeDelta = timeEnd - timeStart;
-        expect(Math.abs(dateDelta - timeDelta) < dateDelta * 0.25).toBe(true);
+        var tolerance = Math.max(10, dateDelta * 0.5);
+        expect(timeDelta > 0).toBe(true);
+        expect(Math.abs(dateDelta - timeDelta) < tolerance).toBe(true);
         break;
-      } catch(e) {
+      } catch (e) {
         if (i == 4) {
           throw e;
         }
       }
     }
   });
-});
+});

test-app/runtime/CMakeLists.txt

@@ -147,6 +147,8 @@ add_library(
         src/main/cpp/URLImpl.cpp
         src/main/cpp/URLSearchParamsImpl.cpp
         src/main/cpp/URLPatternImpl.cpp
+        src/main/cpp/HMRSupport.cpp
+        src/main/cpp/DevFlags.cpp
 
         # V8 inspector source files will be included only in Release mode
         ${INSPECTOR_SOURCES}

test-app/runtime/src/main/cpp/DevFlags.cpp

@@ -0,0 +1,38 @@
+// DevFlags.cpp
+#include "DevFlags.h"
+#include "JEnv.h"
+#include <atomic>
+#include <mutex>
+
+namespace tns {
+
+bool IsScriptLoadingLogEnabled() {
+  static std::atomic<int> cached{-1}; // -1 unknown, 0 false, 1 true
+  int v = cached.load(std::memory_order_acquire);
+  if (v != -1) {
+    return v == 1;
+  }
+
+  static std::once_flag initFlag;
+  std::call_once(initFlag, []() {
+    bool enabled = false;
+    try {
+      JEnv env;
+      jclass runtimeClass = env.FindClass("com/tns/Runtime");
+      if (runtimeClass != nullptr) {
+        jmethodID mid = env.GetStaticMethodID(runtimeClass, "getLogScriptLoadingEnabled", "()Z");
+        if (mid != nullptr) {
+          jboolean res = env.CallStaticBooleanMethod(runtimeClass, mid);
+          enabled = (res == JNI_TRUE);
+        }
+      }
+    } catch (...) {
+      // keep default false
+    }
+    cached.store(enabled ? 1 : 0, std::memory_order_release);
+  });
+
+  return cached.load(std::memory_order_acquire) == 1;
+}
+
+} // namespace tns

test-app/runtime/src/main/cpp/DevFlags.h

@@ -0,0 +1,10 @@
+// DevFlags.h
+#pragma once
+
+namespace tns {
+
+// Fast cached flag: whether to log script loading diagnostics.
+// First call queries Java once; subsequent calls are atomic loads only.
+bool IsScriptLoadingLogEnabled();
+
+}