visaljs 0.0.4 → 0.0.6

package/node/third_party/zstd/zstd_errors.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_ERRORS_H_398273423
+#define ZSTD_ERRORS_H_398273423
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
+#ifndef ZSTDERRORLIB_VISIBLE
+   /* Backwards compatibility with old macro name */
+#  ifdef ZSTDERRORLIB_VISIBILITY
+#    define ZSTDERRORLIB_VISIBLE ZSTDERRORLIB_VISIBILITY
+#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_VISIBLE __attribute__ ((visibility ("default")))
+#  else
+#    define ZSTDERRORLIB_VISIBLE
+#  endif
+#endif
+
+#ifndef ZSTDERRORLIB_HIDDEN
+#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_HIDDEN __attribute__ ((visibility ("hidden")))
+#  else
+#    define ZSTDERRORLIB_HIDDEN
+#  endif
+#endif
+
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBLE
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBLE
+#endif
+
+/*-*********************************************
+ *  Error codes list
+ *-*********************************************
+ *  Error codes _values_ are pinned down since v1.3.1 only.
+ *  Therefore, don't rely on values if you may link to any version < v1.3.1.
+ *
+ *  Only values < 100 are considered stable.
+ *
+ *  note 1 : this API shall be used with static linking only.
+ *           dynamic linking is not yet officially supported.
+ *  note 2 : Prefer relying on the enum than on its value whenever possible
+ *           This is the only supported way to use the error list < v1.3.1
+ *  note 3 : ZSTD_isError() is always correct, whatever the library version.
+ **********************************************/
+typedef enum {
+  ZSTD_error_no_error = 0,
+  ZSTD_error_GENERIC  = 1,
+  ZSTD_error_prefix_unknown                = 10,
+  ZSTD_error_version_unsupported           = 12,
+  ZSTD_error_frameParameter_unsupported    = 14,
+  ZSTD_error_frameParameter_windowTooLarge = 16,
+  ZSTD_error_corruption_detected = 20,
+  ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_literals_headerWrong = 24,
+  ZSTD_error_dictionary_corrupted      = 30,
+  ZSTD_error_dictionary_wrong          = 32,
+  ZSTD_error_dictionaryCreation_failed = 34,
+  ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_combination_unsupported = 41,
+  ZSTD_error_parameter_outOfBound    = 42,
+  ZSTD_error_tableLog_tooLarge       = 44,
+  ZSTD_error_maxSymbolValue_tooLarge = 46,
+  ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_cannotProduce_uncompressedBlock = 49,
+  ZSTD_error_stabilityCondition_notRespected = 50,
+  ZSTD_error_stage_wrong       = 60,
+  ZSTD_error_init_missing      = 62,
+  ZSTD_error_memory_allocation = 64,
+  ZSTD_error_workSpace_tooSmall= 66,
+  ZSTD_error_dstSize_tooSmall = 70,
+  ZSTD_error_srcSize_wrong    = 72,
+  ZSTD_error_dstBuffer_null   = 74,
+  ZSTD_error_noForwardProgress_destFull = 80,
+  ZSTD_error_noForwardProgress_inputEmpty = 82,
+  /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
+  ZSTD_error_frameIndex_tooLarge = 100,
+  ZSTD_error_seekableIO          = 102,
+  ZSTD_error_dstBuffer_wrong     = 104,
+  ZSTD_error_srcBuffer_wrong     = 105,
+  ZSTD_error_sequenceProducer_failed = 106,
+  ZSTD_error_externalSequences_invalid = 107,
+  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
+} ZSTD_ErrorCode;
+
+ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_ERRORS_H_398273423 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "visaljs",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Ahead-of-time JavaScript to C compiler: the command line",
   "license": "MIT",
   "repository": {

package/runtime/include/js_console.h

@@ -51,9 +51,12 @@ JSValue js_new_console(JSContext *ctx);
 JSValue js_print(JSContext *ctx, JSValue callee, JSValue this_val,
                  uint32_t argc, const JSValue *argv, JSValue new_target);
 
-/* Prints the pending exception to stderr and clears it. Returns the process
- * exit status for an uncaught error (1). */
+/* An uncaught error, the pending exception (cleared): the host's handler's (rt->on_uncaught),
+ * else printed to stderr. 0 when handled (the program goes on), else the exit status: 1, or the
+ * handler's. js_report_rejection is the same for the reason of a promise rejected and
+ * unhandled, printed "Uncaught (in promise) …". */
 int js_report_uncaught(JSContext *ctx);
+int js_report_rejection(JSContext *ctx, JSValue promise, JSValue reason);
 /* Prints `prefix` and the value as an uncaught error to stderr (e.g. "Uncaught (in promise) "). */
 void js_report_error(JSContext *ctx, const char *prefix, JSValue e);
 

package/runtime/include/js_host.h

@@ -7,10 +7,12 @@
 
 #include "js_function.h"
 
-/* process.c: console, process and global, installed before the program runs (main);
- * the exit status (process.exitCode) unless the program failed; a process warning on stderr */
+/* process.c: console, process and global, installed before the program runs (main); the end
+ * of the program, after the event loop ended with `status` (0, or 1 after an uncaught error):
+ * process's 'beforeExit' (on success; it may run the loop again) and 'exit', and the exit status
+ * (process.exitCode); a process warning on stderr */
 int js_host_init(JSContext *ctx, int argc, char **argv);
-int js_host_exit_code(void);
+int js_host_exit(JSContext *ctx, int status);
 void js_emit_warning(JSContext *ctx, JSValue message, const char *type, const char *code);
 
 /* cwd(): the working directory (process.cwd()), also a host primitive of node:path; -errno on failure. */

package/runtime/include/js_jobs.h

@@ -23,8 +23,9 @@ enum {
 /* Every queued job's values are precise GC roots. */
 typedef struct JSJob {
     uint8_t    kind;
-    JSContext *realm;  /* set by js_enqueue_microtask: the realm that queued it */
+    JSContext *realm;    /* set by js_enqueue_microtask: the realm that queued it */
     JSValue    a, b, c;
+    JSValue    context;  /* set by js_enqueue_microtask: the async context it runs under (ADR 0020) */
 } JSJob;
 
 typedef struct JSJobQueue {
@@ -42,6 +43,7 @@ typedef struct JSTimer {
     JSContext *realm;
     JSValue    fn;
     JSValue    args;       /* an array of the extra arguments, or undefined */
+    JSValue    context;    /* the async context it was set in, which it runs under (ADR 0020) */
 } JSTimer;
 
 typedef struct JSTimers {
@@ -76,9 +78,24 @@ void js_track_rejection(JSContext *ctx, JSValue promise, bool rejected);
 /* A one-shot timer from C: fn() after `delay` ms (clamped as setTimeout clamps it). An unref'd
  * one doesn't keep the program alive, as Node's timer.unref(). Its id (clearTimeout's). */
 uint32_t js_add_timer(JSContext *ctx, JSValue fn, double delay, bool unref);
+/* The timers node:timers builds its Timeout and Immediate objects on: fn() once, after `delay` ms
+ * or, `immediate`, at the loop's time (setImmediate's). A nonzero `id` restarts that timer, pending
+ * or not, under the same id (Timeout's refresh()); 0 gives a new one. Its id. */
+uint32_t js_timer_start(JSContext *ctx, JSValue fn, double delay, bool immediate, bool unref, uint32_t id);
+/* ref() / unref() on a pending timer: whether it keeps the program alive */
+void js_timer_set_ref(JSContext *ctx, uint32_t id, bool ref);
+void js_timer_clear(JSContext *ctx, uint32_t id);
+
+/* The async context (ADR 0020): the host's value for the current chain of async work, which
+ * jobs, timers and promise reactions carry to where they run (undefined: none). Setting it
+ * isn't undone by the runtime: the caller restores the one it replaced. */
+JSValue js_async_context(JSContext *ctx);
+void js_set_async_context(JSContext *ctx, JSValue context);
 
 /* Runs the program after its main script returned `main_result`: reports an uncaught
  * error, else checkpoints until nothing is pending. The process exit status. */
 int js_run_event_loop(JSContext *ctx, JSValue main_result);
+/* Whether the loop has more to do: a timer not unref'd, or I/O. */
+bool js_event_loop_alive(JSContext *ctx);
 
 #endif /* JS_JOBS_H */

package/runtime/include/js_promise.h

@@ -18,6 +18,7 @@ typedef struct JSPromise {
     uint8_t  state;             /* JS_PROMISE_* */
     uint8_t  is_handled;        /* [[PromiseIsHandled]]: rejection tracking */
     uint8_t  already_resolved;  /* settled through the runtime (no resolving functions) */
+    uint8_t  reported;          /* rejected, unhandled and handled by the host (rt->on_uncaught) */
 } JSPromise;
 
 bool js_is_promise(JSValue v);

package/runtime/include/jscontext.h

@@ -183,7 +183,21 @@ struct JSRuntime {
     uintptr_t stack_limit;  /* lowest usable stack address, margin included */
     JSJobQueue jobs;        /* microtasks (ADR 0008) */
     JSTimers  timers;       /* setTimeout / setInterval (ADR 0008) */
+    /* The async context (ADR 0020): an opaque value the host keeps per chain of async work
+     * (node:async_hooks' AsyncLocalStorage keeps its stores in it). Every job, timer and promise
+     * reaction takes the one current when it was queued, and runs under it. Undefined: none. A root. */
+    JSValue   async_context;
     struct JSRejections { JSValue *items; size_t count, cap; } rejections;  /* rejected, unhandled promises (roots) */
+    struct JSRejections handled_late;  /* reported ones given a handler since: for on_handled_late (roots) */
+    /* Set by the host (process's 'uncaughtException', 'unhandledRejection'): an uncaught error,
+     * or the reason of a promise rejected and unhandled (`promise` undefined for an error).
+     * 0 handled, -1 not (it is reported), else the exit status after the host reported its
+     * handler's own error (7 for 'uncaughtException''s, as in Node). on_handled_late: a
+     * promise it handled got a handler ('rejectionHandled'), at the end of a checkpoint; 0, or
+     * -1 after an exception. */
+    int     (*on_uncaught)(JSContext *ctx, JSValue error, JSValue promise);
+    int     (*on_handled_late)(JSContext *ctx, JSValue promise);
+    uint8_t   failure;  /* the exit status after an uncaught error: 1, or on_uncaught's */
     struct JSWeakList { struct JSObject **items; size_t count, cap; } weak;  /* WeakMap/Set/Ref, registries (ADR 0002) */
     struct JSKeptAlive { JSValue *items; size_t count, cap; } kept_alive;    /* [[KeptAlive]]: roots until ClearKeptObjects */
     const struct JSComponent *const *components;  /* installed in every realm (ADR 0014) */

package/runtime/src/buffer.c

@@ -1256,11 +1256,15 @@ JSValue js_new_buffer_from_bytes(JSContext *ctx, const uint8_t *p, size_t n) { r
 
 /* ---- Realm ---------------------------------------------------------------------------------- */
 
-#define FN(name, fn, length) JS_BUILTIN_FN(name, fn, length)
-
-/* Node assigns them, so they're enumerable (safer-buffer copies them with for-in) */
+/* Node assigns them, so they're enumerable: safer-buffer copies the statics with for-in, and
+ * mysql2's MockBuffer stubs out the prototype's methods with for-in */
 #define STATIC(name, fn, length) \
     { (name), NULL, JS_BUILTIN_KIND_FN, JS_BUILTIN_METHOD_ATTRS | JS_PROP_ENUMERABLE, (length), (fn), NULL, 0, NULL }
+#define FN(name, fn, length) STATIC(name, fn, length)
+#define ALIAS(name, earlier) \
+    { (name), NULL, JS_BUILTIN_KIND_ALIAS, JS_BUILTIN_METHOD_ATTRS | JS_PROP_ENUMERABLE, 0, NULL, NULL, 0, (earlier) }
+#define GETTER(name, get) \
+    { (name), NULL, JS_BUILTIN_KIND_ACCESSOR, JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE, 0, (get), NULL, 0, NULL }
 
 static const JSBuiltin buffer_statics[] = {
     JS_BUILTIN_NUMBER("poolSize", 8192, JS_PROP_DEFAULT),
@@ -1279,28 +1283,28 @@ static const JSBuiltin buffer_statics[] = {
 
 static const JSBuiltin buffer_proto[] = {
     FN("readBigUInt64LE", read_big_uint64le, 0), FN("readBigUInt64BE", read_big_uint64be, 0),
-    JS_BUILTIN_ALIAS("readBigUint64LE", "readBigUInt64LE"), JS_BUILTIN_ALIAS("readBigUint64BE", "readBigUInt64BE"),
+    ALIAS("readBigUint64LE", "readBigUInt64LE"), ALIAS("readBigUint64BE", "readBigUInt64BE"),
     FN("readBigInt64LE", read_big_int64le, 0), FN("readBigInt64BE", read_big_int64be, 0),
     FN("writeBigUInt64LE", write_big_uint64le, 0), FN("writeBigUInt64BE", write_big_uint64be, 0),
-    JS_BUILTIN_ALIAS("writeBigUint64LE", "writeBigUInt64LE"), JS_BUILTIN_ALIAS("writeBigUint64BE", "writeBigUInt64BE"),
+    ALIAS("writeBigUint64LE", "writeBigUInt64LE"), ALIAS("writeBigUint64BE", "writeBigUInt64BE"),
     FN("writeBigInt64LE", write_big_int64le, 0), FN("writeBigInt64BE", write_big_int64be, 0),
     FN("readUIntLE", read_uintle, 2), FN("readUInt32LE", read_uint32le, 0), FN("readUInt16LE", read_uint16le, 0),
     FN("readUInt8", read_uint8, 0), FN("readUIntBE", read_uintbe, 2), FN("readUInt32BE", read_uint32be, 0),
     FN("readUInt16BE", read_uint16be, 0),
-    JS_BUILTIN_ALIAS("readUintLE", "readUIntLE"), JS_BUILTIN_ALIAS("readUint32LE", "readUInt32LE"),
-    JS_BUILTIN_ALIAS("readUint16LE", "readUInt16LE"), JS_BUILTIN_ALIAS("readUint8", "readUInt8"),
-    JS_BUILTIN_ALIAS("readUintBE", "readUIntBE"), JS_BUILTIN_ALIAS("readUint32BE", "readUInt32BE"),
-    JS_BUILTIN_ALIAS("readUint16BE", "readUInt16BE"),
+    ALIAS("readUintLE", "readUIntLE"), ALIAS("readUint32LE", "readUInt32LE"),
+    ALIAS("readUint16LE", "readUInt16LE"), ALIAS("readUint8", "readUInt8"),
+    ALIAS("readUintBE", "readUIntBE"), ALIAS("readUint32BE", "readUInt32BE"),
+    ALIAS("readUint16BE", "readUInt16BE"),
     FN("readIntLE", read_intle, 2), FN("readInt32LE", read_int32le, 0), FN("readInt16LE", read_int16le, 0),
     FN("readInt8", read_int8, 0), FN("readIntBE", read_intbe, 2), FN("readInt32BE", read_int32be, 0),
     FN("readInt16BE", read_int16be, 0),
     FN("writeUIntLE", write_uintle, 3), FN("writeUInt32LE", write_uint32le, 0), FN("writeUInt16LE", write_uint16le, 0),
     FN("writeUInt8", write_uint8, 0), FN("writeUIntBE", write_uintbe, 3), FN("writeUInt32BE", write_uint32be, 0),
     FN("writeUInt16BE", write_uint16be, 0),
-    JS_BUILTIN_ALIAS("writeUintLE", "writeUIntLE"), JS_BUILTIN_ALIAS("writeUint32LE", "writeUInt32LE"),
-    JS_BUILTIN_ALIAS("writeUint16LE", "writeUInt16LE"), JS_BUILTIN_ALIAS("writeUint8", "writeUInt8"),
-    JS_BUILTIN_ALIAS("writeUintBE", "writeUIntBE"), JS_BUILTIN_ALIAS("writeUint32BE", "writeUInt32BE"),
-    JS_BUILTIN_ALIAS("writeUint16BE", "writeUInt16BE"),
+    ALIAS("writeUintLE", "writeUIntLE"), ALIAS("writeUint32LE", "writeUInt32LE"),
+    ALIAS("writeUint16LE", "writeUInt16LE"), ALIAS("writeUint8", "writeUInt8"),
+    ALIAS("writeUintBE", "writeUIntBE"), ALIAS("writeUint32BE", "writeUInt32BE"),
+    ALIAS("writeUint16BE", "writeUInt16BE"),
     FN("writeIntLE", write_intle, 3), FN("writeInt32LE", write_int32le, 0), FN("writeInt16LE", write_int16le, 0),
     FN("writeInt8", write_int8, 0), FN("writeIntBE", write_intbe, 3), FN("writeInt32BE", write_int32be, 0),
     FN("writeInt16BE", write_int16be, 0),
@@ -1314,8 +1318,8 @@ static const JSBuiltin buffer_proto[] = {
     FN("asciiWrite", buffer_ascii_write, 3), FN("base64Write", buffer_base64_write, 3),
     FN("base64urlWrite", buffer_base64url_write, 3), FN("latin1Write", buffer_latin1_write, 3),
     FN("hexWrite", buffer_hex_write, 3), FN("ucs2Write", buffer_ucs2_write, 3), FN("utf8Write", buffer_utf8_write, 3),
-    JS_BUILTIN_GETTER("parent", buffer_parent),
-    JS_BUILTIN_GETTER("offset", buffer_offset),
+    GETTER("parent", buffer_parent),
+    GETTER("offset", buffer_offset),
     FN("copy", buffer_copy, 4),
     FN("toString", buffer_to_string, 3),
     FN("equals", buffer_equals, 1),
@@ -1332,7 +1336,7 @@ static const JSBuiltin buffer_proto[] = {
     FN("swap16", buffer_swap16, 0),
     FN("swap32", buffer_swap32, 0),
     FN("swap64", buffer_swap64, 0),
-    JS_BUILTIN_ALIAS("toLocaleString", "toString"),
+    ALIAS("toLocaleString", "toString"),
 };
 
 static void install_buffer(JSContext *ctx, JSObject *global) {

package/runtime/src/console.c

@@ -619,7 +619,20 @@ void js_report_error(JSContext *ctx, const char *prefix, JSValue e) {
     fflush(stderr);
 }
 
+static int uncaught(JSContext *ctx, const char *prefix, JSValue error, JSValue promise) {
+    JSRuntime *rt = ctx->rt;
+    int status = rt->on_uncaught ? rt->on_uncaught(ctx, error, promise) : -1;
+    if (status < 0) {
+        js_report_error(ctx, prefix, error);
+        status = 1;
+    }
+    return status ? (rt->failure = (uint8_t)status) : 0;
+}
+
 int js_report_uncaught(JSContext *ctx) {
-    js_report_error(ctx, "Uncaught ", js_take_exception(ctx));
-    return 1;
+    return uncaught(ctx, "Uncaught ", js_take_exception(ctx), JS_UNDEFINED);
+}
+
+int js_report_rejection(JSContext *ctx, JSValue promise, JSValue reason) {
+    return uncaught(ctx, "Uncaught (in promise) ", reason, promise);
 }

package/runtime/src/events.c

@@ -410,7 +410,7 @@ BUILTIN(rethrow) {
 
 static void report_later(JSContext *ctx) {
     JSValue error = js_take_exception(ctx);
-    JSJob job = { JS_JOB_CALLBACK, NULL, js_new_closure_native(ctx, rethrow, 0, error), JS_UNDEFINED, JS_UNDEFINED };
+    JSJob job = { JS_JOB_CALLBACK, NULL, js_new_closure_native(ctx, rethrow, 0, error), JS_UNDEFINED, JS_UNDEFINED, JS_UNDEFINED };
     js_enqueue_microtask(ctx, &job);
 }
 

package/runtime/src/gc.c

@@ -521,6 +521,7 @@ static void mark_roots(JSRuntime *rt, JSTracer *trc) {
     JSHeap *h = &rt->heap;
     js_trace_value(trc, rt->exception);  /* ADR 0004, invariant 4 */
     js_trace_value(trc, rt->symbol_registry);
+    js_trace_value(trc, rt->async_context);
     js_jobs_trace(rt, trc);  /* queued jobs, unhandled rejections (ADR 0008) */
     js_weak_trace_roots(rt, trc);  /* the WeakRef kept-alive set */
     for (JSContext *realm = rt->realms; realm; realm = realm->next_realm)
@@ -724,6 +725,7 @@ JSRuntime *js_runtime_new(void) {
     rt->stack_limit = (uintptr_t)stack_low + JS_STACK_MARGIN;
     rt->exception = JS_EMPTY;
     rt->symbol_registry = JS_UNDEFINED;
+    rt->async_context = JS_UNDEFINED;
     rt->heap.min_heap = JS_GC_MIN_HEAP;
     const char *limit = getenv("JS_HEAP_LIMIT_MB");
     if (limit) rt->heap.heap_limit = (size_t)strtoull(limit, NULL, 10) << 20;