@scriptc/runtime 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "scriptc native runtime — C sources, compiled into every scriptc binary",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/src/scr_async.c

@@ -106,6 +106,10 @@ struct ScrPromise {
   size_t ncbs, cbs_cap;
   /* Unhandled-rejection tracking: set when rejected, cleared on await. */
   bool rejection_observed;
+  /* Set when the loop-end report delivered THIS promise to
+   * 'unhandledRejection' listeners — a handler attached after that is
+   * Node's 'rejectionHandled' moment (scr_prom_observe below). */
+  bool reported_unhandled;
 };
 
 #ifdef SCR_RC_AUDIT
@@ -187,6 +191,35 @@ ScrPromise *scr_promise_new(void) {
   return p;
 }
 
+/* The 'rejectionHandled' hook (scr_async_dyn.c installs it at listener
+ * registration — the scr_urj_deliver_fn pattern, so listener-free
+ * binaries keep their size class): called when a promise the loop-end
+ * report already delivered as unhandled gains a handler. */
+void (*scr_rjh_notify_fn)(ScrPromise *p) = NULL;
+
+/* Every handler attach funnels here: mark the rejection observed, and
+ * fire Node's 'rejectionHandled' when the attach arrived AFTER the
+ * report delivered this promise to 'unhandledRejection' listeners (the
+ * model's one late-handling window — earlier handling keeps the promise
+ * out of the report entirely). The flag clears on the first attach, so
+ * one report fires at most one 'rejectionHandled' — Node's pairing. */
+static void scr_prom_observe(ScrPromise *p) {
+  p->rejection_observed = true;
+  if (p->reported_unhandled) {
+    p->reported_unhandled = false;
+    if (scr_rjh_notify_fn != NULL) scr_rjh_notify_fn(p);
+  }
+}
+
+/* The attach-time handled mark (scr_async_dyn.c's dyn then/catch with a
+ * rejection handler): Node marks a rejection handled at ATTACH, not when
+ * the reaction runs — and the loop-exhaustion window (a .catch inside an
+ * 'unhandledRejection' listener) has no later fiber turn whose await
+ * could observe it. */
+void scr_promise_mark_handled(ScrPromise *p) {
+  if (p->state == SCR_PROM_REJECTED) scr_prom_observe(p);
+}
+
 ScrPromise *scr_promise_retain(ScrPromise *p) {
   if (p && p->rc != SIZE_MAX) {
     p->rc++;
@@ -855,7 +888,7 @@ static void scr_promise_settle_from(ScrPromise *dst, ScrPromise *src) {
     }
     scr_promise_settle_wake(dst);
   }
-  if (src->state == SCR_PROM_REJECTED) src->rejection_observed = true;
+  if (src->state == SCR_PROM_REJECTED) scr_prom_observe(src);
 }
 
 /* The emitted same-type Promise.race adapter (see raceAdapterFor). */
