Add browser-compatible Worker polyfill and WPT coverage

.github/workflows/build-linux.yml

@@ -54,14 +54,24 @@ jobs:
 
       - name: Run Tests
         working-directory: Build/ubuntu/Tests/UnitTests
-        run: ./UnitTests
-        env:
-          TSAN_OPTIONS: ${{ inputs.enable-thread-sanitizer && format('suppressions={0}/.github/tsan_suppressions.txt', github.workspace) || '' }}
+        run: |
           # JSC's concurrent GC on Linux uses SIGUSR1 + sem_wait to suspend mutator
           # threads at safepoints. TSan's signal interception delays SIGUSR1 delivery
           # indefinitely, deadlocking the Collector Thread's sem_wait. Disabling the
           # concurrent collector removes the dedicated Collector Thread, so GC runs
           # on the mutator without cross-thread signals. macOS JSC uses Mach
           # thread_suspend() and is unaffected.
-          JSC_useConcurrentGC: ${{ inputs.enable-thread-sanitizer && '0' || '' }}
+          if [[ "${{ inputs.enable-thread-sanitizer }}" == "true" ]]; then
+            export TSAN_OPTIONS="suppressions=${{ github.workspace }}/.github/tsan_suppressions.txt"
+            export JSC_useConcurrentGC=0
+          fi
+          ./UnitTests
 
+      - name: Run Node-API v7 conformance
+        working-directory: Build/ubuntu/Tests/NodeApi
+        run: |
+          if [[ "${{ inputs.enable-thread-sanitizer }}" == "true" ]]; then
+            export TSAN_OPTIONS="suppressions=${{ github.workspace }}/.github/tsan_suppressions.txt"
+            export JSC_useConcurrentGC=0
+          fi
+          ./NodeApiTests

.github/workflows/build-macos.yml

@@ -41,11 +41,16 @@ jobs:
             -D ENABLE_THREAD_SANITIZER=${{ inputs.enable-thread-sanitizer && 'ON' || 'OFF' }}
 
       - name: Build
-        run: cmake --build Build/macOS --target UnitTests --config RelWithDebInfo
+        run: cmake --build Build/macOS --target UnitTests NodeApiTests --config RelWithDebInfo
 
       - name: Run Tests
         working-directory: Build/macOS/Tests/UnitTests/RelWithDebInfo
         run: ./UnitTests
         env:
           TSAN_OPTIONS: ${{ inputs.enable-thread-sanitizer && format('suppressions={0}/.github/tsan_suppressions.txt', github.workspace) || '' }}
 
+      - name: Run Node-API v7 conformance
+        working-directory: Build/macOS/Tests/NodeApi/RelWithDebInfo
+        run: ./NodeApiTests
+        env:
+          TSAN_OPTIONS: ${{ inputs.enable-thread-sanitizer && format('suppressions={0}/.github/tsan_suppressions.txt', github.workspace) || '' }}

.github/workflows/worker-wpt.yml

@@ -0,0 +1,29 @@
+name: Worker WPT
+
+on:
+  pull_request:
+    branches: [napi-v7]
+
+jobs:
+  Ubuntu_JSC:
+    uses: ./.github/workflows/build-linux.yml
+
+  Ubuntu_JSC_Sanitizers:
+    uses: ./.github/workflows/build-linux.yml
+    with:
+      cc: clang
+      cxx: clang++
+      enable-sanitizers: true
+
+  Ubuntu_QuickJS_ThreadSanitizer:
+    uses: ./.github/workflows/build-linux.yml
+    with:
+      cc: clang
+      cxx: clang++
+      # Linux JSC suspends mutator threads with SIGUSR1. TSan intercepts the
+      # signal and deadlocks inside the uninstrumented system library, even
+      # with concurrent GC disabled. QuickJS still exercises the instrumented
+      # Worker ownership, message queues, and teardown paths without hiding
+      # host races behind an incompatible third-party runtime.
+      js-engine: QuickJS
+      enable-thread-sanitizer: true

CMakeLists.txt

@@ -51,11 +51,14 @@ FetchContent_Declare(UrlLib
     GIT_REPOSITORY https://github.com/BabylonJS/UrlLib.git
     GIT_TAG e86ffb34e77092266145497681efc74e0a920ffe
     EXCLUDE_FROM_ALL)
