fix(hermes): microtask handling

Author: ammarahm-ed

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

@@ -21,7 +21,6 @@
 		}
 	}
 */
-const benchmarkRunner = require("./benchmark.js");
 var MyActivity = (function (_super) {
   __extends(MyActivity, _super);
   function MyActivity() {
@@ -68,14 +67,32 @@ var MyActivity = (function (_super) {
         },
       })
     );
+    var benchmarkWorker = null;
     button2.setOnClickListener(
           new android.view.View.OnClickListener("AppClickListener", {
             onClick: function () {
-              const result = benchmarkRunner.runBenchmark();
-              setTimeout(() => {
-              globalThis.gc();
-              });
-              textView.setText(result);
+              // Run the benchmark on a worker thread so the UI thread stays
+              // responsive and Android does not raise an ANR.
+              if (benchmarkWorker) {
+                return;
+              }
+              button2.setText("Running Benchmark...");
+              textView.setText("Running benchmark, please wait...");
+
+              benchmarkWorker = new Worker("./benchmark-worker.js");
+              benchmarkWorker.onmessage = function (msg) {
+                textView.setText(msg.data);
+                button2.setText("Run Benchmark");
+                benchmarkWorker.terminate();
+                benchmarkWorker = null;
+              };
+              benchmarkWorker.onerror = function (err) {
+                textView.setText("Benchmark error: " + (err && err.message ? err.message : err));
+                button2.setText("Run Benchmark");
+                benchmarkWorker.terminate();
+                benchmarkWorker = null;
+              };
+              benchmarkWorker.postMessage("start");
             },
           })
     );

test-app/app/src/main/assets/app/benchmark-worker.js

@@ -0,0 +1,15 @@
+// Runs the Octane benchmark suite off the main (UI) thread so the app
+// stays responsive and Android does not raise an ANR while benchmarking.
+const benchmarkRunner = require("./benchmark.js");
+
+self.onmessage = function () {
+    try {
+        const result = benchmarkRunner.runBenchmark();
+        if (typeof globalThis.gc === "function") {
+            globalThis.gc();
+        }
+        self.postMessage(result);
+    } catch (e) {
+        self.postMessage("Benchmark failed: " + (e && e.stack ? e.stack : e));
+    }
+};

test-app/runtime/src/main/cpp/napi/hermes/jsr.cpp

@@ -13,6 +13,7 @@ JSR::JSR() {
             .withMicrotaskQueue(true)
             .withES6BlockScoping(true)
             .withEnableAsyncGenerators(true)
+            .withAsyncBreakCheckInEval(true)
             .build();
 
     threadSafeRuntime = facebook::hermes::makeThreadSafeHermesRuntime(config);

test-app/runtime/src/main/cpp/napi/hermes/jsr.h

@@ -29,6 +29,11 @@ class JSR {
     std::unique_ptr<facebook::jsi::ThreadSafeRuntime> threadSafeRuntime;
     facebook::hermes::HermesRuntime* rt;
     std::recursive_mutex js_mutex;
+    // Depth of nested JS scopes entered from the host (see NapiScope). Hermes is
+    // configured with an explicit microtask queue, so promise jobs only run when
+    // we drain them; we drain once this returns to 0, i.e. when the native call
+    // stack has fully unwound back out of JS.
+    int jsEnterState = 0;
     void lock() {
         threadSafeRuntime->lock();
         js_mutex.lock();
@@ -47,6 +52,11 @@ class NapiScope {
             : env_(env)
     {
         js_lock_env(env_);
+        auto it = JSR::env_to_jsr_cache.find(env_);
+        jsr_ = it != JSR::env_to_jsr_cache.end() ? it->second : nullptr;
+        if (jsr_) {
+            jsr_->jsEnterState++;
+        }
         if (openHandle) {
             napi_open_handle_scope(env_, &napiHandleScope_);
         } else {
@@ -55,6 +65,18 @@ class NapiScope {
     }
 
     ~NapiScope() {
+        // Drain the microtask queue only when the outermost JS scope unwinds so
+        // that promise continuations (async/await) run — mirroring how a JS
+        // engine empties its job queue once control returns to the host. Draining
+        // at a nested depth would run continuations while JS is still on the
+        // stack. A throwing microtask must never escape a destructor.
+        if (jsr_ && --jsr_->jsEnterState <= 0) {
+            jsr_->jsEnterState = 0;
+            try {
+                js_execute_pending_jobs(env_);
+            } catch (...) {
+            }
+        }
         if (napiHandleScope_) {
             napi_close_handle_scope(env_, napiHandleScope_);
         }
@@ -64,6 +86,7 @@ class NapiScope {
 private:
     napi_env env_;
     napi_handle_scope napiHandleScope_;
+    JSR* jsr_ = nullptr;
 };
 
 #define JSEnterScope