@crossbind/bridge-tools 0.0.0-stage → 2.0.0-beta.72

package/dist/emscripten/include/emscripten/proxying.h

@@ -0,0 +1,313 @@
+/*
+ * Copyright 2021 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.
+ */
+
+#pragma once
+
+#include <emscripten/emscripten.h>
+#include <emscripten/promise.h>
+
+#include <pthread.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Opaque handle to a set of thread-local work queues to which work can be
+// asynchronously or synchronously proxied from other threads. When work is
+// proxied to a queue on a particular thread, that thread is notified to start
+// processing work from that queue if it is not already doing so.
+//
+// Proxied work can only be completed on live thread runtimes, so users must
+// ensure either that all proxied work is completed before a thread exits or
+// that the thread exits with a live runtime, e.g. via
+// `emscripten_exit_with_live_runtime` to avoid dropped work.
+typedef struct em_proxying_queue em_proxying_queue;
+
+// Create and destroy proxying queues.
+em_proxying_queue* em_proxying_queue_create(void);
+void em_proxying_queue_destroy(em_proxying_queue* q);
+
+// Get the queue used for proxying low-level runtime work. Work on this queue
+// may be processed at any time inside system functions, so it must be
+// nonblocking and safe to run at any time, similar to a native signal handler.
+em_proxying_queue* emscripten_proxy_get_system_queue(void);
+
+// Execute all the tasks enqueued for the current thread on the given queue. New
+// tasks that are enqueued concurrently with this execution will be executed as
+// well. This function returns once it observes an empty queue.
+void emscripten_proxy_execute_queue(em_proxying_queue* q);
+
+// Opaque handle to a currently-executing proxied task, used to signal the end
+// of the task.
+typedef struct em_proxying_ctx em_proxying_ctx;
+
+// Signal the end of a task proxied with `emscripten_proxy_sync_with_ctx`.
+void emscripten_proxy_finish(em_proxying_ctx* ctx);
+
+// Enqueue `func` on the given queue and thread and return immediately. Returns
+// true if the work was successfully enqueued and the target thread notified or
+// false otherwise.
+bool emscripten_proxy_async(em_proxying_queue* q,
+                            pthread_t target_thread,
+                            void (*func)(void*),
+                            void* arg);
+
+// Enqueue `func` on the given queue and thread and wait for it to finish
+// executing before returning. Returns true if the task was successfully
+// completed and false otherwise, including if the target thread is canceled or
+// exits before the work is completed.
+bool emscripten_proxy_sync(em_proxying_queue* q,
+                           pthread_t target_thread,
+                           void (*func)(void*),
+                           void* arg);
+
+// Enqueue `func` on the given queue and thread and wait for it to be executed
+// and for the task to be marked finished with `emscripten_proxy_finish` before
+// returning. `func` need not call `emscripten_proxy_finish` itself; it could
+// instead store the context pointer and call `emscripten_proxy_finish` at an
+// arbitrary later time. Returns true if the task was successfully completed and
+// false otherwise, including if the target thread is canceled or exits before
+// the work is completed.
+bool emscripten_proxy_sync_with_ctx(em_proxying_queue* q,
+                                    pthread_t target_thread,
+                                    void (*func)(em_proxying_ctx*, void*),
+                                    void* arg);
+
+// Enqueue `func` on the given queue and thread. Once (and if) it finishes
+// executing, it will asynchronously proxy `callback` back to the current thread
+// on the same queue, or if the target thread dies before the work can be
+// completed, `cancel` will be proxied back instead. All three functions will
+// receive the same argument, `arg`. Returns true if `func` was successfully
+// enqueued and the target thread notified or false otherwise.
+bool emscripten_proxy_callback(em_proxying_queue* q,
+                               pthread_t target_thread,
+                               void (*func)(void*),
+                               void (*callback)(void*),
+                               void (*cancel)(void*),
+                               void* arg);
+
+// Enqueue `func` on the given queue and thread. Once (and if) it finishes the
+// task by calling `emscripten_proxy_finish` on the given `em_proxying_ctx`, it
+// will asynchronously proxy `callback` back to the current thread on the same
+// queue, or if the target thread dies before the work can be completed,
+// `cancel` will be proxied back instead. All three functions will receive the
+// same argument, `arg`. Returns true if `func` was successfully enqueued and
+// the target thread notified or false otherwise.
+bool emscripten_proxy_callback_with_ctx(em_proxying_queue* q,
+                                        pthread_t target_thread,
+                                        void (*func)(em_proxying_ctx*, void*),
+                                        void (*callback)(void*),
+                                        void (*cancel)(void*),
+                                        void* arg);
+
+__attribute__((warn_unused_result)) em_promise_t
+emscripten_proxy_promise(em_proxying_queue* q,
+                         pthread_t target_thread,
+                         void (*func)(void*),
+                         void* arg);
+
+__attribute__((warn_unused_result)) em_promise_t
+emscripten_proxy_promise_with_ctx(em_proxying_queue* q,
+                                  pthread_t target_thread,
+                                  void (*func)(em_proxying_ctx*, void*),
+                                  void* arg);
+
+#ifdef __cplusplus
+} // extern "C"
+
+#if __cplusplus < 201103L
+#warning "C++ ProxyingQueue support requires building with -std=c++11 or newer!"
+#else
+
+#include <functional>
+#include <thread>
+#include <utility>
+
+namespace emscripten {
+
+// A thin C++ wrapper around the underlying C API.
+class ProxyingQueue {
+public:
+  // Simple wrapper around `em_proxying_ctx*` providing a `finish` method as an
+  // alternative to `emscripten_proxy_finish`.
+  struct ProxyingCtx {
+    em_proxying_ctx* ctx;
+
+    ProxyingCtx() = default;
+    ProxyingCtx(em_proxying_ctx* ctx) : ctx(ctx) {}
+    void finish() { emscripten_proxy_finish(ctx); }
+  };
+
+private:
+  static void runAndFree(void* arg) {
+    auto* f = (std::function<void()>*)arg;
+    (*f)();
+    delete f;
+  }
+
+  static void run(void* arg) {
+    auto* f = (std::function<void()>*)arg;
+    (*f)();
+  }
+
+  static void runWithCtx(em_proxying_ctx* ctx, void* arg) {
+    auto* f = (std::function<void(ProxyingCtx)>*)arg;
+    (*f)(ProxyingCtx{ctx});
+  }
+
+  struct CallbackFuncs {
+    std::function<void()> func;
+    std::function<void()> callback;
+    std::function<void()> cancel;
+
+    CallbackFuncs(std::function<void()>&& func,
+                  std::function<void()>&& callback,
+                  std::function<void()>&& cancel)
+      : func(std::move(func)), callback(std::move(callback)),
+        cancel(std::move(cancel)) {}
+  };
+
+  static void runFunc(void* arg) {
+    auto* info = (CallbackFuncs*)arg;
+    info->func();
+  }
+
+  static void runCallback(void* arg) {
+    auto* info = (CallbackFuncs*)arg;
+    info->callback();
+    delete info;
+  }
+
+  static void runCancel(void* arg) {
+    auto* info = (CallbackFuncs*)arg;
+    if (info->cancel) {
+      info->cancel();
+    }
+    delete info;
+  }
+
+  struct CallbackWithCtxFuncs {
+    std::function<void(ProxyingCtx)> func;
+    std::function<void()> callback;
+    std::function<void()> cancel;
+
+    CallbackWithCtxFuncs(std::function<void(ProxyingCtx)>&& func,
+                         std::function<void()>&& callback,
+                         std::function<void()>&& cancel)
+      : func(std::move(func)), callback(std::move(callback)),
+        cancel(std::move(cancel)) {}
+  };
+
+  static void runFuncWithCtx(em_proxying_ctx* ctx, void* arg) {
+    auto* info = (CallbackWithCtxFuncs*)arg;
+    info->func(ProxyingCtx{ctx});
+  }
+
+  static void runCallbackWithCtx(void* arg) {
+    auto* info = (CallbackWithCtxFuncs*)arg;
+    info->callback();
+    delete info;
+  }
+
+  static void runCancelWithCtx(void* arg) {
+    auto* info = (CallbackWithCtxFuncs*)arg;
+    if (info->cancel) {
+      info->cancel();
+    }
+    delete info;
+  }
+
+public:
+  em_proxying_queue* queue = em_proxying_queue_create();
+
+  // ProxyingQueue can be moved but not copied. It is not valid to call any
+  // methods on ProxyingQueues that have been moved out of.
+  ProxyingQueue() = default;
+  ProxyingQueue& operator=(const ProxyingQueue&) = delete;
+  ProxyingQueue& operator=(ProxyingQueue&& other) {
+    if (this != &other) {
+      if (queue) {
+        em_proxying_queue_destroy(queue);
+      }
+      queue = other.queue;
+      other.queue = nullptr;
+    }
+    return *this;
+  }
+
+  ProxyingQueue(const ProxyingQueue&) = delete;
+  ProxyingQueue(ProxyingQueue&& other) : queue(nullptr) {
+    *this = std::move(other);
+  }
+
+  ~ProxyingQueue() {
+    if (queue) {
+      em_proxying_queue_destroy(queue);
+    }
+  }
+
+  void execute() { emscripten_proxy_execute_queue(queue); }
+
+  // Return true if the work was successfully enqueued and false otherwise.
+  // Refer to the corresponding C API documentation.
+  bool proxyAsync(pthread_t target, std::function<void()>&& func) {
+    std::function<void()>* arg = new std::function<void()>(std::move(func));
+    if (!emscripten_proxy_async(queue, target, runAndFree, (void*)arg)) {
+      delete arg;
+      return false;
+    }
+    return true;
+  }
+
+  bool proxySync(const pthread_t target, const std::function<void()>& func) {
+    return emscripten_proxy_sync(queue, target, run, (void*)&func);
+  }
+
+  bool proxySyncWithCtx(const pthread_t target,
+                        const std::function<void(ProxyingCtx)>& func) {
+    return emscripten_proxy_sync_with_ctx(
+      queue, target, runWithCtx, (void*)&func);
+  }
+
+  bool proxyCallback(pthread_t target,
+                     std::function<void()>&& func,
+                     std::function<void()>&& callback,
+                     std::function<void()>&& cancel) {
+    CallbackFuncs* info = new CallbackFuncs(
+      std::move(func), std::move(callback), std::move(cancel));
+    if (!emscripten_proxy_callback(
+          queue, target, runFunc, runCallback, runCancel, info)) {
+      delete info;
+      return false;
+    }
+    return true;
+  }
+
+  bool proxyCallbackWithCtx(pthread_t target,
+                            std::function<void(ProxyingCtx)>&& func,
+                            std::function<void()>&& callback,
+                            std::function<void()>&& cancel) {
+    CallbackWithCtxFuncs* info = new CallbackWithCtxFuncs(
+      std::move(func), std::move(callback), std::move(cancel));
+    if (!emscripten_proxy_callback_with_ctx(queue,
+                                            target,
+                                            runFuncWithCtx,
+                                            runCallbackWithCtx,
+                                            runCancelWithCtx,
+                                            info)) {
+      delete info;
+      return false;
+    }
+    return true;
+  }
+};
+
+} // namespace emscripten
+
+#endif // __cplusplus < 201103L
+#endif // __cplusplus

