Fix Node.js exit for library builds with pthreads

When building without a main function (a library build), and using pthreads
to do background work, the main Node.js thread has no event loop work to
keep Node.js alive. The workers are also unreferenced when they start
executing, so Node.js will exit prematurely before the background thread
can finish its work.

To prevent this, change the worker reference logic so that we only
`unref()` workers upon execution if `HAS_MAIN` is enabled. For library
builds, we keep them referenced (`worker.ref()`) to keep the process
alive while they are active.

We also ensure idle workers returned to the pool are `unref()`'d across
all Node builds (not just with `PROXY_TO_PTHREAD`) so that an idle
pool doesn't leak references preventing exit.

Fixes #23092

Author: brendandahl

src/lib/libpthread.js

@@ -208,11 +208,11 @@ var LibraryPThread = {
       // worker pool as an unused worker.
       worker.pthread_ptr = 0;
 
-#if ENVIRONMENT_MAY_BE_NODE && PROXY_TO_PTHREAD
+#if ENVIRONMENT_MAY_BE_NODE
       if (ENVIRONMENT_IS_NODE) {
-        // Once the proxied main thread has finished, mark it as weakly
+        // Once the worker is returned to the pool, mark it as weakly
         // referenced so that its existence does not prevent Node.js from
-        // exiting.  This has no effect if the worker is already weakly
+        // exiting. This has no effect if the worker is already weakly
         // referenced.
         worker.unref();
       }
@@ -689,11 +689,17 @@ var LibraryPThread = {
 #endif
 #if ENVIRONMENT_MAY_BE_NODE
     if (ENVIRONMENT_IS_NODE) {
+#if HAS_MAIN
       // Mark worker as weakly referenced once we start executing a pthread,
       // so that its existence does not prevent Node.js from exiting.  This
       // has no effect if the worker is already weakly referenced (e.g. if
       // this worker was previously idle/unused).
       worker.unref();
+#else
+      // When there is no main() function treat the program as a library and mark the worker as
+      // strongly referenced, so that it keeps Node.js alive while working.
+      worker.ref();
+#endif
     }
 #endif
     // Ask the worker to start executing its pthread entry point function.

test/core/pthread/test_pthread_exit_library.c

@@ -0,0 +1,38 @@
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <emscripten.h>
+#include <emscripten/proxying.h>
+#include <emscripten/threading.h>
+
+void create_done(void* arg) {
+    printf("done\n");
+    // Notify JS to resolve promise
+    EM_ASM({
+        doneCallback();
+    });
+}
+
+void* worker(void* arg) {
+    printf("worker starting\n");
+    fflush(stdout);
+    emscripten_thread_sleep(100);
+
+    // proxy back to the main thread
+    emscripten_proxy_async(
+        emscripten_proxy_get_system_queue(),
+        emscripten_main_runtime_thread_id(),
+        create_done,
+        NULL
+    );
+    return NULL;
+}
+
+EMSCRIPTEN_KEEPALIVE
+void create_thread_async() {
+    pthread_t thread;
+    int rc = pthread_create(&thread, NULL, worker, NULL);
+    assert(rc == 0);
+    pthread_detach(thread);
+}

test/core/pthread/test_pthread_exit_library.out

@@ -0,0 +1,4 @@
+initialized
+worker starting
+done
+exiting

test/core/pthread/test_pthread_exit_library.post.js

@@ -0,0 +1,14 @@
+let resolveDone;
+const p = new Promise(resolve => resolveDone = resolve);
+
+globalThis.doneCallback = function() {
+  resolveDone();
+};
+
+Module['onRuntimeInitialized'] = function() {
+  console.log('initialized');
+  Module['_create_thread_async']();
+  p.then(() => {
+    console.log('exiting');
+  });
+};

test/test_core.py

@@ -9164,6 +9164,12 @@ def test_pthread_keepalive(self):
   def test_pthread_weak_ref(self):
     self.do_core_test('pthread/test_pthread_weak_ref.c')
 
+  @requires_pthreads
+  def test_pthread_exit_library(self):
+    # Test that Node.js doesn't exit while there are still pthreads running when there is no main function.
+    self.cflags += ['--post-js', test_file('core/pthread/test_pthread_exit_library.post.js')]
+    self.do_core_test('pthread/test_pthread_exit_library.c')
+
   @requires_pthreads
   def test_pthread_exit_main(self):
     self.do_core_test('pthread/test_pthread_exit_main.c')