Guard the JSC unhandled-rejection SPI to Apple platforms

The macOS CI matrix built fine, but the Linux JSC job (WebKitGTK via gcc) failed:
JSGlobalContextSetUnhandledRejectionCallback is an Apple SPI absent from WebKitGTK,
and __builtin_available / its iOS/macOS platform names are Clang/Apple-only, so the
unguarded registration didn't compile under gcc.

- AppRuntime_JavaScriptCore.cpp: wrap the rejection-callback machinery (forward
  declaration, thread_local context, callback, and registration) in #if __APPLE__.
  On non-Apple JSC (WebKitGTK/Linux, Android JSC) tracking is now a documented no-op,
  consistent with the existing #if __APPLE__ guard around JSGlobalContextSetInspectable.
- Shared.cpp: tighten the compile-time gate to
  V8 || (JavaScriptCore && __APPLE__), so the rejection tests skip on non-Apple JSC
  where the hook is unavailable (otherwise they would hang waiting for a report).
- AppRuntime.h: note that JSC support is Apple-only (WebKitGTK JSC is a no-op).

Re-validated on Win32 V8 Release: AppRuntime rejection tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

Core/AppRuntime/Include/Babylon/AppRuntime.h

@@ -52,8 +52,10 @@ namespace Babylon
         // handled synchronously (e.g. `const p = Promise.reject(e); p.catch(...)`) is not reported.
         //
         // Coverage is determined by whether the engine exposes a host promise-rejection hook:
-        //   * V8 (Isolate::SetPromiseRejectCallback) and JavaScriptCore
-        //     (JSGlobalContextSetUnhandledRejectionCallback) -- supported.
+        //   * V8 (Isolate::SetPromiseRejectCallback) -- supported on all platforms.
+        //   * Apple JavaScriptCore (JSGlobalContextSetUnhandledRejectionCallback) -- supported. This
+        //     is an SPI present only in Apple's JSC; the WebKitGTK JSC used on Linux does not expose
+        //     it, so tracking is a no-op there.
         //   * Chakra (in-box/EdgeMode) and JSI -- no-op: neither exposes such a hook
         //     (JsSetHostPromiseRejectionTracker is ChakraCore-only, and neither jsi::Runtime nor
         //     V8JSI surfaces the V8 callback).

Core/AppRuntime/Source/AppRuntime_JavaScriptCore.cpp

@@ -1,17 +1,23 @@
 #include "AppRuntime.h"
-#include "AppRuntime_PromiseRejection.h"
 #include <napi/env.h>
 
+#if __APPLE__
+#include "AppRuntime_PromiseRejection.h"
+
 // JSGlobalContextSetUnhandledRejectionCallback is declared in the private JavaScriptCore header
 // <JavaScriptCore/JSContextRefPrivate.h>, which is not part of the public macOS/iOS SDK. The symbol
 // is exported by the JavaScriptCore framework (SPI), so it is forward-declared here and the call is
 // guarded with __builtin_available (it is JSC_API_AVAILABLE(macos(10.15.4), ios(13.4))). It registers
 // a JS function invoked at the microtask checkpoint with (promise, reason) for each promise that is
 // still unhandled at that point, so -- unlike V8 -- no deferral or candidate bookkeeping is needed.
+// This is Apple-only: the WebKitGTK JavaScriptCore used on Linux exposes neither this SPI nor
+// __builtin_available, so unhandled-rejection tracking is a no-op there (see AppRuntime.h).
 extern "C" void JSGlobalContextSetUnhandledRejectionCallback(JSGlobalContextRef ctx, JSObjectRef function, JSValueRef* exception);
+#endif
 
 namespace Babylon
 {
+#if __APPLE__
     namespace
     {
         // JSObjectMakeFunctionWithCallback takes no user-data argument; each AppRuntime owns its JSC
@@ -43,6 +49,7 @@ namespace Babylon
             return JSValueMakeUndefined(ctx);
         }
     }
+#endif
 
     void AppRuntime::RunEnvironmentTier(const char*)
     {
@@ -57,6 +64,7 @@ namespace Babylon
 
         Napi::Env env = Napi::Attach(globalContext);
 
+#if __APPLE__
         // Always track unhandled promise rejections (routed to the host UnhandledExceptionHandler).
         JSCRejectionContext rejectionContext{this, env};
         t_rejectionContext = &rejectionContext;
@@ -67,10 +75,13 @@ namespace Babylon
             JSStringRelease(callbackName);
             JSGlobalContextSetUnhandledRejectionCallback(globalContext, callback, nullptr);
         }
+#endif
 
         Run(env);
 
+#if __APPLE__
         t_rejectionContext = nullptr;
+#endif
 
         JSGlobalContextRelease(globalContext);
 

Tests/UnitTests/Shared/Shared.cpp

@@ -283,11 +283,12 @@ TEST(AppRuntime, DestroyDoesNotDeadlock)
 TEST(AppRuntime, UnhandledPromiseRejectionReachesHandler)
 {
     // Unhandled promise rejection tracking is implemented on the engines that expose a host
-    // promise-rejection hook: V8 (Isolate::SetPromiseRejectCallback) and JavaScriptCore
-    // (JSGlobalContextSetUnhandledRejectionCallback). The OS EdgeMode Chakra runtime and the V8JSI
-    // (JSI) shim expose no such hook, so the body is compiled out there and the test is skipped.
-#if !defined(JSRUNTIMEHOST_NAPI_ENGINE_V8) && !defined(JSRUNTIMEHOST_NAPI_ENGINE_JavaScriptCore)
-    GTEST_SKIP() << "unhandled promise rejection tracking is only implemented for the V8 and JavaScriptCore backends";
+    // promise-rejection hook: V8 (Isolate::SetPromiseRejectCallback) and Apple JavaScriptCore
+    // (JSGlobalContextSetUnhandledRejectionCallback, an SPI absent from WebKitGTK/Linux JSC). The OS
+    // EdgeMode Chakra runtime and the V8JSI (JSI) shim expose no such hook, so the body is compiled
+    // out there (and on non-Apple JSC) and the test is skipped.
+#if !(defined(JSRUNTIMEHOST_NAPI_ENGINE_V8) || (defined(JSRUNTIMEHOST_NAPI_ENGINE_JavaScriptCore) && defined(__APPLE__)))
+    GTEST_SKIP() << "unhandled promise rejection tracking requires the V8 or Apple JavaScriptCore backend";
 #else
     // A fire-and-forget rejected promise (no handler ever attached) must reach the embedder's
     // UnhandledExceptionHandler.
@@ -313,8 +314,8 @@ TEST(AppRuntime, UnhandledPromiseRejectionReachesHandler)
 TEST(AppRuntime, SynchronouslyHandledRejectionDoesNotReachHandler)
 {
     // Only engines with a host promise-rejection hook implement this tracking (see the note above).
-#if !defined(JSRUNTIMEHOST_NAPI_ENGINE_V8) && !defined(JSRUNTIMEHOST_NAPI_ENGINE_JavaScriptCore)
-    GTEST_SKIP() << "unhandled promise rejection tracking is only implemented for the V8 and JavaScriptCore backends";
+#if !(defined(JSRUNTIMEHOST_NAPI_ENGINE_V8) || (defined(JSRUNTIMEHOST_NAPI_ENGINE_JavaScriptCore) && defined(__APPLE__)))
+    GTEST_SKIP() << "unhandled promise rejection tracking requires the V8 or Apple JavaScriptCore backend";
 #else
     // A rejection that is handled synchronously in the same turn must NOT reach the handler --
     // reporting is deferred to the end of the turn, by which point the .catch has been attached.