GeezerVison

…r events)

Ports the error model from NativeScript/ios#409 to the Android runtime.

Unhandled promise rejection tracking:
- Register SetPromiseRejectCallback (previously rejections vanished with
  no log, no callback). Rejections are tracked per-isolate and drained
  once per looper turn via a LooperTasks task, so a handler attached in
  the same turn always cancels the report.
- Unhandled ones report through the existing __onUncaughtError hook with
  an always-on "Unhandled promise rejection:" logcat entry; late-attached
  handlers fire `rejectionhandled` (as a task, per spec, carrying the
  original reason; already-reported promises are held weakly).
- Worker isolates dispatch `unhandledrejection` on the worker global
  first, then fall through to the existing worker onerror channel.

WHATWG error events on globalThis:
- Events.{h,cpp}: generic Event/EventTarget constructors, the
  addEventListener/removeEventListener/dispatchEvent mixin, and the
  internal backing target (stashed natively for future consumers).
- ErrorEvents.{h,cpp}: ErrorEvent/PromiseRejectionEvent, reportError()
  and the native dispatch closures, layered on the generic primitives
  via a one-shot _installListenerErrorReporter handoff. Dispatch
  closures are captured at init so events keep firing even if app code
  overwrites globalThis.dispatchEvent.
- NativeScriptException keeps the reporting machinery and the rejection
  tracker, mirroring the iOS file layout.

preventDefault() semantics:
- Uncaught errors dispatch a cancelable `error` ErrorEvent before the
  __onUncaughtError/__onDiscardedError hooks; preventDefault() fully
  handles the report. passExceptionToJsNative now returns that handled
  flag and NativeScriptUncaughtExceptionHandler skips the error activity
  and the default (crashing) handler when set.
- Back-compat: unprevented errors behave exactly as before.

Not ported (already native to Android): interop.escapeException - a JS
throw in a method override already surfaces as a real
com.tns.NativeScriptException to the Java caller, and caught Java
exceptions already carry error.nativeException. crashOnUncaughtJsExceptions
is likewise unnecessary - Android crashes by default on truly-uncaught
exceptions.

Testing: 30 new jasmine specs (WHATWG events/EventTarget semantics,
reportError, unhandled rejections incl. rejectionhandled); full suite
green on an API 35 arm64 emulator with no changes to existing suites.

coderabbitai Bot left a comment

…tive callers)

Ports the identity-preservation half of iOS's interop.escapeException
(NativeScript/ios#409). The escape direction itself is already Android's
default - a JS throw in a native-invoked override surfaces to the Java
caller as a real com.tns.NativeScriptException - but a rethrown *Java*
exception lost its identity: ReThrowToJava wrapped it, so the caller's
catch of the concrete type (e.g. IOException) never matched.

Now, mirroring iOS:

- New `interop` global (per isolate, workers included) with
  interop.escapeException(x): returns a fresh JS Error branded via a
  private symbol whose payload carries the original Java throwable when
  x is/carries one (nativeException), or {name, message, stack}
  synthesis info otherwise. Idempotent; TypeError with no arguments.
- At the JS->Java boundary, a branded error carrying a Java throwable is
  rethrown UNWRAPPED (env.Throw of the original object), so a native
  `catch (IOException e)` above the caller matches and Throwable
  identity is preserved. JNI does not enforce checked-exception
  declarations, so any Throwable propagates.
- Branded errors bypass discardUncaughtJsExceptions (which only handles
  com.tns.NativeScriptException) - an explicit forward request, matching
  iOS semantics where branded escapes ignore the discard flag.
- Unbranded throws keep today's semantics exactly (wrapper with the
  original as cause); branded plain JS errors keep the default
  NativeScriptException escape shape.

Testing: 7 new specs (brand semantics + boundary round-trips through a
new EscapeExceptionTest fixture, asserting the caller catches the
original java.io.IOException by identity, and that unbranded/plain
behavior is unchanged). Full suite green on an API 35 arm64 emulator.

coderabbitai Bot left a comment

Companion to the iOS runtime's JS-stack DX work on NativeScript/ios#409,
using the JVM primitive iOS doesn't have: Throwable.addSuppressed.

- New com.tns.JavaScriptStackTrace: a never-thrown Throwable carrying a
  JS stack, with StackTraceElements synthesized from the V8 frames (its
  own Java capture is suppressed). Attached generically via attach() so
  future exception paths can adopt it; SDK integrations read the raw
  stacks through getJavaScriptStack()/getEscapeSiteStack().
- Original-throwable escapes: the boundary attaches the carrier as a
  suppressed exception before rethrowing, so the JS journey renders
  automatically in printStackTrace(), logcat fatal logs and crash
  reporters ("Suppressed: com.tns.JavaScriptStackTrace: ...") while the
  original object's identity, class, stack and cause chain stay
  untouched. Idempotent: the same throwable escaping twice through
  nested overrides gets one carrier.
- Escape-site capture: escapeException() now records the stack of its
  own call site (the branded Error's natural V8 stack, grabbed before
  the origin stack overwrites it) alongside the origin stack. For
  non-Error values it is the only stack available and was previously
  lost.
- Synthesized escapes: the com.tns.NativeScriptException thrown for a
  branded error with no underlying Java throwable gets its stack trace
  replaced with the synthesized JS frames, so crash reporters group
  these by where they actually happened in JS instead of bucketing
  everything under the identical JNI boundary machinery.

Testing: 3 new specs (suppressed carrier contents + escape-site
accessor, duplicate-carrier guard across nested escapes, non-Error
escape-site fallback) plus JS-frame assertions on the synthesized path.
Full suite green on an API 35 arm64 emulator.

Documents the web-compliant error model: global error/unhandledrejection/
rejectionhandled events and reportError, Java exception round-tripping
(error.nativeException), interop.escapeException and the
com.tns.JavaScriptStackTrace carrier, configuration flags with the
terminal-path decision table, and crash-reporter integration on both the
JS and Java sides. Adds a docs/ index and links it from the README,
mirroring the docs added on the iOS PR (NativeScript/ios#409).

coderabbitai Bot left a comment

Adopts the web's model as the default: an erroring page doesn't crash
the browser, and an uncaught JS error no longer crashes the app. This is
the Android half of the unified NativeScript 9.1 error-handling spec.

Containment:
- An uncaught throw in a NATIVE-initiated callback (the OS invoking an
  overridden method or interface implementation, a posted Runnable, a
  timer, __runOnMainThread, a frame callback) is contained at the
  boundary: reported through the WHATWG pipeline (cancelable `error`
  event -> __onUncaughtError -> logcat) and the native caller resumes
  with the return type's default value. preventDefault() suppresses the
  report entirely.
- A JS-INITIATED chain (JS -> Java -> JS callback throws) keeps
  propagating to the outer JS catch with the original JS error object -
  correct JavaScript semantics, tracked via a per-isolate JS->Java call
  depth around CallJavaMethod/RegisterInstance. Containment applies only
  at an outermost native-initiated boundary.
- Contained primitive-returning overrides yield the type's default
  (dispatchCallJSMethodNative substitutes it before unboxing), fixing
  the NPE the old discard path produced.
- Branded interop.escapeException throws are never contained; module/
  script evaluation (bootstrap) is not contained.

uncaughtErrorPolicy (app package.json, root level):
- "report" (default): report and continue, never crash.
- "throw": unprevented errors are thrown to the native layer as real
  Java exceptions - com.tns.NativeScriptException with the JS frames as
  its stack trace - restoring the pre-9.1 behavior (typically a crash,
  via the thread's uncaught-exception path, which performs the single
  report). Unhandled rejections are thrown from a clean Java frame
  posted to the runtime's looper. Named for the mechanism, not a
  guaranteed crash: native catch-alls above the boundary can still
  intercept.

discardUncaughtJsExceptions is deprecated (logcat warning): `true` keeps
its legacy quiet routing (__onDiscardedError, no log) on top of the new
default; `false` - which used to mean "crash" - is ignored. Branded
escapes are now exempt from the discard handling (escapedFromJs marker).

Testing: 5 new specs (containment + app liveness with event/hook
identity, preventDefault suppression, timer containment, primitive
default instead of NPE, JS-initiated chain identity) plus the
direct-throw escape specs; "throw" policy is a documented manual smoke.
Full suite green on an API 35 arm64 emulator - every pre-existing suite
passes unchanged thanks to the JS-initiated-chain rule.

… parity)

