Fix Asyncify.handleAsync conflict with PROXY_SYNC_ASYNC

When a JS library function has both __proxy:'sync' and __async:'auto',
the compiler generates an Asyncify.handleAsync wrapper.  When called
from the PROXY_SYNC_ASYNC path on the main thread, handleAsync
triggers an Asyncify unwind instead of returning a Promise, causing
"rtn.then is not a function" in the proxy infrastructure.

Fix by generating a PThread.currentProxiedOperationCallerThread check
in handleAsyncFunction (jsifier.mjs): when in a proxied context, call
the inner function directly and skip the Asyncify unwind, letting the
proxy mechanism handle the async return.

Author: thiblahute

src/jsifier.mjs

@@ -360,16 +360,29 @@ ${body};
   });
 }
 
-function handleAsyncFunction(snippet, sig) {
+function handleAsyncFunction(snippet, sig, proxyingMode) {
   const return64 = sig && (MEMORY64 && sig.startsWith('p') || sig.startsWith('j'))
   let handleAsync = 'Asyncify.handleAsync(innerFunc)'
   if (return64 && ASYNCIFY == 1) {
     handleAsync = makeReturn64(handleAsync);
   }
+  // When a function uses both __proxy:'sync' and __async:'auto', the proxy
+  // mechanism (PROXY_SYNC_ASYNC) handles the async return itself.  In that
+  // case, skip the Asyncify unwind and call the inner function directly so
+  // the proxy can use .then() on the returned Promise.
+  const skipHandleAsync = PTHREADS && ASYNCIFY == 1 && proxyingMode === 'sync';
   return modifyJSFunction(snippet, (args, body, async_, oneliner) => {
     if (!oneliner) {
       body = `{\n${body}\n}`;
     }
+    if (skipHandleAsync) {
+      return `\
+function(${args}) {
+  let innerFunc = ${async_} () => ${body};
+  if (PThread.currentProxiedOperationCallerThread) return innerFunc();
+  return ${handleAsync};
+}\n`;
+    }
     return `\
 function(${args}) {
   let innerFunc = ${async_} () => ${body};
@@ -474,11 +487,11 @@ function(${args}) {
       compileTimeContext.i53ConversionDeps.forEach((d) => deps.push(d));
     }
 
+    const proxyingMode = LibraryManager.library[symbol + '__proxy'];
+
     if (ASYNCIFY && isAsyncFunction == 'auto') {
-      snippet = handleAsyncFunction(snippet, sig);
+      snippet = handleAsyncFunction(snippet, sig, proxyingMode);
     }
-
-    const proxyingMode = LibraryManager.library[symbol + '__proxy'];
     if (proxyingMode) {
       if (!['sync', 'async', 'none'].includes(proxyingMode)) {
         error(`JS library error: invalid proxying mode '${symbol}__proxy: ${proxyingMode}' specified`);

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'],),