+FetchContent_Declare(zlib
+    URL "https://github.com/madler/zlib/archive/refs/tags/v1.3.1.tar.gz"
+    EXCLUDE_FROM_ALL)
 FetchContent_Declare(quickjs-ng
     GIT_REPOSITORY https://github.com/quickjs-ng/quickjs.git
     GIT_TAG 93d3f7df465027f487ed37e175a0bc3012fee79e
     EXCLUDE_FROM_ALL)
-    
+
 # --------------------------------------------------
 
 FetchContent_MakeAvailable(CMakeExtensions)
@@ -75,6 +78,14 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# A newer MSVC (windows-latest) emits C4875 ("a non-string literal argument to [[gsl::suppress]] is
+# deprecated") from the vendored GSL headers, which several targets compile with warnings-as-error.
+# Suppress this dependency-side deprecation so the Windows build isn't broken by toolchain drift. Must
+# be set before arcana.cpp / Core / Polyfills are added below so they inherit it.
+if(MSVC)
+    add_compile_options(/wd4875)
+endif()
+
 # --------------------------------------------------
 # Options
 # --------------------------------------------------
@@ -102,6 +113,10 @@ option(JSRUNTIMEHOST_POLYFILL_FILE "Include JsRuntimeHost Polyfill File and File
 option(JSRUNTIMEHOST_POLYFILL_PERFORMANCE "Include JsRuntimeHost Polyfill Performance." ON)
 option(JSRUNTIMEHOST_POLYFILL_TEXTDECODER "Include JsRuntimeHost Polyfill TextDecoder." ON)
 option(JSRUNTIMEHOST_POLYFILL_TEXTENCODER "Include JsRuntimeHost Polyfill TextEncoder." ON)
+option(JSRUNTIMEHOST_POLYFILL_WORKER "Include JsRuntimeHost Polyfill Worker." ON)
+option(JSRUNTIMEHOST_POLYFILL_STREAMS "Include JsRuntimeHost Polyfill Web Streams." ON)
+option(JSRUNTIMEHOST_POLYFILL_COMPRESSION "Include JsRuntimeHost Polyfills CompressionStream and DecompressionStream." ON)
+option(JSRUNTIMEHOST_POLYFILL_INDEXEDDB "Include JsRuntimeHost Polyfill IndexedDB." ON)
 
 # Sanitizers
 option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF)
@@ -154,6 +169,17 @@ endif()
 FetchContent_MakeAvailable_With_Message(arcana.cpp)
 set_property(TARGET arcana PROPERTY FOLDER Dependencies)
 
+if(ANDROID)
+    FetchContent_GetProperties(AndroidExtensions)
+    if(NOT AndroidExtensions_POPULATED)
+        FetchContent_Populate(AndroidExtensions)
+        FetchContent_GetProperties(AndroidExtensions)
+        add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR})
+    else()
+        add_subdirectory(${androidextensions_SOURCE_DIR} ${androidextensions_BINARY_DIR})
+    endif()
+endif()
+
 if(JSRUNTIMEHOST_POLYFILL_XMLHTTPREQUEST OR JSRUNTIMEHOST_POLYFILL_FETCH)
     FetchContent_MakeAvailable_With_Message(UrlLib)
     set_property(TARGET UrlLib PROPERTY FOLDER Dependencies)

Core/AppRuntime/CMakeLists.txt