Parity round with NativeScript/ios#409's claim-slot commit, closing the
review's cross-platform divergences:

- Single report per failure under uncaughtErrorPolicy: "throw": the full
  report (cancelable event -> hook -> log) now runs at the decision
  point BEFORE the native throw, for both the sync boundary and the
  rejection drain, and the thrown com.tns.NativeScriptException is
  marked reportedToJs (isolate-private brand carried to a Java field by
  ReThrowToJava; set directly for the rejection looper throw) so
  NativeScriptUncaughtExceptionHandler skips the post-mortem
  re-report. Previously a "throw"-policy rejection fired
  unhandledrejection AND a second post-mortem error event. The public
  NativeScriptException.isReportedToJs() lets custom
  Thread.UncaughtExceptionHandler implementations honor the same
  contract.
- preventDefault() now beats the "throw" policy at the sync boundary
  too: the event dispatches before the propagation decision, so a
  prevented error is fully contained with the app alive (iOS behavior).
  The deprecated discard flag disables the throw, matching iOS.
- error.stackTrace / reason.stackTrace (the combined legacy stack, a
  NativeScript extension) are populated BEFORE the error /
  unhandledrejection events dispatch - including the worker branch of
  the rejection drain - so listeners see the same shape the hooks do;
  pinned by new spec assertions mirroring the iOS ones.
- Docs: unified "throw" sequencing and the cross-platform catchability
  note (Android sync at the method boundary; iOS sync only at
  own-frame-reporting boundaries, deferred for block/method callbacks
  and loop-originated errors; escapeException is the portable per-call
  interception tool), plus the Android-only native-crash event
  asymmetry and the interop feature-detection note.

Full suite green on an API 35 arm64 emulator: 604 specs, 0 failures.

Separates native-layer deaths from the WHATWG `error` event, completing
the invariant that error/unhandledrejection only fire while the failure
is still containable (the app fully alive, preventDefault() honest).

- New cancelable `nativeuncaughterror` ErrorEvent, dispatched
  synchronously from the uncaught-exception handler for everything that
  reaches it un-marked: pure-native Java crashes, uncaught
  interop.escapeException forwards, bootstrap failures. The handler
  classifies nothing - the simple rule IS the spec. e.error carries the
  wrapped original Throwable via nativeException. preventDefault() is
  best-effort: it skips the error activity and the default (killing)
  handler - meaningful for background-thread crashes (this is what
  keeps the new spec's test runner alive). The legacy __onUncaughtError
  hook still fires for unprevented native crashes (deprecated
  back-compat - it is what Application.uncaughtErrorEvent has received
  for years). This also removes the blanket-preventDefault footgun: a
  generic `error` listener can no longer accidentally spare a process
  whose crashed thread is already gone.

- Main-runtime fallback: crashes on threads with no runtime of their
  own (plugin/executor threads) previously got NO JS reporting at all -
  Runtime.isInitialized() and getCurrentRuntime() are thread-local, so
  the handler silently skipped them. The handler now resolves current
  -> main (new Runtime.getMainRuntime(), set when the workerId-0
  runtime initializes) and enters the main isolate cross-thread (the
  JNI layer takes the v8::Locker).

- Already-reported fast path: an uncaughtErrorPolicy "throw" exception
  (isReportedToJs) now short-circuits the handler before any work -
  no JS roundtrip and no eager stack rendering; the message strings are
  built lazily, only when the logger, debug print or error activity
  actually consumes them.

Testing: new spec crashes a fresh runtime-less Java thread and asserts
nativeuncaughterror arrives via the main-runtime fallback carrying the
original Throwable, `error` never fires (invariant pin), the prevented
report skips the legacy hook, and the process survives. Full suite
green on an API 35 arm64 emulator: 605 specs, 0 failures.