@scriptc/cli-darwin-arm64 0.2.0 → 0.2.1

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

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

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);
@@ -3298,6 +3317,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 +3342,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 +3389,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 +3421,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

@@ -496,6 +496,47 @@ ScrDyn *scr_dyn_promise_then(ScrPromise *src, ScrDyn *onf, ScrDyn *onr, ScrDyn *
   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;
+  /* Promise resolution schedules a job before attaching its reaction. */
+  scr_await_hop();
+  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);
+}
+
+/* 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;
+  }
+  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);
+}
+
 /* `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
@@ -597,6 +638,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 +712,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 +732,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 +804,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 +822,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 +833,45 @@ 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;
 }
+
+/* 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. */