fix(runtime): keep error reporting alive on a terminating isolate

Building an error report runs JS (ToDetailString), which materializes an
armed termination interrupt; the next V8 call then answers Nothing, and
two ToChecked() sites in the formatter turned that into an unconditional
CHECK abort - reachable whenever worker.terminate() lands while a
genuine error is being reported. Both read through FromMaybe now, like
the rest of the file.

A spec pins the whole terminate-during-entry window: a worker whose
.mjs entry parks forever in top-level await is terminated mid-pump,
three times over, asserting no onerror fires on the dying worker and
that a fresh worker still round-trips - termination ends the pump
promptly and never masquerades as a timeout or an entry rejection.

Author: edusperoni

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

@@ -0,0 +1,10 @@
+// An ES module worker entry that never finishes evaluating. The parent is told
+// the entry body started before the park, so its terminate() lands inside the
+// entry's bounded evaluation pump rather than after it.
+postMessage("never-settles:started");
+
+await new Promise(function () {});
+
+globalThis.onmessage = function () {
+    postMessage("never-settles:unreachable");
+};

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

@@ -90,6 +90,58 @@ describe("worker ES module entries", function () {
         worker.postMessage("ping");
     });
 
+    // The worker isolate is published before its entry runs, so terminate()
+    // can interrupt an entry that is still evaluating - here one parked on a
+    // promise that never settles, inside the pump that waits for it.
+    it("survives terminate() while an entry is parked in top-level await", function (done) {
+        var ITERATIONS = 3;
+        var FALLBACK_TERMINATE = 700;
+        var SETTLE_AFTER = 700;
+        var errors = [];
+
+        function iteration(remaining) {
+            if (remaining === 0) {
+                expect(errors).toEqual([]);
+                // A worker spawned after the terminated ones still works.
+                var next = new Worker("~/tests/esmEntrySyncWorker.mjs");
+                next.onmessage = function (msg) {
+                    expect(msg.data).toBe("esm-entry:ping");
+                    next.terminate();
+                    done();
+                };
+                next.postMessage("ping");
+                return;
+            }
+
+            var worker = new Worker("./esmEntryNeverSettlesWorker.mjs");
+            var terminated = false;
+
+            function terminateOnce() {
+                if (terminated) {
+                    return;
+                }
+                terminated = true;
+                worker.terminate();
+                setTimeout(function () {
+                    iteration(remaining - 1);
+                }, SETTLE_AFTER);
+            }
+
+            worker.onerror = function (e) {
+                errors.push(String((e && e.message) || e));
+            };
+            worker.onmessage = function (msg) {
+                expect(msg.data).toBe("never-settles:started");
+                terminateOnce();
+            };
+            // The evaluation pump is bounded, so a start message that never
+            // arrives must not push the terminate past the window it targets.
+            setTimeout(terminateOnce, FALLBACK_TERMINATE);
+        }
+
+        iteration(ITERATIONS);
+    });
+
     // WHATWG parity: the worker's message queue is enabled when its entry
     // script finishes evaluating, and from then on messages dispatch whether
     // or not a handler exists. A handler registered later (from a timer)

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

@@ -1049,7 +1049,10 @@ string NativeScriptException::GetFullMessage(const TryCatch& tc,
   } else {
     ss << endl << "File: (<unknown>";
   }
-  ss << ":" << message->GetLineNumber(context).ToChecked() << ":"
+  // An isolate that started terminating while this message was being
+  // formatted answers Nothing to every query below - a missing line number
+  // must degrade the report, not abort the process.
+  ss << ":" << message->GetLineNumber(context).FromMaybe(0) << ":"
      << message->GetStartColumn() << ")" << endl
      << endl;
   ss << "StackTrace: " << endl << stackTraceMessage << endl;
@@ -1135,7 +1138,7 @@ string NativeScriptException::GetErrorMessage(const Local<Message>& message,
   bool hasFullErrorMessage = false;
   auto v8FullMessage = ArgConverter::ConvertToV8String(isolate, "fullMessage");
   if (error->IsObject() &&
-      error.As<Object>()->Has(context, v8FullMessage).ToChecked()) {
+      error.As<Object>()->Has(context, v8FullMessage).FromMaybe(false)) {
     hasFullErrorMessage = true;
     Local<Value> errMsgVal;
     error.As<Object>()->Get(context, v8FullMessage).ToLocal(&errMsgVal);