Fix Asyncify.handleAsync conflict with PROXY_SYNC_ASYNC

When in a proxied context, skip the Asyncify unwind and call
startAsync() directly, letting the proxy mechanism handle the
async return.

This already affects __syscall_poll and would also affect the new
__syscall_ppoll.

Author: thiblahute

src/lib/libasync.js

@@ -443,10 +443,17 @@ addToLibrary({
     //
     // This is particularly useful for native JS `async` functions where the
     // returned value will "just work" and be passed back to C++.
-    handleAsync: (startAsync) => Asyncify.handleSleep(async (wakeUp) => {
-      // TODO: add error handling as a second param when handleSleep implements it.
-      wakeUp(await startAsync());
-    }),
+    handleAsync: (startAsync) => {
+#if PTHREADS
+      // When called from a proxied function (PROXY_SYNC_ASYNC), the proxy
+      // mechanism handles the async return.  Skip the Asyncify unwind.
+      if (PThread.currentProxiedOperationCallerThread) return startAsync();
+#endif
+      return Asyncify.handleSleep(async (wakeUp) => {
+        // TODO: add error handling as a second param when handleSleep implements it.
+        wakeUp(await startAsync());
+      });
+    },
 
 #elif ASYNCIFY == 2
     //

test/core/test_poll_blocking_asyncify_pthread.c

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2026 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <poll.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <time.h>
+#include <unistd.h>
+
+static int fds[2];
+
+static void *writer(void *arg) {
+  write(fds[1], "x", 1);
+  return NULL;
+}
+
+int main(void) {
+  pthread_t t;
+  char buf;
+  struct pollfd pfd = {.events = POLLIN};
+
+  pipe(fds);
+  pfd.fd = fds[0];
+
+  // poll should timeout on an empty pipe
+  assert(poll(&pfd, 1, 100) == 0);
+
+  // poll should return immediately when data is already available
+  write(fds[1], "a", 1);
+  assert(poll(&pfd, 1, 1000) == 1);
+  assert(pfd.revents & POLLIN);
+  assert(read(fds[0], &buf, 1) == 1 && buf == 'a');
+
+  // poll should wake up from a cross-thread write
+  pfd.revents = 0;
+  pthread_create(&t, NULL, writer, NULL);
+  assert(poll(&pfd, 1, 5000) == 1);
+  assert(pfd.revents & POLLIN);
+  assert(read(fds[0], &buf, 1) == 1 && buf == 'x');
+  pthread_join(t, NULL);
+
+  // ppoll should also timeout on an empty pipe
+  struct timespec ts = {0, 200 * 1000000L};
+  struct timespec begin, end;
+  pfd.revents = 0;
+  clock_gettime(CLOCK_MONOTONIC, &begin);
+  assert(ppoll(&pfd, 1, &ts, NULL) == 0);
+  clock_gettime(CLOCK_MONOTONIC, &end);
+  long elapsed_ms = (end.tv_sec - begin.tv_sec) * 1000 +
+                    (end.tv_nsec - begin.tv_nsec) / 1000000;
+  assert(elapsed_ms >= 195);
+
+  printf("done\n");
+}

test/test_core.py

@@ -9645,6 +9645,18 @@ def test_poll_blocking_asyncify(self):
       self.skipTest('test requires setTimeout which is not supported under v8')
     self.do_runf('core/test_poll_blocking_asyncify.c', 'done\n')
 
+  @no_esm_integration('WASM_ESM_INTEGRATION is not compatible with ASYNCIFY=1')
+  @requires_pthreads
+  def test_poll_blocking_asyncify_pthread(self):
+    # Only testing ASYNCIFY=1: JSPI's handleAsync is a plain async function
+    # and doesn't have this bug.  Also, with_asyncify_and_jspi can't be
+    # combined with requires_pthreads since require_jspi may select d8 which
+    # doesn't support pthreads (require_pthreads then hard-fails instead of
+    # skipping).
+    self.set_setting('ASYNCIFY')
+    self.do_runf('core/test_poll_blocking_asyncify_pthread.c', 'done\n',
+                 cflags=['-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'])
+
   @parameterized({
     '': ([],),
     'pthread': (['-pthread'],),