visaljs 0.0.4 → 0.0.6

package/runtime/src/jobs.c

@@ -2,6 +2,7 @@
  * loop (layer 2: timers; the v1 backend has no I/O, so waiting is sleeping). */
 #include "js_jobs.h"
 
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -31,10 +32,32 @@ void js_enqueue_microtask(JSContext *ctx, const JSJob *job) {
     JSJob *slot = &q->items[(q->head + q->count) % q->cap];
     *slot = *job;
     slot->realm = ctx;
+    slot->context = ctx->rt->async_context;
     q->count++;
 }
 
+/* ---- The async context (ADR 0020) ---------------------------------------------------- */
+
+JSValue js_async_context(JSContext *ctx) { return ctx->rt->async_context; }
+
+void js_set_async_context(JSContext *ctx, JSValue context) {
+    ctx->rt->async_context = context;  /* a root, not a heap cell: no barrier */
+}
+
+/* A job runs under the async context it was queued in (a promise reaction's is its then()'s:
+ * promise.c), and the one current before is current again after it. */
+static int run_job_body(const JSJob *job);
+
 static int run_job(const JSJob *job) {
+    JSRuntime *rt = job->realm->rt;
+    JSValue saved = rt->async_context;
+    rt->async_context = job->context;
+    int r = run_job_body(job);
+    rt->async_context = saved;
+    return r;
+}
+
+static int run_job_body(const JSJob *job) {
     JSContext *ctx = job->realm;
     switch (job->kind) {
     case JS_JOB_PROMISE_REACTION: return js_promise_reaction_job(ctx, job->a, job->b, job->c);
@@ -61,19 +84,28 @@ static int run_job(const JSJob *job) {
 
 void js_set_rejection_mode(JSRuntime *rt, JSRejectionMode mode) { rt->rejection_mode = (uint8_t)mode; }
 
+static void push_rejection(struct JSRejections *l, JSValue promise) {
+    if (l->count == l->cap) {
+        size_t cap = l->cap ? l->cap * 2 : 16;
+        JSValue *items = realloc(l->items, cap * sizeof *items);
+        if (!items) js_fatal("out of memory tracking a rejection");
+        l->items = items;
+        l->cap = cap;
+    }
+    l->items[l->count++] = promise;
+}
+
 void js_track_rejection(JSContext *ctx, JSValue promise, bool rejected) {
     JSRuntime *rt = ctx->rt;
     struct JSRejections *l = &rt->rejections;
     if (rt->rejection_mode == JS_REJECTIONS_NONE) return;
     if (rejected) {
-        if (l->count == l->cap) {
-            size_t cap = l->cap ? l->cap * 2 : 16;
-            JSValue *items = realloc(l->items, cap * sizeof *items);
-            if (!items) js_fatal("out of memory tracking a rejection");
-            l->items = items;
-            l->cap = cap;
-        }
-        l->items[l->count++] = promise;
+        push_rejection(l, promise);
+        return;
+    }
+    if (js_as_promise(promise)->reported) {  /* the host handled it as unhandled: it hears of the handler */
+        js_as_promise(promise)->reported = 0;
+        if (rt->on_handled_late) push_rejection(&rt->handled_late, promise);
         return;
     }
     for (size_t i = 0; i < l->count; i++) {  /* handled before the checkpoint ended: not reported */
@@ -85,16 +117,24 @@ void js_track_rejection(JSContext *ctx, JSValue promise, bool rejected) {
     }
 }
 
-/* Reports what is still unhandled. Strict: the first one ends the program (like Node). */
+/* Reports what is still unhandled, unless the host handles it. Strict: the first one not
+ * handled ends the program (like Node). */
 static int process_rejections(JSContext *ctx) {
     JSRuntime *rt = ctx->rt;
-    struct JSRejections *l = &rt->rejections;
+    struct JSRejections *l = &rt->rejections, *late = &rt->handled_late;
+    while (late->count) {
+        JSValue promise = late->items[0];  /* on the C stack: the conservative scan keeps it alive */
+        memmove(&late->items[0], &late->items[1], (late->count - 1) * sizeof *late->items);
+        late->count--;
+        if (rt->on_handled_late(ctx, promise) < 0 && js_report_uncaught(ctx)) return -1;
+    }
     while (l->count) {
         JSValue promise = l->items[0];
         memmove(&l->items[0], &l->items[1], (l->count - 1) * sizeof *l->items);
         l->count--;
-        js_report_error(ctx, "Uncaught (in promise) ", js_as_promise(promise)->result);
-        if (rt->rejection_mode == JS_REJECTIONS_STRICT) {
+        int status = js_report_rejection(ctx, promise, js_as_promise(promise)->result);
+        if (status == 0) js_as_promise(promise)->reported = 1;
+        if (status && rt->rejection_mode == JS_REJECTIONS_STRICT) {
             l->count = 0;
             return -1;
         }
@@ -110,18 +150,19 @@ int js_run_microtasks(JSContext *ctx) {
     rt->in_checkpoint = 1;
     JSJobQueue *q = &rt->jobs;
     int status = 0;
-    while (q->count) {
-        JSJob job = q->items[q->head];  /* on the C stack: the conservative scan keeps it alive */
-        q->head = (q->head + 1) % q->cap;
-        q->count--;
-        if (run_job(&job) < 0) {
-            js_report_uncaught(job.realm);
-            status = -1;
-            break;
+    do {  /* again while the host's handling of a rejection queued jobs */
+        while (q->count) {
+            JSJob job = q->items[q->head];  /* on the C stack: the conservative scan keeps it alive */
+            q->head = (q->head + 1) % q->cap;
+            q->count--;
+            if (run_job(&job) < 0 && js_report_uncaught(job.realm)) {  /* handled: the next job runs */
+                status = -1;
+                break;
+            }
         }
-    }
-    js_clear_kept_objects(rt);  /* the end of the job: WeakRef targets may go now */
-    if (status == 0) status = process_rejections(ctx);
+        js_clear_kept_objects(rt);  /* the end of the job: WeakRef targets may go now */
+        if (status == 0) status = process_rejections(ctx);
+    } while (status == 0 && (q->count || rt->handled_late.count));
     rt->in_checkpoint = 0;
     return status;
 }
@@ -135,17 +176,21 @@ void js_jobs_trace(JSRuntime *rt, JSTracer *trc) {
         js_trace_value(trc, j->a);
         js_trace_value(trc, j->b);
         js_trace_value(trc, j->c);
+        js_trace_value(trc, j->context);
     }
     for (size_t i = 0; i < rt->rejections.count; i++) js_trace_value(trc, rt->rejections.items[i]);
+    for (size_t i = 0; i < rt->handled_late.count; i++) js_trace_value(trc, rt->handled_late.items[i]);
     for (size_t i = 0; i < rt->timers.count; i++) {
         js_trace_value(trc, rt->timers.heap[i].fn);
         js_trace_value(trc, rt->timers.heap[i].args);
+        js_trace_value(trc, rt->timers.heap[i].context);
     }
 }
 
 void js_jobs_free(JSRuntime *rt) {
     free(rt->jobs.items);
     free(rt->rejections.items);
+    free(rt->handled_late.items);
     free(rt->timers.heap);
 }
 
@@ -210,33 +255,58 @@ static JSValue add_timer(JSContext *ctx, uint32_t argc, const JSValue *argv, boo
     JSValue args = argc > 2 ? js_new_array_from(ctx, argv + 2, argc - 2) : JS_UNDEFINED;
     JSTimers *t = &ctx->rt->timers;
     if (++t->next_id > 2147483647u) t->next_id = 1;
-    JSTimer timer = { t->now + (uint64_t)delay, t->seq++, t->next_id, repeat ? (uint32_t)delay : 0, 0, ctx, fn, args };
+    JSTimer timer = { t->now + (uint64_t)delay, t->seq++, t->next_id, repeat ? (uint32_t)delay : 0, 0, ctx, fn, args, ctx->rt->async_context };
     timer_push(t, &timer);
     return js_int32((int32_t)timer.id);
 }
 
 uint32_t js_add_timer(JSContext *ctx, JSValue fn, double delay, bool unref) {
+    return js_timer_start(ctx, fn, delay, false, unref, 0);
+}
+
+static size_t timer_find(const JSTimers *t, uint32_t id) {
+    for (size_t i = 0; i < t->count; i++)
+        if (t->heap[i].id == id) return i;
+    return SIZE_MAX;
+}
+
+uint32_t js_timer_start(JSContext *ctx, JSValue fn, double delay, bool immediate, bool unref, uint32_t id) {
     if (!(delay >= 1 && delay <= TIMEOUT_MAX)) delay = 1;
     JSTimers *t = &ctx->rt->timers;
     if (!t->now) t->now = js_os_now_ms();
-    if (++t->next_id > 2147483647u) t->next_id = 1;
-    JSTimer timer = { t->now + (uint64_t)delay, t->seq++, t->next_id, 0, unref, ctx, fn, JS_UNDEFINED };
+    if (id) {  /* restarted: it replaces the pending one with its id */
+        size_t i = timer_find(t, id);
+        if (i != SIZE_MAX) timer_remove(t, i);
+    } else {
+        if (++t->next_id > 2147483647u) t->next_id = 1;
+        id = t->next_id;
+    }
+    JSTimer timer = { immediate ? t->now : t->now + (uint64_t)delay, t->seq++, id, 0, unref, ctx, fn, JS_UNDEFINED, ctx->rt->async_context };
     timer_push(t, &timer);
-    return timer.id;
+    return id;
+}
+
+void js_timer_set_ref(JSContext *ctx, uint32_t id, bool ref) {
+    JSTimers *t = &ctx->rt->timers;
+    size_t i = timer_find(t, id);
+    if (i == SIZE_MAX || t->heap[i].unref == !ref) return;
+    t->heap[i].unref = !ref;
+    if (ref) t->refed++;
+    else t->refed--;
+}
+
+void js_timer_clear(JSContext *ctx, uint32_t id) {
+    JSTimers *t = &ctx->rt->timers;
+    if (t->running && id == t->running) t->running_cleared = 1;
+    size_t i = timer_find(t, id);
+    if (i != SIZE_MAX) timer_remove(t, i);
 }
 
 /* clearTimeout / clearInterval (either clears both kinds, as in Node). */
 static void clear_timer(JSContext *ctx, uint32_t argc, const JSValue *argv) {
     if (!argc || !js_is_number(argv[0])) return;
     double d = js_as_number(argv[0]);
-    JSTimers *t = &ctx->rt->timers;
-    if (t->running && d == (double)t->running) t->running_cleared = 1;
-    for (size_t i = 0; i < t->count; i++) {
-        if ((double)t->heap[i].id == d) {
-            timer_remove(t, i);
-            return;
-        }
-    }
+    if (d >= 1 && d <= 2147483647.0 && d == (double)(uint32_t)d) js_timer_clear(ctx, (uint32_t)d);
 }
 
 #define HOST_FN(fn) static JSValue fn(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target)
@@ -257,7 +327,7 @@ HOST_FN(set_immediate) {
     JSValue args = argc > 1 ? js_new_array_from(ctx, argv + 1, argc - 1) : JS_UNDEFINED;
     JSTimers *t = &ctx->rt->timers;
     if (++t->next_id > 2147483647u) t->next_id = 1;
-    JSTimer timer = { t->now, t->seq++, t->next_id, 0, 0, ctx, fn, args };
+    JSTimer timer = { t->now, t->seq++, t->next_id, 0, 0, ctx, fn, args, ctx->rt->async_context };
     timer_push(t, &timer);
     return js_int32((int32_t)timer.id);
 }
@@ -274,7 +344,7 @@ static JSValue queue_microtask(JSContext *ctx, JSValue callee, JSValue this_val,
     (void)callee, (void)this_val, (void)new_target;
     JSValue fn = argc ? argv[0] : JS_UNDEFINED;
     if (!js_is_callable(fn)) return js_throw_type_error(ctx, "The \"callback\" argument must be of type function");
-    JSJob job = { JS_JOB_CALLBACK, NULL, fn, JS_UNDEFINED, JS_UNDEFINED };
+    JSJob job = { JS_JOB_CALLBACK, NULL, fn, JS_UNDEFINED, JS_UNDEFINED, JS_UNDEFINED };
     js_enqueue_microtask(ctx, &job);
     return JS_UNDEFINED;
 }
@@ -291,16 +361,22 @@ void js_jobs_realm_init(JSContext *ctx, JSObject *global) {
     if (!t->now) t->now = js_os_now_ms();  /* the base of every timer the main script sets */
 }
 
+bool js_event_loop_alive(JSContext *ctx) {
+    JSRuntime *rt = ctx->rt;
+    return rt->timers.refed || (rt->io && rt->io->alive(rt));
+}
+
 /* One task per iteration, then a full checkpoint: promise callbacks always run before the
  * next timer. The program ends when no timer is pending (unref'd ones don't count) and no I/O is. */
 int js_run_event_loop(JSContext *ctx, JSValue main_result) {
-    if (js_is_exception(main_result)) return js_report_uncaught(ctx);
-    if (js_run_microtasks(ctx) < 0) return 1;
     JSRuntime *rt = ctx->rt;
+    int status = js_is_exception(main_result) ? js_report_uncaught(ctx) : 0;
+    if (status) return status;
+    if (js_run_microtasks(ctx) < 0) return rt->failure;
     JSTimers *t = &rt->timers;
-    while (t->refed || (rt->io && rt->io->alive(rt))) {
+    while (js_event_loop_alive(ctx)) {
         /* FinalizationRegistry cleanups run between tasks; on their own they don't keep the program alive */
-        if (js_run_finalization_cleanups(ctx) < 0) return 1;
+        if (js_run_finalization_cleanups(ctx) < 0) return rt->failure;
         if (!t->count || t->heap[0].deadline > t->now) {  /* nothing due at the cached time: refresh it, or wait */
             t->now = js_os_now_ms();
             if (!t->count || t->heap[0].deadline > t->now) {
@@ -310,7 +386,7 @@ int js_run_event_loop(JSContext *ctx, JSValue main_result) {
                 fflush(stderr);
                 /* I/O callbacks run while waiting, unref'd handles' too while a timer is pending */
                 if (rt->io && (timeout >= 0 || rt->io->alive(rt))) {
-                    int status = rt->io->run(ctx, timeout);
+                    status = rt->io->run(ctx, timeout);
                     if (status) return status;
                 } else {
                     js_os_sleep_ms(t->heap[0].deadline - t->now);  /* t->refed: a timer is pending */
@@ -323,16 +399,19 @@ int js_run_event_loop(JSContext *ctx, JSValue main_result) {
         timer_remove(t, 0);
         t->running = timer.repeat ? timer.id : 0;
         t->running_cleared = 0;
+        JSValue saved = rt->async_context;
+        rt->async_context = timer.context;
         JSValue r = js_is_undefined(timer.args) ? js_call(timer.realm, timer.fn, JS_UNDEFINED, 0, NULL)
                                                 : js_call_spread(timer.realm, timer.fn, JS_UNDEFINED, timer.args, NULL);
+        rt->async_context = saved;
         t->running = 0;
-        if (js_is_exception(r)) return js_report_uncaught(timer.realm);
+        if (js_is_exception(r) && (status = js_report_uncaught(timer.realm))) return status;
         if (timer.repeat && !t->running_cleared) {  /* re-armed after its callback, from the loop's time */
             timer.deadline = t->now + timer.repeat;
             timer.seq = t->seq++;
             timer_push(t, &timer);
         }
-        if (js_run_microtasks(ctx) < 0) return 1;
+        if (js_run_microtasks(ctx) < 0) return rt->failure;
     }
     return 0;
 }

package/runtime/src/process.c

@@ -1,6 +1,7 @@
 /* The global process (ADR 0012), natively: the command line, the environment, the exit
  * status, standard output and error, and warnings. js_host_init installs it with console
- * and global before the program runs. */
+ * and global before the program runs. Its events ('beforeExit', 'exit') go through its emit,
+ * which it has once node/prelude/internal/process_events.js made it an EventEmitter. */
 #define _XOPEN_SOURCE 700  /* getpid, isatty, realpath, environ under -std=c11 */
 #include "js_host.h"
 
@@ -61,15 +62,88 @@ JSValue js_host_cwd(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t a
 
 static int saved_argc;
 static char **saved_argv;
+static JSValue process_object;  /* set by js_host_init, a root: the program may delete globalThis.process */
+static bool exiting;                           /* 'exit' was emitted: process.exit() now just exits */
 
 /* process.exitCode: undefined, null or an integer */
 static enum { EXIT_UNSET, EXIT_NULL, EXIT_SET } exit_state;
 static double exit_value;
 
-int js_host_exit_code(void) {
+static int exit_status(void) {
     return exit_state == EXIT_SET ? (int)(int64_t)exit_value : 0;
 }
 
+/* process.emit(type, a[, b]): 1 if it had listeners, 0 if not or process has no emit (it isn't
+ * an EventEmitter: the program never names one of its methods), -1 after an exception. */
+static int emit_event(JSContext *ctx, const char *type, uint32_t argc, JSValue a, JSValue b) {
+    JSValue emit = js_get_value(ctx, process_object, js_atom_from_cstr(ctx, "emit"));
+    if (js_is_exception(emit)) return -1;
+    if (!js_is_callable(emit)) return 0;
+    JSValue args[3] = { js_new_string_cstr(ctx, type), a, b };
+    if (js_is_exception(args[0])) return -1;
+    JSValue r = js_call(ctx, emit, process_object, argc + 1, args);
+    return js_is_exception(r) ? -1 : js_truthy(r);
+}
+
+/* rt->on_uncaught: a rejection goes to 'unhandledRejection' (reason, promise); an error, or a
+ * rejection nobody listens for, to 'uncaughtException' (error, origin), as in Node. A
+ * listener's own error: an 'unhandledRejection' one's is uncaught, an 'uncaughtException'
+ * one's ends the program with status 7, without 'exit'. */
+static int on_uncaught(JSContext *ctx, JSValue error, JSValue promise) {
+    const char *origin = "uncaughtException";
+    bool rethrown = false;  /* error is an 'unhandledRejection' listener's */
+    if (!js_is_undefined(promise)) {
+        int had = emit_event(ctx, "unhandledRejection", 2, error, promise);
+        if (had > 0) return 0;
+        if (had == 0) origin = "unhandledRejection";
+        else {
+            error = js_take_exception(ctx);
+            rethrown = true;
+        }
+    }
+    JSValue name = js_new_string_cstr(ctx, origin);
+    int had = js_is_exception(name) ? -1 : emit_event(ctx, "uncaughtException", 2, error, name);
+    if (had > 0) return 0;
+    if (had < 0) {
+        js_report_error(ctx, "Uncaught ", js_take_exception(ctx));
+        exiting = true;
+        return 7;
+    }
+    if (!rethrown) return -1;
+    js_report_error(ctx, "Uncaught ", error);
+    return 1;
+}
+
+/* rt->on_handled_late: 'rejectionHandled' (promise) */
+static int on_handled_late(JSContext *ctx, JSValue promise) {
+    return emit_event(ctx, "rejectionHandled", 1, promise, JS_UNDEFINED) < 0 ? -1 : 0;
+}
+
+/* 'exit', with process.exitCode (0 when unset): once, whichever way the program ends. */
+static int emit_exit(JSContext *ctx) {
+    if (exiting) return 0;
+    exiting = true;
+    return emit_event(ctx, "exit", 1, js_number(exit_state == EXIT_SET ? exit_value : 0), JS_UNDEFINED);
+}
+
+int js_host_exit(JSContext *ctx, int status) {
+    /* 'beforeExit' each time the loop empties, while its listeners give it more to do */
+    while (status == 0) {
+        int had = emit_event(ctx, "beforeExit", 1, js_number(exit_state == EXIT_SET ? exit_value : 0), JS_UNDEFINED);
+        if (had == 0) break;
+        if (had < 0 && (status = js_report_uncaught(ctx))) break;
+        if (js_run_microtasks(ctx) < 0) status = ctx->rt->failure;
+        else if (!js_event_loop_alive(ctx)) break;
+        else status = js_run_event_loop(ctx, JS_UNDEFINED);
+    }
+    if (status != 0) {  /* process.exitCode is the failure's status, as in Node */
+        exit_state = EXIT_SET;
+        exit_value = status;
+    }
+    if (emit_exit(ctx) < 0 && (status = js_report_uncaught(ctx))) return status;
+    return exit_status();
+}
+
 /* ---- Node's argument errors -------------------------------------------------------------- */
 
 static JSValue throw_with_code(JSContext *ctx, JSErrorKind kind, const char *code, JSValue message) {
@@ -192,14 +266,15 @@ NATIVE(exit_code_set) {
     return JS_UNDEFINED;
 }
 
+/* exit(code): process.exitCode = code (when given), 'exit' (unless it's running), then the end. */
 NATIVE(process_exit) {
     UNUSED_ARGS;
-    JSValue code = ARG(0);
-    if (js_is_undefined(code)) code = exit_state == EXIT_SET ? js_number(exit_value) : JS_UNDEFINED;
-    if (check_code(ctx, &code) < 0) return JS_EXCEPTION;
+    if (!js_is_undefined(ARG(0)) && js_is_exception(exit_code_set(ctx, JS_UNDEFINED, JS_UNDEFINED, 1, argv, JS_UNDEFINED)))
+        return JS_EXCEPTION;
+    if (emit_exit(ctx) < 0) (void)js_report_uncaught(ctx);  /* the status stays the one asked for */
     fflush(stdout);
     fflush(stderr);
-    exit(js_is_number(code) ? (int)(int64_t)js_as_number(code) : 0);
+    exit(exit_status());
 }
 
 NATIVE(process_cwd) {
@@ -220,7 +295,7 @@ NATIVE(process_next_tick) {
         args = js_new_array_from(ctx, argv + 1, argc - 1);
         if (js_is_exception(args)) return args;
     }
-    JSJob job = { JS_JOB_CALLBACK, NULL, argv[0], args, JS_UNDEFINED };
+    JSJob job = { JS_JOB_CALLBACK, NULL, argv[0], args, JS_UNDEFINED, JS_UNDEFINED };
     js_enqueue_microtask(ctx, &job);
     return JS_UNDEFINED;
 }
@@ -277,6 +352,11 @@ NATIVE(process_emit_warning) {
     char small_name[128], small_code[128];
     size_t n = js_view_to_utf8(js_string_view(ctx, name), small_name, sizeof small_name - 1);
     small_name[n < sizeof small_name ? n : sizeof small_name - 1] = '\0';
+    if (strcmp(small_name, "DeprecationWarning") == 0 && js_is_object(process_object)) {  /* silenced as the program runs, as in Node */
+        JSValue silenced = js_get_value(ctx, process_object, js_atom_from_cstr(ctx, "noDeprecation"));
+        if (js_is_exception(silenced)) return JS_EXCEPTION;
+        if (js_truthy(silenced)) return JS_UNDEFINED;
+    }
     if (!js_is_undefined(code_str)) {
         size_t c = js_view_to_utf8(js_string_view(ctx, code_str), small_code, sizeof small_code - 1);
         small_code[c < sizeof small_code ? c : sizeof small_code - 1] = '\0';
@@ -292,7 +372,7 @@ static JSValue stream_write(JSContext *ctx, int fd, uint32_t argc, const JSValue
     js_write_output(ctx, fd, s);
     JSValue callback = js_is_callable(ARG(1)) ? ARG(1) : ARG(2);
     if (js_is_callable(callback)) {
-        JSJob job = { JS_JOB_CALLBACK, NULL, callback, JS_UNDEFINED, JS_UNDEFINED };
+        JSJob job = { JS_JOB_CALLBACK, NULL, callback, JS_UNDEFINED, JS_UNDEFINED, JS_UNDEFINED };
         js_enqueue_microtask(ctx, &job);
     }
     return JS_TRUE;
@@ -433,6 +513,10 @@ int js_host_init(JSContext *ctx, int argc, char **argv) {
     js_define_data(ctx, g, js_atom_from_cstr(ctx, "console"), console, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     JSValue process = new_process(ctx);
     if (js_is_exception(process)) return -1;
+    process_object = process;
+    js_add_root(ctx->rt, &process_object);
+    ctx->rt->on_uncaught = on_uncaught;
+    ctx->rt->on_handled_late = on_handled_late;
     js_define_data(ctx, g, js_atom_from_cstr(ctx, "process"), process, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     js_define_data(ctx, g, js_atom_from_cstr(ctx, "global"), global, JS_PROP_DEFAULT);
     return 0;

package/runtime/src/promise.c

@@ -74,6 +74,7 @@ typedef struct Reaction {
     JSValue    on_rejected;   /* a function, or EMPTY: the reason passes through */
     JSValue    capability;    /* the derived promise (settled directly), a Capability cell, or undefined */
     JSValue    next;          /* the next (older) reaction, or undefined */
+    JSValue    context;       /* the async context of its then() or await, which its job runs under (ADR 0020) */
 } Reaction;
 
 static void reaction_visit(JSCell *c, JSTracer *trc) {
@@ -82,11 +83,12 @@ static void reaction_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, r->on_rejected);
     js_trace_value(trc, r->capability);
     js_trace_value(trc, r->next);
+    js_trace_value(trc, r->context);
 }
 static const JSCellClass reaction_class = { "PromiseReaction", reaction_visit, NULL };
 
 static void enqueue_reaction(JSContext *ctx, JSValue reaction, JSValue argument, int state) {
-    JSJob job = { JS_JOB_PROMISE_REACTION, NULL, reaction, argument, js_int32(state) };
+    JSJob job = { JS_JOB_PROMISE_REACTION, NULL, reaction, argument, js_int32(state), JS_UNDEFINED };
     js_enqueue_microtask(ctx, &job);
 }
 
@@ -130,7 +132,7 @@ static void resolve(JSContext *ctx, JSValue promise, JSValue resolution) {
         settle(ctx, promise, JS_PROMISE_FULFILLED, resolution);
         return;
     }
-    JSJob job = { JS_JOB_RESOLVE_THENABLE, NULL, promise, resolution, then };
+    JSJob job = { JS_JOB_RESOLVE_THENABLE, NULL, promise, resolution, then, JS_UNDEFINED };
     js_enqueue_microtask(ctx, &job);
 }
 
@@ -284,6 +286,7 @@ static void perform_then(JSContext *ctx, JSValue promise, JSValue on_fulfilled,
     js_init_slot(&r->on_rejected, js_is_callable(on_rejected) ? on_rejected : JS_EMPTY);
     js_init_slot(&r->capability, capability);
     js_init_slot(&r->next, JS_UNDEFINED);
+    js_init_slot(&r->context, ctx->rt->async_context);
     add_reaction(ctx, promise, r);
 }
 
@@ -298,6 +301,7 @@ void js_promise_await(JSContext *ctx, JSValue promise, JSValue gen) {
     js_init_slot(&r->on_rejected, JS_EMPTY);
     js_init_slot(&r->capability, JS_UNDEFINED);
     js_init_slot(&r->next, JS_UNDEFINED);
+    js_init_slot(&r->context, ctx->rt->async_context);
     add_reaction(ctx, promise, r);
 }
 
@@ -318,6 +322,7 @@ static void add_reaction(JSContext *ctx, JSValue promise, Reaction *r) {
  * a throwing resolve or reject of a foreign capability escapes, as an uncaught error. */
 int js_promise_reaction_job(JSContext *ctx, JSValue reaction, JSValue argument, JSValue state) {
     Reaction *r = (Reaction *)js_as_cell(reaction);
+    ctx->rt->async_context = r->context;  /* run_job restores the one before */
     bool rejected = js_as_int32(state) == JS_PROMISE_REJECTED;
     if (r->kind == REACTION_AWAIT) {  /* resume the async call; its outcome settles its own promise */
         js_async_resume(ctx, js_as_generator(r->on_fulfilled), argument, rejected ? JS_RESUME_THROW : JS_RESUME_NEXT);

package/runtime/src/weak.c

@@ -380,10 +380,7 @@ int js_run_finalization_cleanups(JSContext *ctx) {
         if (o->shape->cls != &registry_class || !((Registry *)o)->pending) continue;
         Registry *r = (Registry *)o;
         JSValue keep = js_object_value(o);  /* a callback may drop the last reference */
-        if (cleanup_registry(r) < 0) {
-            js_report_uncaught(r->realm);
-            return -1;
-        }
+        if (cleanup_registry(r) < 0 && js_report_uncaught(r->realm)) return -1;
         js_keep_alive(keep);
         if (js_run_microtasks(ctx) < 0) return -1;
     }