Add deterministic test for AppRuntime destructor deadlock race

Add a test that deterministically triggers the lost-wakeup race condition
in WorkQueue::~WorkQueue(). Uses arcana testing hooks to sleep while
holding the queue mutex before wait(), guaranteeing the worker is between
the condition check and wait() when the destructor fires cancel+notify.

The test is expected to FAIL (deadlock timeout) with the current code,
proving the bug exists. The fix will be in a separate PR.

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

Author: bghgary

CMakeLists.txt

@@ -14,8 +14,8 @@ FetchContent_Declare(AndroidExtensions
     GIT_TAG 2d5af72259cc73e5f249d3c99bee2010be9cb042
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(arcana.cpp
-    GIT_REPOSITORY https://github.com/microsoft/arcana.cpp.git
-    GIT_TAG 7c6be8aaa29effbc8ee1a2217388fb6e399150d2
+    GIT_REPOSITORY https://github.com/bghgary/arcana.cpp.git
+    GIT_TAG d5804f8a51de0e37d78bdea469c21823eb7d27ce
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(asio
     GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
@@ -113,6 +113,10 @@ endif()
 
 # --------------------------------------------------
 
+if(JSRUNTIMEHOST_TESTS)
+    add_compile_definitions(ARCANA_TESTING_HOOKS)
+endif()
+
 FetchContent_MakeAvailable_With_Message(arcana.cpp)
 set_property(TARGET arcana PROPERTY FOLDER Dependencies)
 

Core/AppRuntime/Include/Babylon/AppRuntime.h

@@ -63,5 +63,10 @@ namespace Babylon
 
         std::unique_ptr<WorkQueue> m_workQueue;
         Options m_options;
+
+#ifdef ARCANA_TESTING_HOOKS
+    public:
+        void SetBeforeWaitCallback(std::function<void()> callback);
+#endif
     };
 }

Core/AppRuntime/Source/AppRuntime.cpp

@@ -57,4 +57,11 @@ namespace Babylon
             });
         });
     }
+
+#ifdef ARCANA_TESTING_HOOKS
+    void AppRuntime::SetBeforeWaitCallback(std::function<void()> callback)
+    {
+        m_workQueue->SetBeforeWaitCallback(std::move(callback));
+    }
+#endif
 }

Core/AppRuntime/Source/WorkQueue.h

@@ -54,5 +54,13 @@ namespace Babylon
         arcana::manual_dispatcher<128> m_dispatcher{};
 
         std::thread m_thread;
+
+#ifdef ARCANA_TESTING_HOOKS
+    public:
+        void SetBeforeWaitCallback(std::function<void()> callback)
+        {
+            m_dispatcher.set_before_wait_callback(std::move(callback));
+        }
+#endif
     };
 }

Tests/UnitTests/Shared/Shared.cpp

@@ -11,8 +11,11 @@
 #include <Babylon/Polyfills/Blob.h>
 #include <Babylon/Polyfills/TextDecoder.h>
 #include <gtest/gtest.h>
+#include <atomic>
+#include <chrono>
 #include <future>
 #include <iostream>
+#include <thread>
 
 namespace
 {
@@ -125,6 +128,62 @@ TEST(Console, Log)
     done.get_future().get();
 }
 
+TEST(AppRuntime, DestroyDoesNotDeadlock)
+{
+    // Deterministic test for the race condition in the AppRuntime destructor.
+    //
+    // A per-instance hook sleeps WHILE HOLDING the queue mutex, right before
+    // condition_variable::wait(). We synchronize so the worker is definitely
+    // in the hook before triggering destruction.
+    //
+    // Old (broken) code: cancel() + notify_all() fire without the mutex,
+    //   so the notification is lost while the worker sleeps → deadlock.
+    // Fixed code: Append(cancel) calls push() which NEEDS the mutex,
+    //   so it blocks until the worker enters wait() → notification delivered.
+    for (int i = 0; i < 3; i++)
+    {
+        // Shared state for hook synchronization
+        std::atomic<bool> hookEnabled{false};
+        std::atomic<bool> hookSignaled{false};
+        std::promise<void> workerInHook;
+
+        auto runtime = std::make_unique<Babylon::AppRuntime>();
+
+        // Set the callback once, before any dispatches. The callback checks
+        // hookEnabled so we control when it actually sleeps.
+        runtime->SetBeforeWaitCallback([&]() {
+            if (hookEnabled.load() && !hookSignaled.exchange(true))
+                workerInHook.set_value();
+            if (hookEnabled.load())
+                std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        });
+
+        // Dispatch work and wait for completion
+        std::promise<void> ready;
+        runtime->Dispatch([&ready](Napi::Env) {
+            ready.set_value();
+        });
+        ready.get_future().wait();
+
+        // Enable the hook and dispatch a no-op to wake the worker,
+        // ensuring it cycles through the hook on its way back to idle
+        hookEnabled.store(true);
+        runtime->Dispatch([](Napi::Env) {});
+
+        // Wait for the worker to be in the hook (holding mutex, sleeping)
+        workerInHook.get_future().wait();
+
+        // NOW destroy
+        auto destroyFuture = std::async(std::launch::async, [&runtime]() {
+            runtime.reset();
+        });
+
+        auto status = destroyFuture.wait_for(std::chrono::seconds(5));
+        ASSERT_NE(status, std::future_status::timeout)
+            << "Deadlock detected on iteration " << i;
+    }
+}
+
 int RunTests()
 {
     testing::InitGoogleTest();

Tests/UnitTests/Win32/App.cpp

@@ -1,13 +1,15 @@
 #include "../Shared/Shared.h"
 #include <Windows.h>
 #include "Babylon/DebugTrace.h"
+#include <gtest/gtest.h>
 
-int main()
+int main(int argc, char** argv)
 {
     SetConsoleOutputCP(CP_UTF8);
 
     Babylon::DebugTrace::EnableDebugTrace(true);
     Babylon::DebugTrace::SetTraceOutput([](const char* trace) { OutputDebugStringA(trace); });
 
-    return RunTests();
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }