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

package/dist/emscripten/include/emscripten/em_macros.h

@@ -0,0 +1,53 @@
+/*
+ * 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
+
+#define EMSCRIPTEN_KEEPALIVE __attribute__((used))
+
+#ifdef __wasm__
+#define EM_IMPORT(NAME) __attribute__((import_module("env"), import_name(#NAME)))
+#else
+#define EM_IMPORT(NAME)
+#endif
+
+#ifdef __cplusplus
+#define _EM_BEGIN_CDECL extern "C" {
+#define _EM_END_CDECL   }
+#else // __cplusplus
+#define _EM_BEGIN_CDECL
+#define _EM_END_CDECL
+#endif // __cplusplus
+
+/*
+ * EM_JS_DEPS: Use this macro to declare indirect dependencies on JS symbols.
+ * The first argument is just a unique name for the set of dependencies.  The
+ * second argument is a C string that lists JS library symbols in the same way
+ * they would be specified in the DEFAULT_LIBRARY_FUNCS_TO_INCLUDE command line
+ * setting.
+ *
+ * For example, if your code contains an EM_ASM or EM_JS block that make use of
+ * the stringToNewUTF8 and stackSave JS library functions then you might write this in
+ * your library source code:
+ *
+ *   EM_JS_DEPS(mylib_dep, "$stringToNewUTF8,$stackSave");
+ *
+ * The emscripten linker will then pick this up and make sure those symbols get
+ * included in the JS support library.
+ *
+ * Dependencies declared in this way will be included if-and-only-if the object
+ * file (translation unit) in which they exist is included by the linker, so
+ * it makes sense co-locate them with the EM_JS or EM_ASM code they correspond
+ * to.
+ */
+#define EM_JS_DEPS(tag, deps)             \
+  _EM_BEGIN_CDECL                         \
+  EMSCRIPTEN_KEEPALIVE                    \
+  __attribute__((section("em_lib_deps"))) \
+  __attribute__((aligned(1)))             \
+  char __em_lib_deps_##tag[] = deps;      \
+  _EM_END_CDECL

package/dist/emscripten/include/emscripten/em_math.h

@@ -0,0 +1,82 @@
+/*
+ * 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
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * This file contains C functions to access the JavaScript Math API via Emscripten.
+ * Please note that accessing these functions is relatively slow, since they each
+ * incur a language boundary crossing call from WebAssembly out to JavaScript.
+
+ * These functions are best used in scenarios where small code size is more desirable
+ * than performance.
+
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math
+ * for details. */
+
+// The following operations have very fast WebAssembly opcodes. Therefore they are not
+// exposed as individual functions:
+
+// Math.abs(x) -> f32.abs and f64.abs. (use fabsf() and fabs() from math.h)
+// Math.ceil -> f32.ceil and f64.ceil (ceil() and ceilf() in math.h)
+// Math.clz32(x) -> i32.clz and i64.clz (call __builtin_clz() and __builtin_clzll())
+// Math.floor -> f32.floor and f64.floor (floor() and floorf() in math.h)
+// Math.fround -> f64.promote_f32(f32.demote_f64()) (double d = (double)(float)someDouble;)
+// Math.imul(x, y) -> i32.mul and i64.mul (directly multiply two signed integers)
+// Math.min -> f32.min and f64.min (fminf() and fmin() in math.h)
+// Math.max -> f32.max and f64.max (fmaxf() and fmax() in math.h)
+// Math.trunc -> f32.trunc and f64.trunc (truncf() and trunc() in math.h)
+
+// The following constants are available on the JS Math object, mirrored here for convenience.
+
+#define EM_MATH_E 2.718281828459045
+#define EM_MATH_LN2 0.6931471805599453
+#define EM_MATH_LN10 2.302585092994046
+#define EM_MATH_LOG2E 1.4426950408889634
+#define EM_MATH_LOG10E 0.4342944819032518
+#define EM_MATH_PI 3.141592653589793
+#define EM_MATH_SQRT1_2 0.7071067811865476
+#define EM_MATH_SQRT2 1.4142135623730951
+
+// The following Math operations do not have native WebAssembly opcodes, and
+// are provided here as small sized alternatives to their libc counterparts.
+
+double emscripten_math_acos(double x); // acos() in math.h
+double emscripten_math_acosh(double x); // acosh() in math.h
+double emscripten_math_asin(double x); // asin() in math.h
+double emscripten_math_asinh(double x); // asinh() in math.h
+double emscripten_math_atan(double x); // atan() in math.h
+double emscripten_math_atan2(double y, double x); // atan2() in math.h
+double emscripten_math_atanh(double x); // atanh() in math.h
+double emscripten_math_cbrt(double x); // cbrt() in math.h
+double emscripten_math_cos(double x); // cos() in math.h
+double emscripten_math_cosh(double x); // cosh() in math.h
+double emscripten_math_exp(double x); // exp() in math.h
+double emscripten_math_expm1(double x); // expm1() in math.h
+double emscripten_math_fmod(double x, double y); // fmod() in math.h, not a function on Math, but calls JS "x % y" operator.
+double emscripten_math_hypot(int count, ...);  // hypot() in math.h (although only for fixed 2 arguments)
+double emscripten_math_log(double x); // log() in math.h
+double emscripten_math_log1p(double x); // log1p() in math.h
+double emscripten_math_log10(double x); // log10() in math.h
+double emscripten_math_log2(double x); // log2() in math.h
+double emscripten_math_pow(double x, double y); // pow(x, y) in math.h
+double emscripten_math_random(void); // N.b. emscripten_random() in emscripten.h returns a single-precision float!
+double emscripten_math_round(double x); // round() in math.h
+double emscripten_math_sign(double x); // No equivalent in libc
+double emscripten_math_sin(double x); // sin() in math.h
+double emscripten_math_sinh(double x); // sinh() in math.h
+double emscripten_math_sqrt(double x); // sqrt() in math.h
+double emscripten_math_tan(double x); // tan() in math.h
+double emscripten_math_tanh(double x); // tanh() in math.h
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/em_types.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012 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 <stdbool.h>
+
+/* Typedefs */
+
+typedef short __attribute__((aligned(1))) emscripten_align1_short;
+
+typedef long long __attribute__((aligned(4))) emscripten_align4_int64;
+typedef long long __attribute__((aligned(2))) emscripten_align2_int64;
+typedef long long __attribute__((aligned(1))) emscripten_align1_int64;
+
+typedef int __attribute__((aligned(2))) emscripten_align2_int;
+typedef int __attribute__((aligned(1))) emscripten_align1_int;
+
+typedef float __attribute__((aligned(2))) emscripten_align2_float;
+typedef float __attribute__((aligned(1))) emscripten_align1_float;
+
+typedef double __attribute__((aligned(4))) emscripten_align4_double;
+typedef double __attribute__((aligned(2))) emscripten_align2_double;
+typedef double __attribute__((aligned(1))) emscripten_align1_double;
+
+typedef void (*em_callback_func)(void);
+typedef void (*em_arg_callback_func)(void*);
+typedef void (*em_str_callback_func)(const char *);
+
+/* Legacy EM_BOOL type. Emscripten no longer uses this */
+#define EM_BOOL bool
+#define EM_TRUE true
+#define EM_FALSE false
+
+#define EM_UTF8 char
+
+#define EMSCRIPTEN_RESULT int
+
+#define EMSCRIPTEN_RESULT_SUCCESS              0
+#define EMSCRIPTEN_RESULT_DEFERRED             1
+#define EMSCRIPTEN_RESULT_NOT_SUPPORTED       -1
+#define EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED -2
+#define EMSCRIPTEN_RESULT_INVALID_TARGET      -3
+#define EMSCRIPTEN_RESULT_UNKNOWN_TARGET      -4
+#define EMSCRIPTEN_RESULT_INVALID_PARAM       -5
+#define EMSCRIPTEN_RESULT_FAILED              -6
+#define EMSCRIPTEN_RESULT_NO_DATA             -7
+#define EMSCRIPTEN_RESULT_TIMED_OUT           -8

package/dist/emscripten/include/emscripten/emmalloc.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// emmalloc: A lightweight web-friendly memory allocator suitable for very small applications.
+// Enable the usage of emmalloc by passing the linker flag -sMALLOC=emmalloc to the application.
+
+// A debug function that dumps the whole structure of malloc internal memory blocks to console.
+// *extremely slow*, use for debugging allocation test cases.
+void emmalloc_dump_memory_regions(void);
+
+// Allocates size bytes with the given pow-2 alignment. If the WebAssembly memory runs out of
+// free bytes, this function will abort execution, or if building with -sABORTING_MALLOC=0,
+// return a null pointer.
+void *memalign(size_t alignment, size_t size);
+void *emmalloc_memalign(size_t alignment, size_t size);
+void *aligned_alloc(size_t alignment, size_t size);
+
+// Allocates size bytes with default alignment (8 bytes). Like above, either aborts or returns
+// null on OOM.
+void *malloc(size_t size);
+void *emmalloc_malloc(size_t size);
+
+// Returns the number of bytes that are actually allocated to the given pointer ptr.
+// E.g. due to alignment or size requirements, the actual size of the allocation can be
+// larger than what was requested. It is ok to pass a null pointer to these functions, in which
+// case 0 will be returned.
+size_t malloc_usable_size(void *ptr);
+size_t emmalloc_usable_size(void *ptr);
+
+// Frees a memory pointer allocated with any of the memory allocation functions declared
+// in this file, e.g.
+// (emmalloc_)memalign, (emmalloc_)malloc, (emmalloc_)calloc, aligned_alloc,
+// (emmalloc_)realloc, emmalloc_realloc_try, emmalloc_realloc_uninitialized, (emmalloc_)aligned_realloc
+// It is ok to pass null in ptr, which will be a no-op.
+void free(void *ptr);
+void emmalloc_free(void *ptr);
+
+// Performs a reallocation of the given memory pointer to a new size. If the memory region
+// pointed by ptr cannot be resized in place, a new memory region will be allocated, old
+// memory copied over, and the old memory area freed. The pointer ptr must have been
+// allocated with one of the emmalloc memory allocation functions (malloc, memalign, ...).
+// If called with size == 0, the pointer ptr is freed, and a null pointer is returned.
+// If called with null ptr, a new pointer is allocated.
+// If there is not enough memory, the old memory block is not freed and null pointer is
+// returned.
+void *realloc(void *ptr, size_t size);
+void *emmalloc_realloc(void *ptr, size_t size);
+
+// emmalloc_realloc_try() is like realloc(), but only attempts to try to resize the existing
+// memory area. If resizing the existing memory area fails, then realloc_try() will return 0
+// (the original memory block is not freed or modified). If resizing succeeds, previous
+// memory contents will be valid up to min(old length, new length) bytes.
+// If a null pointer is passed, no allocation is attempted but the function will return 0.
+// If zero size is passed, the function will behave like free().
+void *emmalloc_realloc_try(void *ptr, size_t size);
+
+// emmalloc_realloc_uninitialized() is like realloc(), but old memory contents
+// will be undefined after reallocation. (old memory is not preserved in any case)
+void *emmalloc_realloc_uninitialized(void *ptr, size_t size);
+
+// Like realloc(), but allows specifying the alignment to allocate to. This function cannot
+// be used to change the alignment of an existing allocation, but the original pointer should
+// be aligned to the given alignment already.
+void *aligned_realloc(void *ptr, size_t alignment, size_t size);
+void *emmalloc_aligned_realloc(void *ptr, size_t alignment, size_t size);
+
+// emmalloc_aligned_realloc_uninitialized() is like aligned_realloc(), but old memory contents
+// will be undefined after reallocation. (old memory is not preserved in any case)
+void *emmalloc_aligned_realloc_uninitialized(void *ptr, size_t alignment, size_t size);
+
+// posix_memalign allocates memory with a given alignment, like memalign, but with a slightly
+// different usage signature.
+int posix_memalign(void **memptr, size_t alignment, size_t size);
+int emmalloc_posix_memalign(void **memptr, size_t alignment, size_t size);
+
+// calloc allocates memory that is initialized to zero.
+void *calloc(size_t num, size_t size);
+void *emmalloc_calloc(size_t num, size_t size);
+
+// mallinfo() returns information about current emmalloc allocation state. This function
+// is very slow, only good for debugging. Avoid calling it for "routine" diagnostics.
+struct mallinfo mallinfo(void);
+struct mallinfo emmalloc_mallinfo(void);
+
+// malloc_trim() returns unused dynamic memory back to the WebAssembly heap. Returns 1 if it
+// actually freed any memory, and 0 if not. Note: this function does not release memory back to
+// the system, but it only marks memory held by emmalloc back to unused state for other users
+// of sbrk() to claim.
+int malloc_trim(size_t pad);
+int emmalloc_trim(size_t pad);
+
+// Validates the consistency of the malloc heap. Returns non-zero and prints an error to console
+// if memory map is corrupt. Returns 0 (and does not print anything) if memory is intact.
+int emmalloc_validate_memory_regions(void);
+
+// Computes the size of the dynamic memory region governed by emmalloc. This represents the
+// amount of memory that emmalloc has sbrk()ed in for itself to manage. Use this function
+// for memory statistics tracking purposes. Calling this function is quite fast, practically
+// O(1) time.
+size_t emmalloc_dynamic_heap_size(void);
+
+// Computes the amount of memory currently reserved under emmalloc's governance  that is free
+// for the application to allocate. Use this function for memory statistics tracking purposes.
+// Note that calling this function is very slow, as it walks through each free memory block in
+// linear time.
+size_t emmalloc_free_dynamic_memory(void);
+
+// Estimates the amount of untapped memory that emmalloc could expand its dynamic memory area
+// via sbrk()ing. Theoretically the maximum amount of memory that can still be malloc()ed can
+// be calculated via emmalloc_free_dynamic_memory() + emmalloc_unclaimed_heap_memory().
+// Calling this function is very fast constant time lookup.
+size_t emmalloc_unclaimed_heap_memory(void);
+
+// Computes a detailed fragmentation map of available free memory. Pass in a pointer to a
+// 32 element long array. This function populates into each array index i the number of free
+// memory regions that have a size 2^i <= size < 2^(i+1), and returns the total number of
+// free memory regions (the sum of the array entries). This function runs very slowly, as it
+// iterates through all free memory blocks.
+size_t emmalloc_compute_free_dynamic_memory_fragmentation_map(size_t freeMemorySizeMap[32]);
+
+// Same as above, but instead of returning the information in an array, prints it directly
+// to stdout.
+void emmalloc_dump_free_dynamic_memory_fragmentation_map(void);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2012 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
+
+/**
+ * This file contains a few useful things for compiling C/C++ code
+ * with Emscripten.
+ *
+ * Documentation for the public APIs defined in this file must be updated in: 
+ *    site/source/docs/api_reference/emscripten.h.rst
+ * A prebuilt local version of the documentation is available at: 
+ *    site/build/text/docs/api_reference/emscripten.h.txt
+ * You can also build docs locally as HTML or other formats in site/
+ * An online HTML version (which may be of a different version of Emscripten)
+ *    is up at http://kripken.github.io/emscripten-site/docs/api_reference/emscripten.h.html
+ */
+
+#include "em_asm.h"
+#include "em_js.h"
+#include "em_macros.h"
+#include "em_types.h"
+#include "promise.h"
+#include "version.h"
+#include "wget.h"
+
+#ifdef __EMSCRIPTEN__
+#ifndef EMSCRIPTEN
+#define EMSCRIPTEN
+#endif
+#pragma clang deprecated(EMSCRIPTEN, "use __EMSCRIPTEN__ instead")
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void emscripten_run_script(const char * _Nonnull script);
+int emscripten_run_script_int(const char * _Nonnull script);
+char *emscripten_run_script_string(const char * _Nonnull script);
+void emscripten_async_run_script(const char * _Nonnull script, int millis);
+void emscripten_async_load_script(const char * _Nonnull script, em_callback_func onload, em_callback_func onerror);
+
+void emscripten_set_main_loop(em_callback_func func, int fps, bool simulate_infinite_loop);
+
+#define EM_TIMING_SETTIMEOUT 0
+#define EM_TIMING_RAF 1
+#define EM_TIMING_SETIMMEDIATE 2
+
+int emscripten_set_main_loop_timing(int mode, int value);
+void emscripten_get_main_loop_timing(int *mode, int *value); // Pass a null pointer to skip receiving that particular value
+void emscripten_set_main_loop_arg(em_arg_callback_func func, void *arg, int fps, bool simulate_infinite_loop);
+void emscripten_pause_main_loop(void);
+void emscripten_resume_main_loop(void);
+void emscripten_cancel_main_loop(void);
+
+typedef void (*em_socket_callback)(int fd, void *userData);
+typedef void (*em_socket_error_callback)(int fd, int err, const char* msg, void *userData);
+
+void emscripten_set_socket_error_callback(void *userData, em_socket_error_callback callback);
+void emscripten_set_socket_open_callback(void *userData, em_socket_callback callback);
+void emscripten_set_socket_listen_callback(void *userData, em_socket_callback callback);
+void emscripten_set_socket_connection_callback(void *userData, em_socket_callback callback);
+void emscripten_set_socket_message_callback(void *userData, em_socket_callback callback);
+void emscripten_set_socket_close_callback(void *userData, em_socket_callback callback);
+
+void _emscripten_push_main_loop_blocker(em_arg_callback_func func, void *arg, const char *name);
+void _emscripten_push_uncounted_main_loop_blocker(em_arg_callback_func func, void *arg, const char *name);
+#define emscripten_push_main_loop_blocker(func, arg) \
+  _emscripten_push_main_loop_blocker(func, arg, #func)
+#define emscripten_push_uncounted_main_loop_blocker(func, arg) \
+  _emscripten_push_uncounted_main_loop_blocker(func, arg, #func)
+
+void emscripten_set_main_loop_expected_blockers(int num);
+
+void emscripten_async_call(em_arg_callback_func func, void *arg, int millis);
+
+void emscripten_exit_with_live_runtime(void) __attribute__((__noreturn__));
+void emscripten_force_exit(int status) __attribute__((__noreturn__));
+
+double emscripten_get_device_pixel_ratio(void);
+
+char *emscripten_get_window_title(void);
+void emscripten_set_window_title(const char *);
+void emscripten_get_screen_size(int * _Nonnull width, int * _Nonnull height);
+void emscripten_hide_mouse(void);
+void emscripten_set_canvas_size(int width, int height) __attribute__((deprecated("This variant does not allow specifying the target canvas", "Use emscripten_set_canvas_element_size() instead")));
+void emscripten_get_canvas_size(int * _Nonnull width, int * _Nonnull height, int * _Nonnull isFullscreen) __attribute__((deprecated("This variant does not allow specifying the target canvas", "Use emscripten_get_canvas_element_size() and emscripten_get_fullscreen_status() instead")));
+
+double emscripten_get_now(void);
+float emscripten_random(void);
+
+// IDB
+
+typedef void (*em_idb_onload_func)(void*, void*, int);
+void emscripten_idb_async_load(const char * _Nonnull db_name, const char * _Nonnull file_id, void* arg, em_idb_onload_func onload, em_arg_callback_func onerror);
+void emscripten_idb_async_store(const char * _Nonnull db_name, const char * _Nonnull file_id, void* ptr, int num, void* arg, em_arg_callback_func onstore, em_arg_callback_func onerror);
+void emscripten_idb_async_delete(const char * _Nonnull db_name, const char * _Nonnull file_id, void* arg, em_arg_callback_func ondelete, em_arg_callback_func onerror);
+typedef void (*em_idb_exists_func)(void*, int);
+void emscripten_idb_async_exists(const char * _Nonnull db_name, const char * _Nonnull file_id, void* arg, em_idb_exists_func oncheck, em_arg_callback_func onerror);
+void emscripten_idb_async_clear(const char * _Nonnull db_name, void* arg, em_arg_callback_func onclear, em_arg_callback_func onerror);
+
+// IDB "sync"
+
+void emscripten_idb_load(const char *db_name, const char *file_id, void** pbuffer, int* pnum, int *perror);
+void emscripten_idb_store(const char *db_name, const char *file_id, void* buffer, int num, int *perror);
+void emscripten_idb_delete(const char *db_name, const char *file_id, int *perror);
+void emscripten_idb_exists(const char *db_name, const char *file_id, int* pexists, int *perror);
+void emscripten_idb_clear(const char *db_name, int *perror);
+
+// other async utilities
+
+int emscripten_run_preload_plugins(const char* file, em_str_callback_func onload, em_str_callback_func onerror);
+
+typedef void (*em_run_preload_plugins_data_onload_func)(void*, const char*);
+void emscripten_run_preload_plugins_data(char* data, int size, const char *suffix, void *arg, em_run_preload_plugins_data_onload_func onload, em_arg_callback_func onerror);
+
+// show an error on some renamed methods
+#define emscripten_async_prepare(...) _Pragma("GCC error(\"emscripten_async_prepare has been replaced by emscripten_run_preload_plugins\")")
+#define emscripten_async_prepare_data(...) _Pragma("GCC error(\"emscripten_async_prepare_data has been replaced by emscripten_run_preload_plugins_data\")")
+
+// worker APIs
+
+typedef int worker_handle;
+
+worker_handle emscripten_create_worker(const char *url);
+void emscripten_destroy_worker(worker_handle worker);
+
+typedef void (*em_worker_callback_func)(char*, int, void*);
+void emscripten_call_worker(worker_handle worker, const char *funcname, char *data, int size, em_worker_callback_func callback, void *arg);
+void emscripten_worker_respond(char *data, int size);
+void emscripten_worker_respond_provisionally(char *data, int size);
+
+int emscripten_get_worker_queue_size(worker_handle worker);
+
+// misc.
+
+long emscripten_get_compiler_setting(const char *name);
+
+// Returns the value of -sASYNCIFY.  Can be 0, 1, or 2 (in the case of JSPI).
+int emscripten_has_asyncify(void);
+
+void emscripten_debugger(void);
+
+// Forward declare FILE from musl libc headers to avoid needing to #include <stdio.h> from emscripten.h
+struct _IO_FILE;
+typedef struct _IO_FILE FILE;
+
+char *emscripten_get_preloaded_image_data(const char *path, int *w, int *h);
+char *emscripten_get_preloaded_image_data_from_FILE(FILE *file, int *w, int *h);
+
+#define EM_LOG_CONSOLE   1
+#define EM_LOG_WARN      2
+#define EM_LOG_ERROR     4
+#define EM_LOG_C_STACK   8
+#define EM_LOG_JS_STACK 16
+#define EM_LOG_DEMANGLE 32  // deprecated
+#pragma clang deprecated(EM_LOG_DEMANGLE)
+#define EM_LOG_NO_PATHS 64
+#define EM_LOG_FUNC_PARAMS 128  // deprecated
+#pragma clang deprecated(EM_LOG_FUNC_PARAMS)
+#define EM_LOG_DEBUG    256
+#define EM_LOG_INFO     512
+
+void emscripten_log(int flags, const char* format, ...);
+
+int emscripten_get_callstack(int flags, char *out, int maxbytes);
+
+int emscripten_print_double(double x, char *to, signed max);
+
+typedef void (*em_scan_func)(void*, void*);
+void emscripten_scan_registers(em_scan_func func);
+void emscripten_scan_stack(em_scan_func func);
+
+// Asynchronous version of dlopen.  Since WebAssembly module loading in general
+// is asynchronous the normal dlopen function can't be used in all situations.
+typedef void (*em_dlopen_callback)(void* user_data, void* handle);
+void emscripten_dlopen(const char *filename, int flags, void* user_data, em_dlopen_callback onsuccess, em_arg_callback_func onerror);
+
+// Promisified version of emscripten_dlopen
+// The returned promise will resolve once the dso has been loaded.  It's up to
+// the caller to call emscripten_promise_destroy on this promise.
+em_promise_t emscripten_dlopen_promise(const char *filename, int flags);
+
+void emscripten_throw_number(double number);
+void emscripten_throw_string(const char *utf8String);
+
+/* ===================================== */
+/* Internal APIs. Be careful with these. */
+/* ===================================== */
+
+void emscripten_sleep(unsigned int ms);
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/epoll.h

@@ -0,0 +1,78 @@
+/*
+ * 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 <sys/epoll.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// EXPERIMENTAL. This API is new and may change (signature or semantics) over the
+// next few releases.
+//
+// Register a persistent readiness listener on an existing epoll fd (built with
+// epoll_create1/epoll_ctl): instead of blocking in epoll_wait, the runtime
+// invokes `callback` on the event loop whenever the epoll set has ready events
+// waiting to be collected. The callback receives `epfd` and `userdata`; it does
+// not receive the events. To collect them it calls epoll_wait(epfd, ..., 0) itself
+// - a non-blocking, zero-timeout wait - from within the callback.
+// Unlike epoll_wait it never blocks the calling stack, so it works without
+// ASYNCIFY/JSPI.
+//
+// Listeners are supported only on the main thread. For pthreads, epoll_wait()
+// should be used directly instead - registering a listener from a pthread fails
+// with ENOTSUP.
+//
+// Any number of listeners may be added to a descriptor, identified by the
+// (callback, userdata) pair; adding a pair already registered on that descriptor
+// fails with EEXIST. Every listener is signalled while uncollected ready events
+// remain (broadcast), and listeners race to collect: per-fd trigger modes
+// distribute events across collectors exactly as between multiple blocking
+// epoll_wait callers on one epoll, so an EPOLLET edge or an EPOLLONESHOT firing
+// is collected by exactly one listener (load balancing), while a level fd keeps
+// signalling every listener until drained.
+//
+// A listener fires on a later event-loop turn, never from within a running wasm
+// call, while the set has ready events that have not yet been collected, and
+// keeps firing while any remain: it only signals that events are pending, so a
+// callback that does not drain them (via epoll_wait) leaves them pending and
+// re-fires. Whether a given fd is re-reported follows its per-fd trigger mode
+// (set via epoll_ctl) exactly as epoll_wait does. Note that for a level-triggered
+// fd the runtime, not the application, drives the loop, so an fd that is
+// structurally always ready (notably EPOLLOUT on a writable socket) will spin
+// the event loop; use EPOLLET or EPOLLONESHOT for such fds.
+//
+// A listener is an unref'd handle (like Node's handle.unref()): while the
+// runtime is alive, readiness is delivered to it, but it never keeps the
+// runtime alive, even with a delivery pending. Pending callbacks are dropped
+// when the runtime exits. A program whose only reason to stay alive is a
+// listener holds the runtime itself:
+//
+//   emscripten_runtime_keepalive_push();  // e.g. before main() returns
+//   ...
+//   emscripten_runtime_keepalive_pop();   // e.g. from the callback, when done
+//
+// Likewise emscripten_epoll_listener_remove and closing the epoll fd release
+// nothing, since nothing was held.
+//
+// Listeners belong to the registering descriptor: dup does not copy them, and
+// closing that descriptor removes them and cancels pending deliveries. Epoll
+// interests and the ready list remain shared across dup'd descriptors, so a
+// listener sees readiness from interests added through any of them. Returns
+// 0, or a positive errno (EBADF if `epfd` is not an epoll fd).
+typedef void (*em_epoll_callback)(int epfd, void *userdata);
+int emscripten_epoll_listener_add(int epfd, em_epoll_callback callback, void *userdata);
+
+// Remove the listener for the (callback, userdata) pair on `epfd`. Returns 0,
+// EBADF if `epfd` is not an epoll fd, or ENOENT if no such listener is registered.
+int emscripten_epoll_listener_remove(int epfd, em_epoll_callback callback, void *userdata);
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/eventloop.h

@@ -0,0 +1,35 @@
+/*
+ * 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 "em_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void emscripten_unwind_to_js_event_loop(void) __attribute__((__noreturn__));
+
+int emscripten_set_timeout(void (* _Nonnull cb)(void *user_data), double msecs, void *user_data);
+void emscripten_clear_timeout(int id);
+void emscripten_set_timeout_loop(bool (* _Nonnull cb)(double time, void *user_data), double interval_ms, void *user_data);
+
+int emscripten_set_immediate(void (* _Nonnull cb)(void *user_data), void *user_data);
+void emscripten_clear_immediate(int id);
+void emscripten_set_immediate_loop(bool (*cb)(void *user_data), void *user_data);
+
+int emscripten_set_interval(void (* _Nonnull cb)(void *user_data), double interval_ms, void *user_data);
+void emscripten_clear_interval(int id);
+
+void emscripten_runtime_keepalive_push(void);
+void emscripten_runtime_keepalive_pop(void);
+bool emscripten_runtime_keepalive_check(void);
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/exports.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012 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
+
+// API that gives access to the function exports of a Wasm module. Build with
+// -lexports.js to use this API.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns a function pointer to the given exported function by name. Cast the returned pointer
+// to its proper signature before calling the function.
+void *emscripten_get_exported_function(const char * _Nonnull fname);
+
+#ifdef __cplusplus
+}
+#endif