@@ -54,6 +54,8 @@ if(NAPI_JAVASCRIPT_ENGINE STREQUAL "V8" AND JSRUNTIMEHOST_CORE_APPRUNTIME_V8_INS
     set_property(TARGET v8inspector PROPERTY FOLDER Dependencies)
 elseif(NAPI_JAVASCRIPT_ENGINE STREQUAL "QuickJS")
     target_link_libraries(AppRuntime PRIVATE qjs)
+elseif(NAPI_JAVASCRIPT_ENGINE STREQUAL "JavaScriptCore" AND UNIX AND NOT APPLE)
+    target_link_libraries(AppRuntime PRIVATE ${CMAKE_DL_LIBS})
 endif()
 
 set_property(TARGET AppRuntime PROPERTY FOLDER Core)

Core/AppRuntime/Include/Babylon/AppRuntime.h

@@ -21,6 +21,11 @@ namespace Babylon
             // Optional handler for unhandled exceptions.
             std::function<void(const Napi::Error&)> UnhandledExceptionHandler{DefaultUnhandledExceptionHandler};
 
+            // Optional final runtime-thread notification after engine and
+            // environment teardown. The callback is the thread's last action
+            // and must not access that runtime's Napi objects.
+            std::function<void()> ThreadExitHandler{};
+
             // Defines whether to enable the debugger. Only implemented for V8 and Chakra.
             bool EnableDebugger{false};
 
@@ -43,6 +48,17 @@ namespace Babylon
         void Suspend();
         void Resume();
 
+        // Permanently stop accepting work and exit after the currently
+        // executing dispatch returns. Unlike Terminate(), this does not
+        // interrupt JavaScript in the middle of its current task.
+        void Close();
+
+        // Permanently stop accepting work and request interruption of any
+        // JavaScript currently executing. The interruption is immediate on
+        // engines with an interrupt hook (including system JavaScriptCore) and
+        // cooperative between dispatches on the remaining engines.
+        void Terminate();
+
         void Dispatch(Dispatchable<void(Napi::Env)> callback);
 
         // Default unhandled exception handler that outputs the error message to the program output.
@@ -76,6 +92,14 @@ namespace Babylon
         // queue explicitly (Napi::DrainJobs / JS_ExecutePendingJob).
         void DrainMicrotasks(Napi::Env env);
 
+        // Engine tiers may query the shared termination flag without exposing
+        // engine types in the public API.
+        bool IsTerminationRequested() const noexcept;
+
+        // Execution watchdogs use a separate flag so Close() can finish the
+        // current task while Terminate() can still interrupt a tight loop.
+        bool IsExecutionTerminationRequested() const noexcept;
+
         Options m_options;
 
         class Impl;

Core/AppRuntime/Source/AppRuntime.cpp

@@ -4,6 +4,7 @@
 #include <arcana/threading/dispatcher.h>
 
 #include <cassert>
+#include <atomic>
 #include <optional>
 #include <mutex>
 #include <thread>
@@ -36,6 +37,8 @@ namespace Babylon
         arcana::cancellation_source m_cancelSource{};
         arcana::manual_dispatcher<128> m_dispatcher{};
         std::thread m_thread;
+        std::atomic_bool m_terminationRequested{false};
+        std::atomic_bool m_executionTerminationRequested{false};
     };
 
     AppRuntime::AppRuntime() :
@@ -47,7 +50,13 @@ namespace Babylon
         : m_options{std::move(options)}
         , m_impl{std::make_unique<Impl>()}
     {
-        m_impl->m_thread = std::thread{[this] { RunPlatformTier(); }};
+        m_impl->m_thread = std::thread{[this] {
+            RunPlatformTier();
+            if (m_options.ThreadExitHandler)
+            {
+                m_options.ThreadExitHandler();
+            }
+        }};
 
         Dispatch([this](Napi::Env env) {
             JsRuntime::CreateForJavaScript(env, [this](auto func) { Dispatch(std::move(func)); });
@@ -61,17 +70,7 @@ namespace Babylon
             m_impl->m_suspensionLock.reset();
         }
 
-        // Cancel immediately so pending work is dropped promptly, then append
-        // a no-op work item to wake the worker thread from blocking_tick. The
-        // no-op goes through push() which acquires the queue mutex, avoiding
-        // the race where a bare notify_all() can be missed by wait().
-        //
-        // NOTE: This preserves the existing shutdown behavior where pending
-        // callbacks are dropped on cancellation. A more complete solution
-        // would add cooperative shutdown (e.g. NotifyDisposing/Rundown) so
-        // consumers can finish cleanup work before the runtime is destroyed.
-        m_impl->m_cancelSource.cancel();
-        m_impl->Append([](Napi::Env) {});
+        Terminate();
 
         m_impl->m_thread.join();
     }
@@ -105,8 +104,44 @@ namespace Babylon
         m_impl->m_suspensionLock.reset();
     }
 