@@ -1201,7 +1234,7 @@ void scr_await_hop(void) { scr_await_yield(); }
 static bool scr_await_settled(ScrPromise *p) {
   if (p->state != SCR_PROM_PENDING) scr_await_yield();
   while (p->state == SCR_PROM_PENDING) scr_await_park(p);
-  p->rejection_observed = true;
+  scr_prom_observe(p);
   if (p->state == SCR_PROM_REJECTED) {
     switch (p->payload_kind) {
     case SCR_EXC_F64: scr_throw_f64(p->f64); break;
@@ -2076,8 +2109,12 @@ bool scr_report_unhandled_rejections(void) {
       if (scr_urj_deliver_fn != NULL) {
         /* Listener dispatch (scr_async_dyn.c installed the hook at
          * registration): the event handles it, like Node — per entry,
-         * no report, exit 0. A listener throw is the uncaught crash. */
+         * no report, exit 0. A listener throw is the uncaught crash.
+         * reported_unhandled arms the 'rejectionHandled' window: a
+         * handler the listener itself attaches fires the sibling event
+         * (scr_prom_observe). */
         p->rejection_observed = true;
+        p->reported_unhandled = true;
         if (!scr_urj_deliver_fn(p)) crashed = true;
       } else if (!any) {
         any = true;
@@ -2118,6 +2155,14 @@ bool scr_report_unhandled_rejections(void) {
     bool island = scr_island_rejections_fn(!any);
     any = any || island;
   }
+  /* An 'unhandledRejection' listener can spawn fibers the exhausted loop
+   * will never run (a .catch attach mints a reaction fiber): they are
+   * abandoned by construction — re-note them so the RC audit's skip
+   * covers their parked state, exactly the loop-teardown accounting. */
+  if (scr_fibers_live > scr_fibers_abandoned) {
+    scr_fibers_abandoned = scr_fibers_live;
+    scr_note_abandoned_fibers(scr_fibers_abandoned);
+  }
   /* main returns 1 on a reported rejection — the 'exit' listeners (atexit)
    * must see that code, like Node's. */
   if (any) scr_exit_code_note(1);

package/src/scr_async_dyn.c

@@ -146,55 +146,166 @@ ScrDyn *scr_als_exit_run(double id, ScrDyn *fn, ScrDyn *args) {
   return scr_als_call_in(scr_als_enter_absent(id), fn, args);
 }
 
-static ScrDyn **scr_urj_listeners = NULL;
+/* The two rejection-event registries share one shape: listeners with a
+ * `once` flag (auto-removed after one delivery, Node's once) and
+ * identity-based removal (the offWarning stance). */
+typedef struct {
+  ScrDyn *fn;
+  bool once;
+} ScrRejListener;
+
+static ScrRejListener *scr_urj_listeners = NULL;
 static size_t scr_nurj = 0, scr_urj_cap = 0;
+static ScrRejListener *scr_rjh_listeners = NULL;
+static size_t scr_nrjh = 0, scr_rjh_cap = 0;
 
 static void scr_urj_teardown(void) {
-  for (size_t i = 0; i < scr_nurj; i++) scr_dyn_release(scr_urj_listeners[i]);
+  for (size_t i = 0; i < scr_nurj; i++) scr_dyn_release(scr_urj_listeners[i].fn);
   free(scr_urj_listeners);
   scr_urj_listeners = NULL;
   scr_nurj = scr_urj_cap = 0;
 }
 
-static bool scr_urj_dispatch(ScrPromise *p);
+static void scr_rjh_teardown(void) {
+  for (size_t i = 0; i < scr_nrjh; i++) scr_dyn_release(scr_rjh_listeners[i].fn);
+  free(scr_rjh_listeners);
+  scr_rjh_listeners = NULL;
+  scr_nrjh = scr_rjh_cap = 0;
+}
 
-void scr_process_on_unhandled_rejection(ScrDyn *fn) {
-  if (fn->kind != SCR_DYN_FUNC) {
-    const char *msg = "The \"listener\" argument must be of type function";
-    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, strlen(msg), "ERR_INVALID_ARG_TYPE");
-    return;
+static bool scr_urj_dispatch(ScrPromise *p);
+static void scr_rjh_dispatch(ScrPromise *p);
+
+/* Node's ERR_INVALID_ARG_TYPE for a non-function listener; true when the
+ * value is fine. */
+static bool scr_rej_check_listener(ScrDyn *fn) {
+  if (fn->kind == SCR_DYN_FUNC) return true;
+  const char *msg = "The \"listener\" argument must be of type function";
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, strlen(msg), "ERR_INVALID_ARG_TYPE");
+  return false;
+}
+
+static void scr_rej_push(ScrRejListener **list, size_t *n, size_t *cap, ScrDyn *fn, bool once) {
+  if (*n == *cap) {
+    *cap = *cap ? *cap * 2 : 4;
+    *list = realloc(*list, *cap * sizeof **list);
+    if (!*list) scr_ad_oom();
   }
-  if (scr_nurj == scr_urj_cap) {
-    scr_urj_cap = scr_urj_cap ? scr_urj_cap * 2 : 4;
-    scr_urj_listeners = realloc(scr_urj_listeners, scr_urj_cap * sizeof *scr_urj_listeners);
-    if (!scr_urj_listeners) scr_ad_oom();
+  (*list)[(*n)++] = (ScrRejListener){scr_dyn_retain(fn), once};
+}
+
+static void scr_rej_remove(ScrRejListener *list, size_t *n, ScrDyn *fn) {
+  for (size_t i = 0; i < *n; i++) {
+    ScrDyn *l = list[i].fn;
+    bool same = l == fn || (l->kind == SCR_DYN_FUNC && fn->kind == SCR_DYN_FUNC &&
+                            l->v.fn.clo == fn->v.fn.clo);
+    if (same) {
+      scr_dyn_release(l);
+      memmove(list + i, list + i + 1, (*n - i - 1) * sizeof *list);
+      (*n)--;
+      return;
+    }
   }
-  if (scr_nurj == 0) {
+}
+
+/* The hooks arm exactly while their registry is non-empty: Node with
+ * every listener removed (off, or once-consumed) reverts to the default
+ * report/silence, and the report loop consults the hook per promise. */
+static void scr_urj_sync_hook(void) {
+  scr_urj_deliver_fn = scr_nurj > 0 ? scr_urj_dispatch : NULL;
+}
+
+static void scr_rjh_sync_hook(void) {
+  scr_rjh_notify_fn = scr_nrjh > 0 ? scr_rjh_dispatch : NULL;
+}
+
+void scr_process_on_unhandled_rejection(ScrDyn *fn, bool once) {
+  if (!scr_rej_check_listener(fn)) return;
+  static bool teardown_armed = false;
+  if (!teardown_armed) {
+    teardown_armed = true;
     atexit(scr_urj_teardown);
-    scr_urj_deliver_fn = scr_urj_dispatch; /* arm the loop-end report */
   }
-  scr_urj_listeners[scr_nurj++] = scr_dyn_retain(fn);
+  scr_rej_push(&scr_urj_listeners, &scr_nurj, &scr_urj_cap, fn, once);
+  scr_urj_sync_hook();
+}
+
+void scr_process_off_unhandled_rejection(ScrDyn *fn) {
+  scr_rej_remove(scr_urj_listeners, &scr_nurj, fn);
+  scr_urj_sync_hook();
+}
+
+void scr_process_on_rejection_handled(ScrDyn *fn, bool once) {
+  if (!scr_rej_check_listener(fn)) return;
+  static bool teardown_armed = false;
+  if (!teardown_armed) {
+    teardown_armed = true;
+    atexit(scr_rjh_teardown);
+  }
+  scr_rej_push(&scr_rjh_listeners, &scr_nrjh, &scr_rjh_cap, fn, once);
+  scr_rjh_sync_hook();
+}
+
+void scr_process_off_rejection_handled(ScrDyn *fn) {
+  scr_rej_remove(scr_rjh_listeners, &scr_nrjh, fn);
+  scr_rjh_sync_hook();
+}
+
+/* One registry pass: call every listener with `args`, removing once-
+ * listeners BEFORE their call (Node's once removes at dispatch, so a
+ * re-registration inside the listener sticks). The registry is accessed
+ * THROUGH its pointers per step — a listener that registers can realloc
+ * the array mid-pass. Returns false when a listener threw (the caller's
+ * crash path). */
+static bool scr_rej_fire(ScrRejListener **list, size_t *n, ScrDyn **args, size_t argc) {
+  size_t i = 0;
+  bool ok = true;
+  while (i < *n && ok) {
+    /* Own +1 across the call: a once-removal (here) or the listener
+     * removing itself (off inside the body) must not free a running
+     * function. */
+    ScrDyn *fn = scr_dyn_retain((*list)[i].fn);
+    if ((*list)[i].once) {
+      scr_dyn_release((*list)[i].fn);
+      memmove(*list + i, *list + i + 1, (*n - i - 1) * sizeof **list);
+      (*n)--;
+    } else {
+      i++;
+    }
+    ScrDyn *r = scr_dyn_call(fn, args, argc, "listener");
+    if (r == NULL) ok = false;
+    else scr_dyn_release(r);
+    scr_dyn_release(fn);
+  }
+  return ok;
 }
 
 /* Dispatch one unhandled rejection to the registered listeners —
  * (reason, promise), Node's signature. A listener throw is an uncaught
- * exception (Node crashes there too): print it and exit 1. Returns
- * false on that crash path. */
+ * exception (Node crashes there too): the caller prints it and exits 1.
+ * A once-consumed-to-empty registry disarms the hook on the way out, so
+ * the report's NEXT promise takes the default print — Node's
+ * listener-less behavior. */
 static bool scr_urj_dispatch(ScrPromise *p) {
   ScrDyn *reason = scr_promise_reason_dyn(p);
   ScrDyn *boxed = scr_dyn_new_promise(p);
   ScrDyn *args[2] = {reason, boxed};
-  bool ok = true;
-  for (size_t i = 0; i < scr_nurj && ok; i++) {
-    ScrDyn *r = scr_dyn_call(scr_urj_listeners[i], args, 2, "listener");
-    if (r == NULL) ok = false;
-    else scr_dyn_release(r);
-  }
+  bool ok = scr_rej_fire(&scr_urj_listeners, &scr_nurj, args, 2);
   scr_dyn_release(reason);
   scr_dyn_release(boxed);
+  scr_urj_sync_hook();
   return ok;
 }
 
+/* 'rejectionHandled' delivery — (promise), Node's payload. A listener
+ * throw propagates as a pending exception through the attach site. */
+static void scr_rjh_dispatch(ScrPromise *p) {
+  ScrDyn *boxed = scr_dyn_new_promise(p);
+  (void)scr_rej_fire(&scr_rjh_listeners, &scr_nrjh, &boxed, 1);
+  scr_dyn_release(boxed);
+  scr_rjh_sync_hook(); /* a once-consumed-to-empty registry disarms */
+}
+
 /* `new Promise(setImmediate)` (the Node-suite early-exit shape): the
  * executor IS setImmediate, so resolve rides the immediate queue — a
  * fresh promise an armed immediate fulfills with the undefined dyn value
@@ -289,6 +400,11 @@ static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
 }
 
 ScrDyn *scr_dyn_promise_then(ScrPromise *src, ScrDyn *onf, ScrDyn *onr, ScrDyn *onfin) {
+  /* A rejection HANDLER marks the source handled at attach (Node's
+   * moment; the reaction fiber's await re-marks harmlessly) — this is
+   * also what lets a .catch inside an 'unhandledRejection' listener fire
+   * 'rejectionHandled' when no fiber turn remains. */
+  if (onr != NULL) scr_promise_mark_handled(src);
   ScrDynThenPack *a = malloc(sizeof *a);
   if (!a) scr_ad_oom();
   a->src = scr_promise_retain(src);

package/src/scr_dyn_invoke.c

@@ -671,9 +671,33 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
     return NULL;
   }
 
-  if (recv->kind == SCR_DYN_BYTES && dyn_bytes_proto_real(method)) {
-    dyn_throw_unsupported("Uint8Array", method);
-    return NULL;
+  if (recv->kind == SCR_DYN_BYTES) {
+    ScrBytes *bytes = recv->v.bytes;
+    size_t blen = bytes->len;
+    if (dyn_name_is(method, "at")) {
+      double iD = dyn_index_arg(args, argc, 0, 0, what);
+      if (scr_exc_pending()) return NULL;
+      double idx = iD < 0 ? (double)blen + iD : iD;
+      if (idx < 0 || idx >= (double)blen) return scr_dyn_retain(scr_dyn_undefined());
+      return scr_dyn_new_num((double)bytes->data[(size_t)idx]);
+    }
+    if (dyn_name_is(method, "slice") || dyn_name_is(method, "subarray")) {
+      /* Both COPY (no views in this runtime — the static lane's
+       * documented divergence for subarray/Buffer.slice); the result
+       * keeps the receiver's Buffer flavor. */
+      double startD = dyn_index_arg(args, argc, 0, 0, what);
+      if (scr_exc_pending()) return NULL;
+      double endD = dyn_index_arg(args, argc, 1, (double)blen, what);
+      if (scr_exc_pending()) return NULL;
+      ScrBytes *out = scr_bytes_slice(bytes, startD, endD);
+      ScrDyn *d = recv->buffer ? scr_dyn_new_buffer_copy(out) : scr_dyn_new_bytes_copy(out);
+      scr_bytes_release(out);
+      return d;
+    }
+    if (dyn_bytes_proto_real(method)) {
+      dyn_throw_unsupported("Uint8Array", method);
+      return NULL;
+    }
   }
 
   /* NUM/BOOL/BYTES-remainder: the name is no method of this kind — JS's