fix(events): report a throwing event listener instead of swallowing it (−2)

Per DOM "inner invoke", when an event listener callback throws, the exception
is REPORTED (HTML "report the exception" — a window `error` event + legacy
`onerror`), not propagated to the dispatchEvent() caller, and dispatch continues
to the next listener. `fireListeners` was catching a callback throw with
`logThrew` (logged + swallowed), so `window.onerror` never saw it. Route the
throw through `__csimReportCallbackError` (report on the callback's own realm,
WebIDL "invoke a callback") — same as the already-correct handleEvent-Get path
just above. The legacy `window.onerror` property handler is invoked with the
string message, as the test expects.

Add a re-entrancy guard to `reportError`: an `error` handler (`window.onerror`
or an `error` listener) that ITSELF throws is reported too, but firing another
`error` event for it would recurse unboundedly (a click → throwing listener →
report → error event → throwing error handler → report → …). While already
reporting, skip the event and just log — matching browsers, where error
reporting is not re-entrant. (Before this commit `logThrew` broke the cycle; now
that listener throws are reported, the guard is required.)

Clears Event-dispatch-throwing.html (single + multiple listeners). The inline
`on*`-attribute handler throw (line ~366) still uses `logThrew` — also reportable
per spec, but untested and out of scope here.

Gate 660/0/15, gem 1586/0/35, 0 WPT regressions. All five apps green on a clean
box: Redmine 122/0, Avo 396/0 (3m08s, baseline), Forem, Mastodon 26/0, Discourse
2052/0/67 — confirming the report-the-exception behaviour change (now firing
`error` events for throwing listeners) doesn't regress any app.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ursm

lib/capybara/simulated/js/bridge.bundle.js

@@ -3342,7 +3342,10 @@
           cb.call(entry.handler, event);
           fired = true;
         } catch (e) {
-          logThrew("listener (event=" + event.type + ", tag=" + (node && node._tag) + ")", e);
+          try {
+            globalThis.__csimReportCallbackError(cb, e);
+          } catch (_) {
+          }
         } finally {
           event._inPassiveListener = false;
         }
@@ -3351,7 +3354,10 @@
           entry.handler.call(node, event);
           fired = true;
         } catch (e) {
-          logThrew("listener (event=" + event.type + ", tag=" + (node && node._tag) + ")", e);
+          try {
+            globalThis.__csimReportCallbackError(entry.handler, e);
+          } catch (_) {
+          }
         } finally {
           event._inPassiveListener = false;
         }
@@ -17011,8 +17017,17 @@
   globalThis.structuredClone = /* @__PURE__ */ __name(function structuredClone(v) {
     return cloneInto(v, /* @__PURE__ */ new Map());
   }, "structuredClone");
+  var __csimReportingError = false;
   globalThis.reportError = /* @__PURE__ */ __name(function reportError(e) {
+    if (__csimReportingError) {
+      try {
+        console.error(e && e.stack ? e.stack : String(e));
+      } catch (_) {
+      }
+      return;
+    }
     let cancelled = false;
+    __csimReportingError = true;
     try {
       if (typeof globalThis.ErrorEvent !== "undefined" && typeof globalThis.dispatchEvent === "function") {
         const ev = new globalThis.ErrorEvent("error", {
@@ -17026,6 +17041,8 @@
         cancelled = globalThis.dispatchEvent(ev) === false;
       }
     } catch (_) {
+    } finally {
+      __csimReportingError = false;
     }
     if (!cancelled) {
       try {

lib/capybara/simulated/js/src/dispatch.js

@@ -396,12 +396,16 @@ function fireListeners(node, event, capture) {
         try { globalThis.reportError(e); } catch (_) {}
         continue;
       }
+      // A callback throw is REPORTED (HTML "report the exception" — a window
+      // `error` event + legacy `onerror`), NOT propagated to dispatchEvent's
+      // caller, and dispatch continues to the next listener. Report on the
+      // callback's own realm (WebIDL "invoke a callback"), same as the Get path.
       try { cb.call(entry.handler, event); fired = true; }
-      catch (e) { logThrew('listener (event=' + event.type + ', tag=' + (node && node._tag) + ')', e); }
+      catch (e) { try { globalThis.__csimReportCallbackError(cb, e); } catch (_) {} }
       finally { event._inPassiveListener = false; }
     } else {
       try { entry.handler.call(node, event); fired = true; }
-      catch (e) { logThrew('listener (event=' + event.type + ', tag=' + (node && node._tag) + ')', e); }
+      catch (e) { try { globalThis.__csimReportCallbackError(entry.handler, e); } catch (_) {} }
       finally { event._inPassiveListener = false; }
     }
   }

lib/capybara/simulated/js/src/platform-globals.js

@@ -359,8 +359,18 @@ globalThis.structuredClone = function structuredClone(v) { return cloneInto(v, n
 // console. This is also the channel a throwing event-loop callback surfaces
 // through (e.g. queueMicrotask), so it must fire the `error` event — NOT the
 // promise-rejection channel — to match real-browser behavior.
+let __csimReportingError = false;
 globalThis.reportError = function reportError(e) {
+  // Re-entrancy guard: an `error` handler (`window.onerror` / an `error`
+  // listener) that itself throws is reported too — but firing ANOTHER `error`
+  // event for it would recurse unboundedly. While already reporting, skip the
+  // event and just log, matching browsers (error reporting is not re-entrant).
+  if (__csimReportingError) {
+    try { console.error(e && e.stack ? e.stack : String(e)); } catch (_) {}
+    return;
+  }
   let cancelled = false;
+  __csimReportingError = true;
   try {
     if (typeof globalThis.ErrorEvent !== 'undefined' && typeof globalThis.dispatchEvent === 'function') {
       const ev = new globalThis.ErrorEvent('error', {
@@ -374,7 +384,7 @@ globalThis.reportError = function reportError(e) {
       // dispatchEvent returns false iff a listener called preventDefault.
       cancelled = globalThis.dispatchEvent(ev) === false;
     }
-  } catch (_) {}
+  } catch (_) {} finally { __csimReportingError = false; }
   if (!cancelled) {
     try { console.error(e && e.stack ? e.stack : String(e)); } catch (_) {}
   }

spec/support/wpt_expected_failures.yml

@@ -42,9 +42,6 @@ dom/events/Event-dispatch-throwing-multiple-globals.html:
   global
 - exception thrown in event listener interface object should result in error event
   on listener's global
-dom/events/Event-dispatch-throwing.html:
-- Throwing in event listener with a single listeners
-- Throwing in event listener with multiple listeners
 dom/events/Event-timestamp-high-resolution.https.html:
 - Constructed GamepadEvent timestamp should be high resolution and have the same time
   origin as performance.now()