+    void AppRuntime::Terminate()
+    {
+        m_impl->m_executionTerminationRequested.store(true);
+        Close();
+    }
+
+    void AppRuntime::Close()
+    {
+        if (m_impl->m_terminationRequested.exchange(true))
+        {
+            return;
+        }
+
+        m_impl->m_cancelSource.cancel();
+
+        // Queueing under the dispatcher's mutex makes the wake-up immune to
+        // the missed-notification race covered by DestroyDoesNotDeadlock.
+        // The cancelled run loop drops this no-op rather than executing it.
+        m_impl->m_dispatcher.queue([]() {});
+    }
+
+    bool AppRuntime::IsTerminationRequested() const noexcept
+    {
+        return m_impl->m_terminationRequested.load();
+    }
+
+    bool AppRuntime::IsExecutionTerminationRequested() const noexcept
+    {
+        return m_impl->m_executionTerminationRequested.load();
+    }
+
     void AppRuntime::Dispatch(Dispatchable<void(Napi::Env)> func)
     {
+        if (IsTerminationRequested())
+        {
+            return;
+        }
+
         m_impl->Append([this, func{std::move(func)}](Napi::Env env) mutable {
             Execute([this, env, func{std::move(func)}]() mutable {
                 // Some engines (notably Hermes) require an open NAPI handle

Core/AppRuntime/Source/AppRuntime_JavaScriptCore.cpp

@@ -1,12 +1,62 @@
 #include "AppRuntime.h"
 #include <napi/env.h>
 
+#if __has_include(<JavaScriptCore/JSContextRefPrivate.h>)
+#include <JavaScriptCore/JSContextRefPrivate.h>
+#define JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT 1
+#elif defined(__unix__)
+#include <dlfcn.h>
+#define JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT 1
+#endif
+
+namespace
+{
+#if defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT)
+    using SetExecutionTimeLimit = void (*)(JSContextGroupRef, double, bool (*)(JSContextRef, void*), void*);
+    using ClearExecutionTimeLimit = void (*)(JSContextGroupRef);
+#endif
+}
+
 namespace Babylon
 {
     void AppRuntime::RunEnvironmentTier(const char*)
     {
         auto globalContext = JSGlobalContextCreateInGroup(nullptr, nullptr);
 
+#if defined(JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT) || \
+    defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT)
+        auto contextGroup = JSContextGetGroup(globalContext);
+        const auto shouldTerminateJSC = [](JSContextRef, void* context) {
+            return static_cast<AppRuntime*>(context)->IsExecutionTerminationRequested();
+        };
+#endif
+
+#if defined(JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT)
+        // Poll at a modest interval while JS is running. Returning true from
+        // this callback raises a catchable termination exception and lets the
+        // AppRuntime thread unwind, so Worker::terminate() also stops a tight
+        // loop that never reaches the dispatch queue.
+        JSContextGroupSetExecutionTimeLimit(
+            contextGroup,
+            0.05,
+            shouldTerminateJSC,
+            this);
+#elif defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT)
+        // WebKitGTK deliberately omits JSContextRefPrivate.h from its dev
+        // package, but current system builds export the same C ABI. Resolve it
+        // dynamically so JsRuntimeHost stays buildable against the public
+        // package and gracefully falls back to between-dispatch termination on
+        // older builds that do not export the watchdog.
+        auto setExecutionTimeLimit = reinterpret_cast<SetExecutionTimeLimit>(
+            dlsym(RTLD_DEFAULT, "JSContextGroupSetExecutionTimeLimit"));
+        auto clearExecutionTimeLimit = reinterpret_cast<ClearExecutionTimeLimit>(
+            dlsym(RTLD_DEFAULT, "JSContextGroupClearExecutionTimeLimit"));
+        if (setExecutionTimeLimit != nullptr && clearExecutionTimeLimit != nullptr)
+        {
+            setExecutionTimeLimit(contextGroup, 0.05, shouldTerminateJSC, this);
+        }
+#endif
+
 #if __APPLE__
         if (__builtin_available(iOS 16.4, macOS 13.3, *))
         {
@@ -18,6 +68,15 @@ namespace Babylon
 
         Run(env);
 
+#if defined(JSRUNTIMEHOST_HAS_JSC_EXECUTION_TIME_LIMIT)
+        JSContextGroupClearExecutionTimeLimit(contextGroup);
+#elif defined(JSRUNTIMEHOST_LOOKUP_JSC_EXECUTION_TIME_LIMIT)
+        if (setExecutionTimeLimit != nullptr && clearExecutionTimeLimit != nullptr)
+        {
+            clearExecutionTimeLimit(contextGroup);
+        }
+#endif
+
         JSGlobalContextRelease(globalContext);
 
         // Detach must come after JSGlobalContextRelease since it triggers finalizers which require env.

Core/Node-API-JSI/CMakeLists.txt

@@ -57,7 +57,12 @@ if(NOT TARGET jsi)
 endif()
 
 target_include_directories(napi
-    PUBLIC "include")
+    PUBLIC "include"
+    # napi.h pulls in the shared <napi/js_native_api_types.h>, which lives in
+    # Core/Node-API/Include/Shared. That sibling isn't built when the engine is JSI
+    # (Core/CMakeLists.txt selects Node-API-JSI instead of Node-API), so reference the shared
+    # headers directly here -- otherwise the JSI napi fails to compile with C1083.
+    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../Node-API/Include/Shared")
 
 target_link_libraries(napi
     PUBLIC jsi)