@@ -269,6 +269,18 @@
   Local<v8::Message> message = tc.Message();
   NativeScriptException::ReportToJsHandlersAndLog(isolate, exception, message);
   tc.Reset();
+
+  // uncaughtErrorPolicy "throw": the report above runs synchronously here (still
+  // under the boundary's live V8 scopes). Under the "throw" policy it deposited
+  // the NSException into the per-isolate slot; claim it and hand it back so the
+  // caller @throws it AFTER closing every V8 scope (same scopes-before-@throw
+  // discipline as a branded escape) — a native @try/@catch around the boundary
+  // then catches it, matching Android. Under the default "report" policy nothing
+  // is deposited and this is nil.
+  id policyThrow = NativeScriptException::ClaimPendingPolicyThrow(isolate);
+  if (policyThrow != nil) {
+    return policyThrow;
+  }
   return nil;
 }
 
@@ -385,6 +397,26 @@
       }
     }
 
+    // uncaughtErrorPolicy "throw" boundary claim (best-effort). Unlike the
+    // HandleBoundaryException sites (property accessors, DictionaryAdapter),
+    // which report the throw SYNCHRONOUSLY within their own frame and can
+    // therefore claim the deposit here, this path uses tc.ReThrow(): the
+    // unbranded exception is surfaced to V8 as pending and only reported when it
+    // reaches an uncaught V8 Invoke boundary UP THE STACK (or is caught in JS
+    // first). Empirically (verified with instrumentation over the suite,
+    // including a native-origin NSOperationQueue-invoked block) the message
+    // listener does NOT run during `tc`'s teardown, so under the "throw" policy
+    // nothing has been deposited by the time we reach this point and this claim
+    // is a no-op — those errors are instead handled by the deferred clean-frame
+    // fallback. The claim is kept as a defensive hook (harmless when the slot is
+    // empty; identity-checked so it can never steal an unrelated deposit) and to
+    // mirror the boundary discipline. Under the default "report" policy nothing
+    // is ever deposited. The NSError-out branch neither reports nor deposits.
+    // Skip when a branded escape already set pendingThrow.
+    if (pendingThrow == nil) {
+      pendingThrow = NativeScriptException::ClaimPendingPolicyThrow(isolate);
+    }
+
     if (pendingThrow == nil) {
       if (!success) {
         memset(retValue, 0, cif->rtype->size);
 
@@ -58,6 +58,29 @@ class NativeScriptException {
                               v8::Local<v8::Message> message,
                               const std::string& stackOverride = "",
                               const std::string& logPrefix = "");
+  // uncaughtErrorPolicy "throw" handoff slot (per isolate). When the policy is
+  // "throw", ReportFatalTail deposits the NSException to throw here (typed `id`
+  // so this header stays usable from the pure-C++ TUs that include it — mirrors
+  // ArgConverter.h) and schedules a deferred fallback throw. A JS→native
+  // boundary that originated the error claims the slot while still under its V8
+  // scopes and @throws the exception synchronously after scope teardown, so a
+  // native @try/@catch around the boundary can catch it (Android parity).
+  // Loop-originated errors (timers, microtasks, rejections) are never claimed
+  // and are thrown by the deferred fallback from a clean, scope-free frame.
+  //
+  // Deposits happen under the isolate lock (reporting is serialized); claims
+  // happen either at the boundary (under the Locker) or in the deferred
+  // fallback (mutex only). The identity-checked claim prevents a stale fallback
+  // block from throwing a newer deposit.
+  static void DepositPendingPolicyThrow(v8::Isolate* isolate, id exception);
+  // Returns and clears the isolate's pending policy throw, or nil.
+  static id ClaimPendingPolicyThrow(v8::Isolate* isolate);
+  // Claims only when the stored exception IS `expected` (pointer identity);
+  // used by the deferred fallback so an older block cannot steal/throw a newer
+  // deposit. Returns the claimed exception or nil.
+  static id ClaimPendingPolicyThrowIfEqual(v8::Isolate* isolate, id expected);
+  // Clears any pending policy throw for the isolate (called during teardown).
+  static void OnIsolateTeardown(v8::Isolate* isolate);
   static std::string GetErrorStackTrace(
       v8::Isolate* isolate, const v8::Local<v8::StackTrace>& stackTrace);
   static void ShowErrorModal(v8::Isolate* isolate, const std::string& title,
 
@@ -11,6 +11,7 @@
 #include <limits>
 #include <mutex>
 #include <sstream>
+#include <unordered_map>
 #include "ArgConverter.h"
 #include "Caches.h"
 #include "DataWrapper.h"
@@ -43,6 +44,22 @@
 static PendingErrorDisplay gPendingErrorDisplay;
 static uint64_t gNextErrorTicket = 1;
 
+// Per-isolate uncaughtErrorPolicy "throw" handoff slot. The NSException lifetime
+// is managed by ARC (__strong) — fine in this .mm. Heap-allocated and never
+// destroyed: ~Runtime reaches this registry via OnIsolateTeardown, and a global
+// Runtime can be destructed during __cxa_finalize at process exit — after this
+// TU's file-scope statics would have been destroyed. Locking a destroyed
+// std::mutex throws std::system_error out of the noexcept destructor chain and
+// terminates the process, so the registry must outlive all static destructors.
+static std::mutex& PolicyThrowMutex() {
+  static std::mutex* mutex = new std::mutex();
+  return *mutex;
+}
+static std::unordered_map<v8::Isolate*, NSException * __strong>& PendingPolicyThrows() {
+  static auto* map = new std::unordered_map<v8::Isolate*, NSException * __strong>();
+  return *map;
+}
+
 }  // namespace
 
 namespace tns {
@@ -122,15 +139,47 @@ static void ConsiderStackCandidate(PendingErrorDisplay& state, v8::Isolate* isol
   } else {
     messageString = tns::ToString(isolate, error);
   }
+  // Derive the combined stack ONCE, with the full fallback chain ReportFatalTail
+  // uses (stackOverride → GetSmartStackTrace → v8::Message stack → the error's
+  // own stack), so the `error` event listeners and the fatal tail observe the
+  // same string.
   std::string stackForEvent = stackOverride;
   if (stackForEvent.empty()) {
     stackForEvent = tns::GetSmartStackTrace(isolate, nullptr, error);
   }
+  if (stackForEvent.empty()) {
+    if (!message.IsEmpty()) {
+      stackForEvent = GetErrorStackTrace(isolate, message->GetStackTrace());
+    } else {
+      // Rejections/reportError carry no v8::Message; fall back to the error's
+      // own stack.
+      stackForEvent = GetErrorStackTrace(isolate, Exception::GetStackTrace(error));
+    }
+  }
+
+  // Android sets a combined `stackTrace` property on the error object BEFORE
+  // dispatching the `error` event, so listeners can read `e.error.stackTrace`
+  // (not only `e.error.stack`). Mirror that here (object errors only; guarded /
+  // non-fatal on failure — same pattern ReportFatalTail uses). ReportFatalTail
+  // sets it again with the same value (idempotent) for callers that reach it
+  // directly (the nativeReportFatal handshake).
+  if (error->IsObject()) {
+    Local<Context> context = isolate->GetCurrentContext();
+    bool stackTraceSet = error.As<Object>()
+                             ->Set(context, tns::ToV8String(isolate, "stackTrace"),
+                                   tns::ToV8String(isolate, stackForEvent))
+                             .FromMaybe(false);
+    if (!stackTraceSet) {
+      Log(@"Warning: Failed to set stackTrace property on error object");
+    }
+  }
+
   if (ErrorEvents::DispatchError(isolate, error, messageString, stackForEvent)) {
     return;
   }
 
-  ReportFatalTail(isolate, error, message, stackOverride, logPrefix);
+  // Pass the already-derived stack down so ReportFatalTail does not re-derive it.
+  ReportFatalTail(isolate, error, message, stackForEvent, logPrefix);
 }
 
 void NativeScriptException::ReportUnhandledRejection(Isolate* isolate, Local<Promise> promise,
@@ -164,6 +213,38 @@ static void ScheduleDeferredThrow(Isolate* isolate, NSException* e) {
   CFRunLoopWakeUp(loop);
 }
 
+void NativeScriptException::DepositPendingPolicyThrow(Isolate* isolate, id exception) {
+  std::lock_guard<std::mutex> lock(PolicyThrowMutex());
+  PendingPolicyThrows()[isolate] = (NSException*)exception;  // overwrites any prior entry
+}
+
+id NativeScriptException::ClaimPendingPolicyThrow(Isolate* isolate) {
+  std::lock_guard<std::mutex> lock(PolicyThrowMutex());
+  auto it = PendingPolicyThrows().find(isolate);
+  if (it == PendingPolicyThrows().end()) {
+    return nil;
+  }
+  NSException* e = it->second;
+  PendingPolicyThrows().erase(it);
+  return e;
+}
+
+id NativeScriptException::ClaimPendingPolicyThrowIfEqual(Isolate* isolate, id expected) {
+  std::lock_guard<std::mutex> lock(PolicyThrowMutex());
+  auto it = PendingPolicyThrows().find(isolate);
+  if (it == PendingPolicyThrows().end() || it->second != expected) {
+    return nil;
+  }
+  NSException* e = it->second;
+  PendingPolicyThrows().erase(it);
+  return e;
+}
+
+void NativeScriptException::OnIsolateTeardown(Isolate* isolate) {
+  std::lock_guard<std::mutex> lock(PolicyThrowMutex());
+  PendingPolicyThrows().erase(isolate);
+}
+
 void NativeScriptException::ReportFatalTail(Isolate* isolate, Local<Value> error,
                                             Local<v8::Message> message,
                                             const std::string& stackOverride,
@@ -293,9 +374,14 @@ static void ScheduleDeferredThrow(Isolate* isolate, NSException* e) {
   // uncaughtErrorPolicy — the cross-platform uncaught-error contract:
   //   "report" (default): report and keep the app running;
   //   "throw":            after reporting, rethrow the unprevented error
-  //                       natively (deferred to a clean scope-free frame). This
-  //                       is a throw, not a crash guarantee — the app terminates
-  //                       only if no native handler catches it.
+  //                       natively. If a JS→native boundary originated the error
+  //                       it is rethrown synchronously there (catchable by a
+  //                       native @try/@catch around that call, matching Android);
+  //                       otherwise (loop-originated: timers, microtasks,
+  //                       rejections) it is thrown from a clean, scope-free frame
+  //                       on the runtime loop. Either way it is a throw, not a
+  //                       crash guarantee — the app terminates only if nothing
+  //                       catches it.
   // The deprecated discardUncaughtJsExceptions flag suppresses the throw (an
   // explicit "keep the app alive").
   if (!isDiscarded) {
@@ -315,7 +401,32 @@ static void ScheduleDeferredThrow(Isolate* isolate, NSException* e) {
       if (!stackTrace.empty()) {
         tns::SetJSStackOnException(fatal, tns::ToNSString(stackTrace));
       }
-      ScheduleDeferredThrow(isolate, fatal);
+      // Claim-slot handoff: deposit the exception and schedule a FALLBACK
+      // clean-frame throw. A JS→native boundary that originated this error
+      // claims the slot while still under its V8 scopes and @throws `fatal`
+      // synchronously after scope teardown, so a native @try/@catch around the
+      // boundary can catch it (Android parity). Loop-originated errors (timers,
+      // microtasks, rejections) are never claimed at a boundary, so the fallback
+      // throws them from a clean, scope-free frame exactly as before.
+      //
+      // The fallback claims by pointer IDENTITY (ClaimPendingPolicyThrowIfEqual):
+      // reporting is serialized under the isolate lock, but if a newer error is
+      // deposited and then claimed (by its boundary or its own fallback) before
+      // this block runs, the identity check fails and this now-stale block is a
+      // no-op — it can never throw a different (newer) error than the one it was
+      // scheduled for.
+      DepositPendingPolicyThrow(isolate, fatal);
+      Runtime* rt = Runtime::GetRuntime(isolate);
+      CFRunLoopRef loop = rt != nullptr ? rt->RuntimeLoop() : nullptr;
+      if (loop != nullptr) {
+        CFRunLoopPerformBlock(loop, kCFRunLoopCommonModes, ^{
+          id e = ClaimPendingPolicyThrowIfEqual(isolate, fatal);
+          if (e != nil) {
+            @throw e;
+          }
+        });
+        CFRunLoopWakeUp(loop);
+      }
     } else if (policy != "report") {
       static std::once_flag warnedPolicy;
       std::call_once(warnedPolicy, [&policy]() {
@@ -477,6 +588,20 @@ static bool GiveWorkerOnErrorAChance(Isolate* isolate, Local<Context> context,
             NativeScriptException::GetErrorStackTrace(isolate_, Exception::GetStackTrace(reason));
       }
 
+      // Android parity (Fix A): populate `reason.stackTrace` BEFORE dispatching
+      // the unhandledrejection event so listeners can read `e.reason.stackTrace`
+      // (object reasons only; guarded / non-fatal). Covers both the worker and
+      // main dispatch branches below.
+      if (reason->IsObject() && !stack.empty()) {
+        bool ok = reason.As<Object>()
+                      ->Set(context, tns::ToV8String(isolate_, "stackTrace"),
+                            tns::ToV8String(isolate_, stack))
+                      .FromMaybe(false);
+        if (!ok) {
+          Log(@"Warning: Failed to set stackTrace property on rejection reason");
+        }
+      }
+
       if (isWorker) {
         // Dispatch the rejection event on the worker's own global first;
         // preventDefault() there fully handles it. Only when unprevented fall
 
@@ -193,6 +193,10 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {
     rejectionObserver_ = nullptr;
   }
 
+  // Drop any pending uncaughtErrorPolicy "throw" deposit for this isolate so a
+  // stale entry can't outlive the isolate it keys on.
+  NativeScriptException::OnIsolateTeardown(isolate_);
+
   auto currentIsolate = this->isolate_;
   {
     // make sure we remove the isolate from the list of active isolates first
 
@@ -86,6 +86,10 @@ describe("WHATWG error events", function () {
         expect(received.error).toBe(err);
         expect(uncaught.length).toBe(1);
         expect(uncaught[0]).toBe(err);
+        // Fix A: an Error reported (unprevented) through the pipeline ends up
+        // with a combined `stackTrace` string on the error object.
+        expect(typeof err.stackTrace).toBe("string");
+        expect(err.stackTrace.length).toBeGreaterThan(0);
         done();
     });
 
@@ -95,6 +99,39 @@ describe("WHATWG error events", function () {
         }).toThrowError(TypeError);
     });
 
+    it("an error reported through a native boundary has a combined stackTrace set BEFORE the error event fires", function (done) {
+        // Reading an overridden getter from native routes the JS throw through
+        // the C++ boundary reporter (ReportToJsHandlersAndLog), which now sets
+        // `error.stackTrace` before dispatching the cancelable `error` event —
+        // matching Android — so the listener observes it during dispatch (not
+        // only `error.stack`).
+        const marker = "boundary-stacktrace-marker";
+        let sawEvent = false;
+        let stackTraceInListener = null;
+        onGlobal("error", function (e) {
+            if (e.error && e.error.message === marker) {
+                sawEvent = true;
+                stackTraceInListener = e.error.stackTrace;
+                e.preventDefault();
+            }
+        });
+
+        const Derived = TNSDerivedInterface.extend({
+            get baseProperty() {
+                throw new Error(marker);
+            }
+        });
+        const instance = Derived.alloc().init();
+        TNSTestNativeCallbacks.objectValueForKeyKey(instance, "baseProperty");
+
+        pollUntil(function () { return sawEvent; }, function () {
+            expect(sawEvent).toBe(true);
+            expect(typeof stackTraceInListener).toBe("string");
+            expect(stackTraceInListener.length).toBeGreaterThan(0);
+            done();
+        });
+    });
+
     it("unhandledrejection listener receives reason and promise; preventDefault suppresses the shim", function (done) {
         const reason = new Error("rejected");
         let received = null;
@@ -111,6 +148,11 @@ describe("WHATWG error events", function () {
             expect(received.type).toBe("unhandledrejection");
             expect(received.reason).toBe(reason);
             expect(typeof received.promise.then).toBe("function");
+            // Fix A / Android parity: the rejection drain sets a combined
+            // `stackTrace` on the (object) reason BEFORE dispatching the event,
+            // so a listener sees it (not only `reason.stack`).
+            expect(typeof received.reason.stackTrace).toBe("string");
+            expect(received.reason.stackTrace.length).toBeGreaterThan(0);
             afterQuietTurns(function () {
                 expect(uncaught.length).toBe(0);
                 done();
 
@@ -250,11 +250,43 @@ describe("interop.escapeException and boundary hardening", function () {
         });
     });
 
-    // manual: uncaughtErrorPolicy "throw" is not exercised automatically because a
-    // real crash would kill the test runner. To smoke it manually, set
-    // { "uncaughtErrorPolicy": "throw" } in the app config and throw an
-    // unprevented error (or `throw interop.escapeException(err)` from an `error`
-    // listener) — the app must terminate with a NativeScriptFatalJSException
-    // crash report scheduled on the runtime loop. Default-off behavior (report +
-    // continue) is covered by every other suite here.
+    // manual: uncaughtErrorPolicy "throw" is not exercised automatically because
+    // its terminal case (a real crash) would kill the test runner, and the policy
+    // cannot be toggled at runtime (GetAppConfigValue caches, and flipping it
+    // would break every other spec). The whole suite staying green under the
+    // default "report" policy is itself the pin that the claim-slot machinery is
+    // inert when the policy is off.
+    //
+    // To smoke it manually, set { "uncaughtErrorPolicy": "throw" } in the app
+    // config, then:
+    //
+    // 1. BOUNDARY-ORIGINATED, reported SYNCHRONOUSLY (catchable — Android parity):
+    //    boundaries that report inside their own frame via HandleBoundaryException
+    //    — overridden property getters/setters and DictionaryAdapter reads invoked
+    //    from native — rethrow the NSException at that boundary after scope
+    //    teardown. A native @try/@catch wrapping that native access catches it.
+    //    (The existing "throwing overridden getter"/"throwing DictionaryAdapter"
+    //    specs above drive exactly these boundaries; under "throw" the read would
+    //    surface a NativeScriptFatalJSException instead of a nil default.)
+    //
+    //    IMPORTANT LIMITATION (verified empirically): the native→JS block /
+    //    overridden-method boundary (ArgConverter::MethodCallback, e.g.
+    //    invokeBlockCatchingException) does NOT get a synchronous rethrow. It uses
+    //    tc.ReThrow(), so an unbranded plain Error is surfaced to V8 as a pending
+    //    exception and is caught in JS up-stack (or reported later at an uncaught
+    //    Invoke), never during the block's own frame. A native @try/@catch around
+    //    invokeBlockCatchingException therefore does NOT catch a plain Error under
+    //    "throw" — it still surfaces to JS. Use interop.escapeException(err) to
+    //    force a synchronous native @throw at that boundary regardless of policy.
+    //
+    // 2. LOOP-ORIGINATED (deferred clean-frame throw): an uncaught error in a
+    //    setTimeout callback has no originating boundary to claim it, so it is
+    //    thrown from a clean, scope-free frame on the runtime loop and terminates
+    //    the app (nothing catches it) with a NativeScriptFatalJSException crash
+    //    report:
+    //
+    //      setTimeout(() => { throw new Error("policy-throw-timer"); }, 0);
+    //
+    // Default-off behavior (report + continue) is covered by every other suite
+    // here.
 });
Original file line number	Diff line number	Diff line change
`@@ -193,6 +193,10 @@ void DisposeIsolateWhenPossible(Isolate* isolate) {`
`193`	`193`	`rejectionObserver_ = nullptr;`
`194`	`194`	`}`
`195`	`195`
	`196`	`+ // Drop any pending uncaughtErrorPolicy "throw" deposit for this isolate so a`
	`197`	`+ // stale entry can't outlive the isolate it keys on.`
	`198`	`+ NativeScriptException::OnIsolateTeardown(isolate_);`
	`199`	`+`
`196`	`200`	`auto currentIsolate = this->isolate_;`
`197`	`201`	`{`
`198`	`202`	`// make sure we remove the isolate from the list of active isolates first`