package/dist/emscripten/include/emscripten/stack.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020 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.
+ */
+
+#pragma once
+
+#include <inttypes.h>
+#include <stddef.h>
+
+// API that gives access to introspecting the Wasm data stack.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns the starting address of the stack. This is the address
+// that the stack pointer would point to when no bytes are in use on the stack.
+uintptr_t emscripten_stack_get_base(void);
+
+// Returns the end address of the stack. This is the address that the stack
+// pointer would point to when the whole stack is in use.  (the address pointed
+// to by the end is not part of the stack itself). Note that the stack grows
+// down so the address returned by emscripten_stack_get_end() is smaller than
+// emscripten_stack_get_base().
+uintptr_t emscripten_stack_get_end(void);
+
+// Setup internal base/end values based on the initial values that were either
+// set at compile time (in static linking) or instantiation time (for dynamic
+// linking).
+void emscripten_stack_init(void);
+
+// Sets the internal values reported by emscripten_stack_get_base() and
+// emscripten_stack_get_end().  This should be only used by low level libraries
+// such as asyncify fibers.
+void emscripten_stack_set_limits(void* _Nonnull base, void* _Nonnull end);
+
+// Returns the current stack pointer.
+uintptr_t emscripten_stack_get_current(void);
+
+// Returns the number of free bytes left on the stack.  This is required to be
+// fast so that it can be called frequently.
+size_t emscripten_stack_get_free(void);
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/syscalls.h

