@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

package/dist/lib/runtime-sources/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "scriptc native runtime sources and vendored dependencies",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/dist/lib/runtime-sources/src/scr_abort.c

@@ -0,0 +1,5 @@
+/* Portable AbortController/AbortSignal use the same implementation as native
+ * fetch, without its network transport, Web Streams, or global fetch setup. */
+#undef SCR_DYNAMIC
+#define SCR_FETCH_SIGNAL_ONLY 1
+#include "scr_fetch.c"

package/dist/lib/runtime-sources/src/scr_array.c

@@ -420,6 +420,7 @@ ScrArr *scr_arr_new(ScrElemKind elem, size_t initial_cap) {
   a->props = NULL;
   a->prop_len = 0;
   a->prop_cap = 0;
+  a->metadata = NULL;
   if (initial_cap > 0) scr_arr_grow_dense(a, initial_cap);
 #ifdef SCR_RC_AUDIT
   scr_live_arrays++;
@@ -433,6 +434,7 @@ ScrArr *scr_arr_new(ScrElemKind elem, size_t initial_cap) {
  * below releases none — the complement contract in scr_runtime.h. */
 void scr_arr_trace_v(void *a0, ScrTraceVisit visit, void *ctx) {
   ScrArr *a = (ScrArr *)a0;
+  visit(a->metadata, ctx);
   for (size_t i = 0; i < a->cap; i++) {
     if (a->present[i] == SCR_ARR_VALUE) visit(scr_slot_to_ptr(a->data[i]), ctx);
   }
@@ -486,6 +488,7 @@ ScrArr *scr_arr_new_ref(void *(*elem_retain)(void *),
   a->props = NULL;
   a->prop_len = 0;
   a->prop_cap = 0;
+  a->metadata = NULL;
   if (initial_cap > 0) scr_arr_grow_dense(a, initial_cap);
 #ifdef SCR_RC_AUDIT
   scr_live_arrays++;
@@ -497,6 +500,8 @@ void scr_arr_release(ScrArr *a) {
   if (!a || a->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
   if (--a->rc == 0) {
     if (a->elem_trace) scr_cyc_on_dead(a);
+    scr_dyn_release(a->metadata);
+    a->metadata = NULL;
     if (scr_elem_is_ref(a->elem)) {
       for (size_t i = 0; i < a->cap; i++) {
         if (a->present[i] != SCR_ARR_HOLE) {
@@ -534,6 +539,7 @@ void scr_arr_release(ScrArr *a) {
 #ifdef SCR_RC_AUDIT
       scr_live_arrays--;
 #endif
+      scr_weak_dispose(a);
       free(a);
     }
   } else if (a->elem_trace) {
@@ -1442,3 +1448,13 @@ ScrStr *scr_str_raw(ScrArr *raw, ScrArr *subs) {
   free(buf);
   return out;
 }
+
+void scr_arr_copy_metadata(ScrArr *a, ScrDyn *target) {
+  if (!a->metadata) return;
+  for (size_t i = 0; i < a->metadata->v.obj.len; i++) {
+    ScrDynEntry *entry = &a->metadata->v.obj.entries[i];
+    ScrStr *key = scr_str_new(entry->key, entry->key_len);
+    scr_dyn_key_set(target, key, entry->value);
+    scr_str_release(key);
+  }
+}

package/dist/lib/runtime-sources/src/scr_assert.c

@@ -134,6 +134,7 @@ void scr_assert_fail_msg(ScrStr *message) {
   scr_str_release(message); /* scr_error_new retained its copy */
   scr_str_release(e->name);
   e->name = scr_str_new("AssertionError", 14);
+  e->name_present = true;
   scr_error_set_code(e, "ERR_ASSERTION");
   scr_throw_obj(e, &scr_error_retain_v, &scr_error_release_v, scr_error_trace_arg());
 }

package/dist/lib/runtime-sources/src/scr_async.c

@@ -153,8 +153,11 @@ enum { SCR_PROM_PENDING = 0, SCR_PROM_FULFILLED = 1, SCR_PROM_REJECTED = 2 };
 
 typedef struct ScrFiber ScrFiber;
 
+typedef struct { size_t rc; } ScrPromiseIdentity;
+
 struct ScrPromise {
-  size_t rc;
+  size_t rc; /* The cycle collector reads the reference count at offset zero. */
+  ScrPromiseIdentity *identity;
   int state;
   bool top_level_handled; /* uncaughtException handled entry evaluation */
   /* Payload (fulfillment value or rejection reason), ScrExcCell-style.
@@ -257,6 +260,7 @@ static void scr_promise_gcfree(void *o) {
   for (size_t i = 0; i < p->ncbs; i++) {
     if (p->cbs[i].all) scr_promise_all_state_release(p->cbs[i].all);
   }
+  if (--p->identity->rc == 0) free(p->identity);
   free(p->waiters);
   free(p->cbs);
 #ifdef SCR_RC_AUDIT
@@ -268,12 +272,26 @@ static void scr_promise_gcfree(void *o) {
 ScrPromise *scr_promise_new(void) {
   ScrPromise *p = scr_cyc_alloc(sizeof *p, &scr_promise_trace, &scr_promise_gcfree);
   p->rc = 1;
+  p->identity = malloc(sizeof *p->identity);
+  if (!p->identity) scr_oom();
+  p->identity->rc = 1;
 #ifdef SCR_RC_AUDIT
   scr_live_promises++;
 #endif
   return p;
 }
 
+void scr_promise_share_identity(ScrPromise *dst, ScrPromise *src) {
+  if (dst->identity == src->identity) return;
+  if (--dst->identity->rc == 0) free(dst->identity);
+  dst->identity = src->identity;
+  dst->identity->rc++;
+}
+
+bool scr_promise_identity_equal(ScrPromise *a, ScrPromise *b) {
+  return a->identity == b->identity;
+}
+
 /* 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 checkpoint
@@ -328,6 +346,7 @@ void scr_promise_release(ScrPromise *p) {
   if (--p->rc == 0) {
     scr_cyc_on_dead(p);
     scr_promise_release_payload(p);
+    if (--p->identity->rc == 0) free(p->identity);
     free(p->waiters);
     for (size_t i = 0; i < p->ncbs; i++) {
       scr_promise_release(p->cbs[i].dst);
@@ -1240,8 +1259,10 @@ static void scr_fiber_finish(ScrFiber *self) {
      * (moved from the fiber's cell into the promise). */
     scr_promise_reject_from_cell(p, &self->exc);
   }
-  /* Fulfillment payload was stored by the trampoline before finishing. */
-  scr_promise_settle_wake(p);
+  /* A returned checked promise may still be resolving after its function
+   * body finishes. Its resolver owns settlement and must not wake awaiters
+   * until adoption completes (WASI continuations cannot park a C stack). */
+  if (p->state != SCR_PROM_PENDING) scr_promise_settle_wake(p);
   self->done = true;
 }
 
@@ -2127,6 +2148,7 @@ void scr_fs_rename_thunk0(ScrClosure *cb, ScrError *err) {
  * the emitted callback adapter. */
 typedef struct ScrCryptoBytesOp {
   ScrBytes *value;
+  ScrError *error;
   ScrClosure *cb;
   ScrCryptoBytesFn fn;
   struct ScrCryptoBytesOp *next;
@@ -2142,6 +2164,7 @@ static void scr_crypto_bytes_shutdown(void) {
     ScrCryptoBytesOp *op = scr_crypto_bytes_head;
     scr_crypto_bytes_head = op->next;
     scr_bytes_release(op->value);
+    scr_error_release(op->error);
     scr_closure_release(op->cb);
     free(op);
   }
@@ -2159,16 +2182,18 @@ static bool scr_crypto_bytes_dispatch(void) {
   scr_crypto_bytes_head = op->next;
   if (scr_crypto_bytes_head == NULL) scr_crypto_bytes_tail = &scr_crypto_bytes_head;
   scr_crypto_bytes_pending_count--;
-  op->fn(op->cb, op->value); /* adapter consumes value */
+  op->fn(op->cb, op->error, op->value); /* adapter consumes value */
+  scr_error_release(op->error);
   scr_closure_release(op->cb);
   free(op);
   return true;
 }
 
-void scr_crypto_defer_bytes(ScrBytes *value, ScrClosure *cb, ScrCryptoBytesFn fn) {
+void scr_crypto_defer_bytes(ScrBytes *value, ScrError *error, ScrClosure *cb, ScrCryptoBytesFn fn) {
   if (!scr_crypto_bytes_cleanup_registered) {
     if (atexit(scr_crypto_bytes_shutdown) != 0) {
       scr_bytes_release(value);
+      scr_error_release(error);
       scr_closure_release(cb);
       scr_trap("scriptc: could not register crypto callback cleanup\n");
     }
@@ -2177,10 +2202,12 @@ void scr_crypto_defer_bytes(ScrBytes *value, ScrClosure *cb, ScrCryptoBytesFn fn
   ScrCryptoBytesOp *op = malloc(sizeof *op);
   if (!op) {
     scr_bytes_release(value);
+    scr_error_release(error);
     scr_closure_release(cb);
     scr_trap("scriptc: out of memory\n");
   }
   op->value = value;
+  op->error = error;
   op->cb = cb;
   op->fn = fn;
   op->next = NULL;
@@ -3298,6 +3325,7 @@ static void scr_gen_exc_move(ScrExcCell *dst, ScrExcCell *src) {
 
 struct ScrGen {
   size_t rc;
+  ScrDyn *receiver;
   ScrFiber *fiber; /* NULL once torn down (done, or unstarted release) */
   int state;
   ScrGenSlot out; /* yielded value / completion value */
@@ -3322,6 +3350,7 @@ static ScrGen *scr_gen_new_common(void (*entry)(ScrFiber *, void *), void *argpa
   ScrGen *g = calloc(1, sizeof *g);
   if (!g) scr_oom();
   g->rc = 1;
+  g->receiver = scr_dyn_this_get();
   g->state = SCR_GEN_UNSTARTED;
   g->drop_args = drop_args;
   g->is_async = settle_async != NULL;
@@ -3368,6 +3397,7 @@ ScrGen *scr_gen_retain(ScrGen *g) {
 
 void scr_gen_release(ScrGen *g) {
   if (!g || --g->rc != 0) return;
+  scr_dyn_release(g->receiver);
   scr_gen_slot_reset(&g->out);
   scr_gen_slot_reset(&g->in);
   scr_gen_slot_reset(&g->ret);
@@ -3399,6 +3429,9 @@ void scr_gen_release_v(void *g) { scr_gen_release((ScrGen *)g); }
 
 bool scr_gen_done(ScrGen *g) { return g->state == SCR_GEN_DONE; }
 ScrGen *scr_gen_of_fiber(ScrFiber *f) { return f->gen; }
+ScrDyn *scr_gen_receiver(void) {
+  return scr_dyn_retain(scr_current && scr_current->gen ? scr_current->gen->receiver : scr_dyn_undefined());
+}
 
 /* Slot setters (release the previous occupant; payloads MOVE in). */
 static void scr_gen_slot_f64(ScrGenSlot *s, double v) {

package/dist/lib/runtime-sources/src/scr_async_dyn.c

@@ -421,6 +421,24 @@ typedef struct {
   ScrDyn *onf, *onr, *onfin; /* owned or NULL */
 } ScrDynThenPack;
 
+typedef struct {
+  ScrPromise *src, *dst;
+  ScrDyn *result;
+} ScrDynFinallyPack;
+
+static void scr_dyn_finally_entry(ScrFiber *self, void *opaque) {
+  (void)self;
+  ScrDynFinallyPack *pack = opaque;
+  ScrDyn *result = scr_await_dyn(pack->result->v.promise);
+  if (scr_exc_pending()) scr_promise_reject_pending(pack->dst);
+  else scr_promise_adapt_copy(pack->dst, pack->src);
+  scr_dyn_release(result);
+  scr_dyn_release(pack->result);
+  scr_promise_release(pack->src);
+  scr_promise_release(pack->dst);
+  free(pack);
+}
+
 static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
   (void)self;
   ScrDynThenPack *a = (ScrDynThenPack *)ap;
@@ -428,7 +446,7 @@ static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
   bool rejected = scr_exc_pending();
   ScrCaught *c = rejected ? scr_exc_take() : NULL;
   ScrDyn *handler = a->onfin ? a->onfin : (rejected ? a->onr : a->onf);
-  if (handler != NULL && handler->kind == SCR_DYN_FUNC) {
+  if (handler != NULL && scr_dyn_is_callable(handler)) {
     ScrDyn *arg = NULL;
     if (a->onfin == NULL) arg = rejected ? scr_caught_to_dyn(c) : scr_dyn_retain(v);
     ScrDyn *r = scr_dyn_call(handler, arg ? &arg : NULL, arg ? 1 : 0, "handler");
@@ -437,30 +455,27 @@ static void scr_dyn_then_entry(ScrFiber *self, void *ap) {
       /* The handler threw: dst rejects with that. */
       scr_promise_reject_pending(a->dst);
     } else if (a->onfin != NULL) {
-      /* finally: the callback's value is dropped and the source
-       * settlement passes through (JS — a finally callback returning a
-       * promise would delay adoption; that refinement waits for a use). */
-      scr_dyn_release(r);
-      if (rejected) {
-        scr_rethrow(c);
-        scr_promise_reject_pending(a->dst);
-      } else {
-        scr_promise_fulfill_ref(a->dst, scr_dyn_retain(v), scr_dyn_retain_v, scr_dyn_release_v, NULL);
+      /* finally returns PromiseResolve(result).then(valueThunk), which
+       * the outer reaction adopts. Even an undefined result takes those
+       * jobs before propagating the original fulfillment or rejection. */
+      if (r->kind != SCR_DYN_PROMISE) {
+        ScrPromise *result = scr_promise_new();
+        scr_promise_fulfill_ref(result, r, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+        r = scr_dyn_new_promise(result);
+        scr_promise_release(result);
       }
+      ScrPromise *passthrough = scr_promise_new();
+      ScrDynFinallyPack *pack = malloc(sizeof *pack);
+      if (!pack) scr_ad_oom();
+      pack->src = scr_promise_retain(a->src);
+      pack->dst = scr_promise_retain(passthrough);
+      pack->result = r;
+      ScrPromise *waiter = scr_async_spawn_after(r->v.promise, scr_dyn_finally_entry, pack);
+      scr_promise_release(waiter);
+      scr_promise_resolve_dyn(a->dst, scr_dyn_new_promise(passthrough));
+      scr_promise_release(passthrough);
     } else {
-      /* Adopt dyn-promise results (JS's resolve walk). */
-      while (r != NULL && r->kind == SCR_DYN_PROMISE) {
-        ScrDyn *inner = scr_await_dyn(r->v.promise);
-        scr_dyn_release(r);
-        r = inner;
-        if (scr_exc_pending()) {
-          scr_promise_reject_pending(a->dst);
-          break;
-        }
-      }
-      if (r != NULL) {
-        scr_promise_fulfill_ref(a->dst, r, scr_dyn_retain_v, scr_dyn_release_v, NULL);
-      }
+      scr_promise_resolve_dyn(a->dst, r);
     }
   } else if (rejected) {
     scr_rethrow(c);
@@ -492,10 +507,75 @@ ScrDyn *scr_dyn_promise_then(ScrPromise *src, ScrDyn *onf, ScrDyn *onr, ScrDyn *
   a->onr = onr ? scr_dyn_retain(onr) : NULL;
   a->onfin = onfin ? scr_dyn_retain(onfin) : NULL;
   ScrDyn *boxed = scr_dyn_new_promise(a->dst);
-  ScrPromise *waiter = scr_async_spawn(scr_dyn_then_entry, a);
+  ScrPromise *waiter = scr_async_spawn_after(src, scr_dyn_then_entry, a);
   scr_promise_release(waiter); /* the entry never rejects; nobody awaits it */
   return boxed;
 }
+typedef struct {
+  ScrPromise *destination;
+  ScrDyn *value;
+} ScrDynResolvePack;
+
+static void scr_dyn_resolve_entry(ScrFiber *self, void *opaque) {
+  (void)self;
+  ScrDynResolvePack *pack = opaque;
+#ifndef __wasi__
+  /* Promise resolution schedules a job before attaching its reaction. */
+  scr_await_hop();
+#endif
+  ScrDyn *value = scr_await_dyn(pack->value->v.promise);
+  if (scr_exc_pending()) scr_promise_reject_pending(pack->destination);
+  else scr_promise_resolve_dyn(pack->destination, value);
+  scr_dyn_release(pack->value);
+  scr_promise_release(pack->destination);
+  free(pack);
+}
+
+#ifdef __wasi__
+static void scr_dyn_resolve_job(ScrClosure *closure) {
+  ScrPromise *destination = scr_box_get_ref(closure->caps[0]);
+  ScrDyn *value = scr_box_get_ref(closure->caps[1]);
+  ScrDynResolvePack *pack = malloc(sizeof *pack);
+  if (!pack) scr_ad_oom();
+  pack->destination = destination;
+  pack->value = value;
+  ScrPromise *waiter = scr_async_spawn_after(value->v.promise, scr_dyn_resolve_entry, pack);
+  scr_promise_release(waiter);
+}
+#endif
+
+/* The destination is borrowed; value moves in. An async function may
+ * return a native promise hidden behind any/unknown without an explicit
+ * await, so its completion must use resolution rather than fulfillment. */
+void scr_promise_resolve_dyn(ScrPromise *destination, ScrDyn *value) {
+  if (value->kind != SCR_DYN_PROMISE) {
+    scr_promise_fulfill_ref(destination, value, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+    return;
+  }
+  if (value->v.promise == destination) {
+    static const char message[] = "Chaining cycle detected for promise #<Promise>";
+    scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    scr_promise_reject_pending(destination);
+    scr_dyn_release(value);
+    return;
+  }
+#ifdef __wasi__
+  ScrClosure *job = scr_closure_new((void *)scr_dyn_resolve_job, 2);
+  job->caps[0] = scr_box_new_obj(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v);
+  scr_box_set_ref(job->caps[0], scr_promise_retain(destination));
+  job->caps[1] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+  scr_box_set_ref(job->caps[1], value);
+  scr_queue_microtask(job);
+#else
+  ScrDynResolvePack *pack = malloc(sizeof *pack);
+  if (!pack) scr_ad_oom();
+  pack->destination = scr_promise_retain(destination);
+  pack->value = value;
+  ScrPromise *waiter = scr_async_spawn(scr_dyn_resolve_entry, pack);
+  scr_promise_release(waiter);
+#endif
+}
+
 /* `await v` where v is a CHECKED-DYNAMIC value: a dyn promise adopts
  * (the boxed promise awaits — rejections re-throw); every other kind is
  * JS's await-of-a-non-thenable — one microtask hop, the value itself
@@ -507,6 +587,13 @@ ScrDyn *scr_await_dyn_value(ScrDyn *v) {
   return scr_dyn_retain(v);
 }
 
+/* The WASI emitter has already suspended on the value's actual promise,
+ * or taken the non-promise microtask hop. Extraction must never suspend a
+ * runtime-authored C frame. */
+ScrDyn *scr_await_dyn_value_settled(ScrDyn *value) {
+  return value->kind == SCR_DYN_PROMISE ? scr_await_dyn(value->v.promise) : scr_dyn_retain(value);
+}
+
 /* ── process warnings (emitWarning + the 'warning' event) ─────────────
  * Gated with the rest of this TU (a deprecation-emitting unit's gate
  * must imply the dynAsync link). Listeners are dyn functions; emission
@@ -597,6 +684,7 @@ void scr_emit_warning(const char *name, const char *code, ScrStr *message) {
   ScrError *e = scr_error_new(SCR_ERR_ERROR, message);
   scr_str_release(e->name);
   e->name = scr_str_new(name ? name : "Warning", strlen(name ? name : "Warning"));
+  e->name_present = true;
   if (code) e->code = scr_str_new(code, strlen(code));
   ScrDyn *w = scr_dyn_from_error(e);
   scr_error_release(e);
@@ -670,6 +758,7 @@ void scr_process_emit_warning(ScrDyn *args) {
   ScrError *e = scr_error_new(SCR_ERR_ERROR, (ScrStr *)warning->v.str);
   scr_str_release(e->name);
   e->name = type ? scr_str_retain((ScrStr *)type) : scr_str_new("Warning", 7);
+  e->name_present = true;
   if (code) e->code = scr_str_retain((ScrStr *)code);
   ScrDyn *w = scr_dyn_from_error(e);
   scr_error_release(e);
@@ -689,22 +778,6 @@ void scr_process_emit_warning(ScrDyn *args) {
  * (SEMANTICS.md 67). Shared by the dc trace choreography, the checked-dynamic tree
  * promise reactions, and the unhandled-rejection dispatch. Borrows the
  * box; result +1. */
-ScrDyn *scr_caught_to_dyn(const ScrCaught *c) {
-  switch (c->kind) {
-  case SCR_EXC_F64: return scr_dyn_new_num(c->f64);
-  case SCR_EXC_BOOL: return scr_dyn_new_bool(c->b);
-  case SCR_EXC_STR: return scr_dyn_new_str((ScrStr *)c->payload);
-  case SCR_EXC_REF:
-  case SCR_EXC_PRIMITIVE_REF:
-    if (c->retain_fn == scr_dyn_retain_v) return scr_dyn_retain((ScrDyn *)c->payload);
-    return scr_dyn_new_obj();
-  case SCR_EXC_OBJ:
-    if (scr_error_is(c->payload)) return scr_dyn_from_error((const ScrError *)c->payload);
-    return scr_dyn_new_obj();
-  default:
-    return scr_dyn_new_obj();
-  }
-}
 
 /* Await a dyn-CROSSING promise (SCR_DYN_PROMISE's boundary contract —
  * dyn or void fulfillment): the payload as a dyn value (+1; a void
@@ -777,7 +850,10 @@ ScrDyn *scr_promise_reason_dyn(const ScrPromise *p) {
  * promise<dyn> directly and every other inner type through the adapting
  * constructor below. */
 
+extern bool (*scr_dyn_promise_identity_fn)(ScrPromise *, ScrPromise *);
+
 ScrDyn *scr_dyn_new_promise(ScrPromise *p) {
+  scr_dyn_promise_identity_fn = scr_promise_identity_equal;
   ScrDyn *d = scr_dyn_alloc_promise(scr_promise_release);
   d->v.promise = scr_promise_retain(p);
   return d;
@@ -792,6 +868,8 @@ ScrDyn *scr_dyn_new_promise(ScrPromise *p) {
 ScrDyn *scr_dyn_new_promise_adapting(ScrPromise *src,
                                      void (*adapt)(ScrPromise *dst, ScrPromise *src)) {
   ScrPromise *dst = scr_promise_new();
+  scr_promise_share_identity(dst, src);
+  scr_dyn_promise_identity_fn = scr_promise_identity_equal;
   scr_promise_race_add(dst, src, adapt);
   ScrDyn *d = scr_dyn_alloc_promise(scr_promise_release);
   d->v.promise = dst; /* the constructor's +1 moves in */
@@ -801,3 +879,93 @@ ScrDyn *scr_dyn_new_promise_adapting(ScrPromise *src,
 ScrPromise *scr_dyn_promise_of(const ScrDyn *d) {
   return d->kind == SCR_DYN_PROMISE ? d->v.promise : NULL;
 }
+
+static void scr_dyn_all_result(ScrPromise *destination, ScrPromise *source) {
+  ScrArr *values = scr_promise_payload_ref(source);
+  ScrDyn *result = scr_dyn_new_arr();
+  for (size_t i = 0; i < values->len; i++) scr_dyn_arr_push(result, scr_arr_get_ref(values, (double)i));
+  scr_arr_release(values);
+  scr_promise_fulfill_ref(destination, result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+}
+
+ScrPromise *scr_dyn_promise_all(const ScrDyn *entries) {
+  ScrArr *promises = scr_arr_new_ref(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v, entries->v.arr.len);
+  ScrArr *values = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, entries->v.arr.len);
+  for (size_t i = 0; i < entries->v.arr.len; i++) {
+    ScrDyn *value = entries->v.arr.items[i];
+    ScrPromise *source;
+    if (value->kind == SCR_DYN_PROMISE) source = scr_promise_retain(value->v.promise);
+    else {
+      source = scr_promise_new();
+      if (value->kind == SCR_DYN_OBJ || value->kind == SCR_DYN_FUNC || value->kind == SCR_DYN_PROXY) {
+        ScrStr *key = scr_str_new("then", 4);
+        ScrDyn *then = value->kind == SCR_DYN_PROXY ? scr_dyn_proxy_get(value, key)
+          : value->kind == SCR_DYN_FUNC ? scr_dyn_fn_get(value, "then", 4) : scr_dyn_obj_read(value, "then", 4);
+        scr_str_release(key);
+        if (then && then->kind == SCR_DYN_FUNC) {
+          static const char message[] = "Promise.all over custom thenables is not supported yet";
+          scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+        }
+        scr_dyn_release(then);
+      }
+      if (scr_exc_pending()) scr_promise_reject_pending(source);
+      else scr_promise_fulfill_ref(source, scr_dyn_retain(value), scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+    }
+    /* Each element contributes a reaction job, even an already fulfilled
+     * plain value. The aggregate preserves input order and Node's hops. */
+    scr_promise_mark_handled(source);
+    ScrDyn *reaction = scr_dyn_promise_then(source, NULL, NULL, NULL);
+    scr_arr_push_ref(promises, scr_promise_retain(reaction->v.promise));
+    scr_dyn_release(reaction);
+    scr_promise_release(source);
+  }
+  ScrPromise *all = scr_promise_all(promises, values, scr_promise_all_store_ref);
+  ScrPromise *result = scr_promise_new();
+  scr_promise_race_add(result, all, scr_dyn_all_result);
+  scr_promise_release(all);
+  scr_arr_release(values);
+  scr_arr_release(promises);
+  return result;
+}
+
+/* The checked native WebCrypto digest entry keeps promise and ArrayBuffer results native. */
+static ScrDyn *scr_crypto_digest_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
+  (void)closure;
+  ScrPromise *promise = scr_promise_new();
+  ScrDyn *algorithm = argc ? args[0] : scr_dyn_undefined();
+  ScrDyn *name = algorithm->kind == SCR_DYN_OBJ ? scr_dyn_obj_read(algorithm, "name", 4) : scr_dyn_retain(algorithm);
+  ScrStr *text = name ? scr_dyn_string_coerce_js(name) : NULL;
+  scr_dyn_release(name);
+  ScrBytes *bytes = argc > 1 && args[1]->kind == SCR_DYN_BYTES ? scr_dyn_bytes_unbox(args[1]) : NULL;
+  if (!bytes && argc > 1 && scr_array_buffer_is(args[1])) bytes = scr_array_buffer_view(SCR_BYTES_U8, args[1], scr_dyn_undefined(), scr_dyn_undefined());
+  const char *native = NULL;
+  if (text) {
+    if (text->len == 7 && strncasecmp(text->data, "SHA-256", 7) == 0) native = "sha256";
+    else if (text->len == 5 && strncasecmp(text->data, "SHA-1", 5) == 0) native = "sha1";
+  }
+  if (!text || !bytes || !native) {
+    static const char message[] = "Unsupported WebCrypto digest algorithm or BufferSource";
+    if (!scr_exc_pending()) scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "SC2020");
+    scr_promise_reject_pending(promise);
+  } else {
+    ScrStr *alg = scr_str_new(native, strlen(native));
+    ScrCryptoHash *hash = scr_crypto_hash_new(alg);
+    scr_str_release(alg);
+    if (hash) {
+      scr_crypto_hash_update_bytes(hash, bytes);
+      ScrBytes *digest = scr_exc_pending() ? NULL : scr_crypto_hash_digest_buffer(hash);
+      scr_crypto_hash_release(hash);
+      if (digest) {
+        ScrDyn *buffer = scr_array_buffer_from_bytes(digest); scr_bytes_release(digest);
+        scr_promise_resolve_dyn(promise, buffer);
+      } else scr_promise_reject_pending(promise);
+    } else scr_promise_reject_pending(promise);
+  }
+  scr_str_release(text); scr_bytes_release(bytes);
+  ScrDyn *result = scr_dyn_new_promise(promise); scr_promise_release(promise); return result;
+}
+ScrDyn *scr_crypto_native(void) {
+  ScrDyn *subtle = scr_dyn_new_obj();
+  scr_dyn_obj_set(subtle, "digest", 6, scr_dyn_new_func(scr_closure_new(NULL, 0), scr_crypto_digest_call, 2, "crypto.subtle.digest", "digest"));
+  ScrDyn *result = scr_dyn_new_obj(); scr_dyn_obj_set(result, "subtle", 6, subtle); return result;
+}

package/dist/lib/runtime-sources/src/scr_bigint.c

@@ -597,6 +597,14 @@ static ScrBigInt *bi_parse_string(ScrStr *s, bool report_error) {
 
 ScrBigInt *scr_bigint_parse(ScrStr *s) { return bi_parse_string(s, true); }
 
+double scr_bigint_cmp_string(ScrBigInt *a, ScrStr *b) {
+  ScrBigInt *parsed = bi_parse_string(b, false);
+  if (!parsed) return 2;
+  double result = scr_bigint_cmp_f64(a, parsed);
+  scr_bigint_release(parsed);
+  return result;
+}
+
 /* Abstract Equality's String/BigInt arm uses StringToBigInt without
  * surfacing its parse failure: an invalid string compares false instead
  * of throwing. BigInt(string) keeps the public throwing parser above. */