@@ -0,0 +1,129 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <poll.h>
+#include <stdint.h>
+#include <sys/epoll.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __syscall_chdir(const char *path);
+int __syscall_mknod(const char *path, mode_t mode, dev_t dev);
+int __syscall_chmod(const char *path, mode_t mode);
+pid_t __syscall_getpid(void);
+int __syscall_access(const char *path, int amode);
+int __syscall_sync(void);
+int __syscall_rmdir(const char *path);
+int __syscall_dup(int fd);
+int __syscall_acct(const char *filename);
+int __syscall_ioctl(int fd, int request, ...);
+int __syscall_setpgid(pid_t pid, pid_t gpid);
+mode_t __syscall_umask(mode_t mask);
+pid_t __syscall_getppid(void);
+pid_t __syscall_getpgrp(void);
+pid_t __syscall_setsid(void);
+int __syscall_getrusage(int who, struct rusage *usage);
+int __syscall_munmap(void *addr, size_t len);
+int __syscall_fchmod(int fd, mode_t mode);
+int __syscall_getpriority(int which, id_t who);
+int __syscall_setpriority(int which, id_t who, int prio);
+int __syscall_socketcall(int call, long args[6]);
+pid_t __syscall_wait4(pid_t pid, int *wstatus, int options, struct rusage *rusage);
+int __syscall_setdomainname(const char *name, size_t len);
+int __syscall_uname(struct utsname *buf);
+int __syscall_mprotect(size_t start, size_t len, int prot);
+pid_t __syscall_getpgid(pid_t pid);
+int __syscall_fchdir(int fd);
+int __syscall_msync(void *addr, size_t len, int flags);
+pid_t __syscall_getsid(pid_t pid);
+int __syscall_fdatasync(int fd);
+int __syscall_mlock(const void *addr, size_t len);
+int __syscall_munlock(const void *addr, size_t len);
+int __syscall_mlockall(int flags);
+int __syscall_munlockall(void);
+int __syscall_mremap(void *old_addr, size_t old_size, size_t new_size, int flags, void *new_addr);
+int __syscall_poll(struct pollfd *fds, nfds_t nfds, int timeout);
+int __syscall_poll_nonblocking(struct pollfd *fds, nfds_t nfds);
+int __syscall_getcwd(char *buf, size_t size);
+intptr_t __syscall_mmap2(void *addr, size_t len, int prot, int flags, int fd, off_t offset);
+int __syscall_truncate64(const char *path, off_t length);
+int __syscall_ftruncate64(int fd, off_t length);
+int __syscall_stat64(const char *path, struct stat *buf);
+int __syscall_lstat64(const char *path, struct stat *buf);
+int __syscall_fstat64(int fd, struct stat *buf);
+uid_t __syscall_getuid32(void);
+gid_t __syscall_getgid32(void);
+uid_t __syscall_geteuid32(void);
+gid_t __syscall_getegid32(void);
+int __syscall_setreuid32(uid_t ruid, uid_t euid);
+int __syscall_setregid32(gid_t rgid, gid_t egid);
+int __syscall_getgroups32(int count, gid_t list[]);
+int __syscall_fchown32(int fd, uid_t owner, gid_t group);
+int __syscall_setresuid32(uid_t ruid, uid_t euid, uid_t suid);
+int __syscall_getresuid32(uid_t *ruid, uid_t *euid, uid_t *suid);
+int __syscall_setresgid32(gid_t rgid, gid_t egid, gid_t sgid);
+int __syscall_getresgid32(gid_t *rgid, gid_t *egid, gid_t *sgid);
+int __syscall_setuid32(uid_t uid);
+int __syscall_setgid32(gid_t gid);
+int __syscall_mincore(void *addr, size_t length, unsigned char *vec);
+int __syscall_madvise(void *addr, size_t length, int advice);
+int __syscall_getdents64(int fd, void *dirp, size_t count);
+int __syscall_fcntl64(int fd, int cmd, ...);
+int __syscall_statfs64(const char *path, size_t size, struct statfs *buf);
+int __syscall_fstatfs64(int fd, size_t size, struct statfs *buf);
+int __syscall_fadvise64(int fd, off_t offset, off_t len, int advice);
+int __syscall_openat(int dirfd, const char *path, int flags, ...); // mode is optional
+int __syscall_mkdirat(int dirfd, const char *path, mode_t mode);
+int __syscall_mknodat(int dirfd, const char *path, mode_t mode, dev_t dev);
+int __syscall_fchownat(int dirfd, const char *path, uid_t owner, gid_t group, int flags);
+int __syscall_newfstatat(int dirfd, const char *path, struct stat *buf, int flags);
+int __syscall_unlinkat(int dirfd, const char *path, int flags);
+int __syscall_renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath);
+int __syscall_linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags);
+int __syscall_symlinkat(const char *target, int newdirfd, const char *linkpath);
+int __syscall_readlinkat(int dirfd, const char *path, char *buf, size_t bufsize);
+int __syscall_fchmodat2(int dirfd, const char *path, mode_t mode, int flags);
+int __syscall_faccessat(int dirfd, const char *path, int amode, int flags);
+int __syscall_utimensat(int dirfd, const char *path, const struct timespec times[2], int flags);
+int __syscall_fallocate(int fd, int mode, off_t offset, off_t len);
+int __syscall_dup3(int oldfd, int newfd, int flags);
+int __syscall_pipe2(int fd[2], int flags);
+int __syscall_prlimit64(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit);
+int __syscall_socket(int domain, int type, int protocol, int unused1, int unused2, int unused3);
+int __syscall_socketpair(int domain, int type, int protocol, int fd[2], int unused1, int unused2);
+int __syscall_bind(int sockfd, const struct sockaddr *addr, socklen_t len, int unused1, int unused2, int unused3);
+int __syscall_connect(int sockfd, const struct sockaddr *addr, socklen_t len, int unused1, int unused2, int unused3);
+int __syscall_listen(int sockfd, int backlog, int unused1, int unused2, int unused3, int unused4);
+int __syscall_accept4(int sockfd, struct sockaddr *addr, socklen_t *len, int flags, int unused1, int unused2);
+int __syscall_getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen, int unused);
+int __syscall_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen, int unused);
+int __syscall_getsockname(int sockfd, struct sockaddr *addr, socklen_t *len, int unused1, int unused2, int unused3);
+int __syscall_getpeername(int sockfd, struct sockaddr *addr, socklen_t *len, int unused1, int unused2, int unused3);
+int __syscall_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen);
+int __syscall_sendmsg(int sockfd, const struct msghdr *msg, int flags, int unused1, int unused2, int unused3);
+int __syscall_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen);
+int __syscall_recvmsg(int sockfd, struct msghdr *msg, int flags, int unused1, int unused2, int unused3);
+int __syscall_shutdown(int sockfd, int how, int unused1, int unused2, int unused3, int unused4);
+int __syscall_epoll_create1(int flags);
+int __syscall_epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
+int __syscall_epoll_pwait(int epfd, struct epoll_event *ev, int maxevents, int timeout, const sigset_t *sigmask, size_t sigsetsize);
+int __syscall_epoll_pwait_nonblocking(int epfd, struct epoll_event *ev, int maxevents);
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/threading.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2015 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.
+ */
+
+#pragma once
+
+#include <emscripten/atomic.h>
+// Legacy proxying functions.  See proxying.h for the new proxying system.
+#include <emscripten/threading_legacy.h>
+#include <emscripten/threading_primitives.h>
+
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns true if the current runtime is able to spawn threads with shared
+// memory.  If this function returns false then it will not be possible to
+// create new pthreads or Wasm Workers.
+bool emscripten_has_threading_support(void);
+
+// Returns the number of logical cores on the system.
+int emscripten_num_logical_cores(void);
+
+// Returns true if the current thread is the thread that hosts the Emscripten
+// runtime.
+// Returns false on pthreads and Wasm Workers.
+bool emscripten_is_main_runtime_thread(void);
+
+// Returns true if the current thread is the main browser thread.  In the case
+// that the Emscripten module is started in a worker there will be no thread
+// for which this returns true.
+// Returns false on pthreads and Wasm Workers.
+bool emscripten_is_main_browser_thread(void);
+
+// A temporary workaround to issue
+// https://github.com/emscripten-core/emscripten/issues/3495:
+// Call this in the body of all lock-free atomic (cas) loops that the main
+// thread might enter which don't otherwise call to any pthread api calls
+// (mutexes) or C runtime functions that are considered cancellation points.
+void emscripten_main_thread_process_queued_calls(void);
+
+void emscripten_current_thread_process_queued_calls(void);
+
+// Returns the thread ID of the thread that hosts the Emscripten runtime.
+pthread_t emscripten_main_runtime_thread_id(void);
+
+// Synchronously sleeps the calling thread for the given number of milliseconds.
+// Note: Calling this on the main browser thread is _very_ _very_ bad for
+// application logic throttling, because it does not save any battery, it will
+// spin up the CPU at 100%, lock up the UI, printfs will not come through on web
+// page or the console, and eventually it will show up the slow script dialog.
+// Calling this function in a pthread (Web Worker) is fine, and a good way to go
+// if you need to synchronously sleep for a specific amount of time while saving
+// power.
+// Note 2: This function will process the pthread-specific event queue for the
+//         calling thread while sleeping, and this function also acts as a
+//         cancellation point.
+// Note 3: This function is enabled when targeting pthreads (SharedArrayBuffer),
+//         not to be confused with
+//         similarly named function emscripten_sleep(), which is intended for
+//         Asyncify builds.
+void emscripten_thread_sleep(double msecs);
+
+// Sets the name of the given thread. Pass pthread_self() as the thread ID to
+// set the name of the calling thread.
+// The name parameter is a UTF-8 encoded string which is truncated to 32 bytes.
+// When thread profiler is not enabled (not building with --threadprofiler),
+// this is a no-op.
+void emscripten_set_thread_name(pthread_t threadId, const char * _Nonnull name);
+
+// Gets the stored pointer to a string representing the canvases to transfer to
+// the created thread.
+int emscripten_pthread_attr_gettransferredcanvases(const pthread_attr_t * _Nonnull a, const char ** _Nonnull str);
+
+// Specifies a comma-delimited list of canvas DOM element IDs to transfer to the
+// thread to be created.
+// Note: this pointer is weakly stored (not copied) to the given pthread_attr_t,
+// so must be held alive until pthread_create() has been called. If 0 or "", no
+// canvases are transferred.
+// The special value "#canvas" denotes the element stored in Module.canvas.
+int emscripten_pthread_attr_settransferredcanvases(pthread_attr_t * _Nonnull a, const char * _Nonnull str);
+
+// Called when blocking on the main thread. This will error if main thread
+// blocking is not enabled, see ALLOW_BLOCKING_ON_MAIN_THREAD.
+void emscripten_check_blocking_allowed(void);
+
+#ifdef __cplusplus
+}
+#endif