@scriptc/cli-darwin-arm64 0.2.2 → 0.2.4

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

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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

@@ -434,8 +434,10 @@ 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->metadata) visit(a->metadata, ctx);
+  /* Growth and truncation leave spare capacity empty. Sparse slots and
+   * named properties are separate edges, independent of dense length. */
+  for (size_t i = 0, end = a->len < a->cap ? a->len : a->cap; i < end; i++) {
     if (a->present[i] == SCR_ARR_VALUE) visit(scr_slot_to_ptr(a->data[i]), ctx);
   }
   for (size_t i = 0; i < a->sparse_len; i++) {
@@ -503,7 +505,7 @@ void scr_arr_release(ScrArr *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++) {
+      for (size_t i = 0, end = a->len < a->cap ? a->len : a->cap; i < end; i++) {
         if (a->present[i] != SCR_ARR_HOLE) {
           uint64_t old = a->data[i];
           uint8_t state = a->present[i];
@@ -796,6 +798,11 @@ static bool scr_arr_read_value(const ScrArr *a, double i, uint64_t *slot) {
   return state == SCR_ARR_VALUE;
 }
 
+void *scr_arr_peek_ref(const ScrArr *a, double i) {
+  uint64_t slot;
+  return scr_arr_read_value(a, i, &slot) ? scr_slot_to_ptr(slot) : NULL;
+}
+
 double scr_arr_get_number(const ScrArr *a, double i) {
   /* Keep this hot numeric-only entry self-contained: routing it through
    * scr_arr_read_value adds an out-of-line call at -O2 on native targets. */
@@ -1328,21 +1335,26 @@ bool scr_arr_includes_ref(ScrArr *a, void *v) {
 
 /* ── join ──────────────────────────────────────────────────────────────── */
 
-static void scr_join_append(char **buf, size_t *len, size_t *cap,
-                             const char *bytes, size_t n) {
-  if (*len + n > *cap) {
-    size_t cap2 = *cap;
-    while (*len + n > cap2) {
-      if (cap2 > SIZE_MAX / 2) scr_arr_oom();
-      cap2 *= 2;
-    }
-    char *grown = realloc(*buf, cap2);
-    if (!grown) scr_arr_oom();
-    *buf = grown;
-    *cap = cap2;
+static size_t scr_join_size(size_t len, size_t extra) {
+  if (extra > SIZE_MAX - sizeof(ScrStr) - 1 - len) scr_arr_oom();
+  return len + extra;
+}
+
+/* The builder owns the final string allocation throughout construction.
+ * It has no aliases or index-cache entries, and no user callbacks run while
+ * appending primitive array values. Finish by publishing the terminator. */
+static void scr_join_append(ScrStr **out, const char *bytes, size_t n) {
+  ScrStr *s = *out;
+  size_t need = scr_join_size(s->len, n);
+  if (need > s->cap) {
+    const size_t limit = SIZE_MAX - sizeof(ScrStr) - 1;
+    size_t cap = s->cap;
+    while (cap < need) cap = cap > limit / 2 ? need : cap * 2;
+    s = scr_str_regrow(s, cap);
+    *out = s;
   }
-  memcpy(*buf + *len, bytes, n);
-  *len += n;
+  memcpy(s->data + s->len, bytes, n);
+  s->len = need;
 }
 
 /* `a.slice(start?, end?)` — a fresh shallow copy of the index range,
@@ -1385,11 +1397,24 @@ ScrArr *scr_arr_slice(ScrArr *a, double start, double end) {
 }
 
 ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
-  size_t cap = 64, len = 0;
-  char *buf = malloc(cap);
-  if (!buf) scr_arr_oom();
+  size_t cap = 64;
+  /* String widths are already known. Size once to avoid growth and copying
+   * even when the array holds holes, explicit undefined or sparse slots.
+   * Numeric formatting stays single-pass rather than formatting twice. */
+  if (a->elem == SCR_ELEM_STR) {
+    const size_t limit = SIZE_MAX - sizeof(ScrStr) - 1;
+    if (a->len > 1 && sep->len > limit / (a->len - 1)) scr_arr_oom();
+    cap = a->len > 1 ? (a->len - 1) * sep->len : 0;
+    for (size_t i = 0; i < a->len; i++) {
+      uint64_t slot;
+      if (scr_arr_state_at(a, i, &slot) != SCR_ARR_VALUE) continue;
+      const ScrStr *s = (const ScrStr *)scr_slot_to_ptr(slot);
+      if (s) cap = scr_join_size(cap, s->len);
+    }
+  }
+  ScrStr *out = scr_str_alloc_raw(0, cap);
   for (size_t i = 0; i < a->len; i++) {
-    if (i > 0) scr_join_append(&buf, &len, &cap, sep->data, sep->len);
+    if (i > 0) scr_join_append(&out, sep->data, sep->len);
     uint64_t slot;
     uint8_t state = scr_arr_state_at(a, i, &slot);
     if (state != SCR_ARR_VALUE) continue;
@@ -1397,16 +1422,16 @@ ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
       case SCR_ELEM_F64: {
         char nb[32];
         size_t n = scr_f64_to_str(scr_slot_to_f64(slot), nb);
-        scr_join_append(&buf, &len, &cap, nb, n);
+        scr_join_append(&out, nb, n);
         break;
       }
       case SCR_ELEM_BOOL:
-        if (slot != 0) scr_join_append(&buf, &len, &cap, "true", 4);
-        else scr_join_append(&buf, &len, &cap, "false", 5);
+        if (slot != 0) scr_join_append(&out, "true", 4);
+        else scr_join_append(&out, "false", 5);
         break;
       case SCR_ELEM_STR: {
         const ScrStr *s = (const ScrStr *)scr_slot_to_ptr(slot);
-        if (s) scr_join_append(&buf, &len, &cap, s->data, s->len);
+        if (s) scr_join_append(&out, s->data, s->len);
         break;
       }
       case SCR_ELEM_ARR:
@@ -1416,8 +1441,7 @@ ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
         scr_trap("scriptc: internal error: join on a ref-element array\n");
     }
   }
-  ScrStr *out = scr_str_new(buf, len);
-  free(buf);
+  out->data[out->len] = '\0';
   return out;
 }
 
@@ -1427,25 +1451,22 @@ ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
  * missing ones skip, exactly the spec's loop. Both arrays are
  * SCR_ELEM_STR; borrows both; +1 result. Never throws. */
 ScrStr *scr_str_raw(ScrArr *raw, ScrArr *subs) {
-  size_t cap = 64, len = 0;
-  char *buf = malloc(cap);
-  if (!buf) scr_arr_oom();
+  ScrStr *out = scr_str_alloc_raw(0, 64);
   for (size_t i = 0; i < raw->len; i++) {
     uint64_t raw_slot;
     if (scr_arr_slot_at(raw, i, &raw_slot)) {
       const ScrStr *s = (const ScrStr *)scr_slot_to_ptr(raw_slot);
-      if (s) scr_join_append(&buf, &len, &cap, s->data, s->len);
+      if (s) scr_join_append(&out, s->data, s->len);
     }
     if (i + 1 < raw->len && i < subs->len) {
       uint64_t sub_slot;
       if (scr_arr_slot_at(subs, i, &sub_slot)) {
         const ScrStr *v = (const ScrStr *)scr_slot_to_ptr(sub_slot);
-        if (v) scr_join_append(&buf, &len, &cap, v->data, v->len);
+        if (v) scr_join_append(&out, v->data, v->len);
       }
     }
   }
-  ScrStr *out = scr_str_new(buf, len);
-  free(buf);
+  out->data[out->len] = '\0';
   return out;
 }
 

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

@@ -1481,6 +1481,32 @@ void scr_assert_unwanted_rejection(ScrError *err, ScrStr *msg, bool has_msg) {
   scr_assert_fail_msg(ab_take(&b));
 }
 
+void scr_assert_unwanted_error(ScrStr *actual_message, bool rejection, ScrStr *msg, bool has_msg) {
+  ScrAssertBuf b = {0};
+  ab_cstr(&b, rejection ? "Got unwanted rejection" : "Got unwanted exception");
+  if (has_msg && msg->len) {
+    ab_cstr(&b, ": ");
+    ab_str(&b, msg);
+  } else ab_char(&b, '.');
+  ab_cstr(&b, "\nActual message: \"");
+  ab_str(&b, actual_message);
+  ab_char(&b, '"');
+  scr_assert_fail_msg(ab_take(&b));
+}
+
+/* Node calls validation functions with a fresh object receiver and accepts
+ * only the boolean true. A callback exception remains the pending exception. */
+bool scr_assert_no_error_predicate(ScrDyn *predicate, ScrDyn *actual) {
+  ScrDyn *receiver = scr_dyn_new_obj();
+  scr_dyn_this_push_dyn(receiver);
+  ScrDyn *result = scr_dyn_call(predicate, &actual, 1, "expected");
+  scr_dyn_this_pop();
+  scr_dyn_release(receiver);
+  bool matched = result && result->kind == SCR_DYN_BOOL && result->v.b;
+  scr_dyn_release(result);
+  return matched;
+}
+
 /* ── assert.ifError ───────────────────────────────────────────────────
  * Node throws for ANY value but null/undefined (falsy included); the
  * frontend routes null/undefined to a no-op and everything else here.

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

@@ -1758,6 +1758,50 @@ ScrPromise *scr_fsp_chmod(ScrStr *path, double mode) {
   return scr_promise_settled_void();
 }
 
+ScrPromise *scr_fsp_utimes(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime) {
+  scr_fs_utimes_checked(path, atime, mtime);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_fsp_link(const ScrDyn *existing, const ScrDyn *destination) {
+  scr_fs_link_checked(existing, destination);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_fsp_symlink(const ScrDyn *target, const ScrDyn *destination, const ScrDyn *type) {
+  scr_fs_symlink_promise_checked(target, destination, type);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_fsp_readlink_dyn(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_checked(path, options, true);
+  return scr_promise_settled_ref(result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+}
+
+ScrPromise *scr_fsp_statfs(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_statfs_checked(path, options);
+  return scr_promise_settled_ref(result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v);
+}
+
+ScrPromise *scr_fsp_readlink_str(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_checked(path, options, true);
+  ScrStr *text = result && result->kind == SCR_DYN_STR ? scr_str_retain(result->v.str) : NULL;
+  scr_dyn_release(result);
+  return scr_promise_settled_str(text);
+}
+
+ScrPromise *scr_fsp_readlink_buffer(const ScrDyn *path, const ScrDyn *options) {
+  ScrDyn *result = scr_fs_readlink_checked(path, options, true);
+  ScrBytes *bytes = result ? scr_dyn_bytes_unbox(result) : NULL;
+  scr_dyn_release(result);
+  return scr_promise_settled_ref(bytes, scr_bytes_retain_v, scr_bytes_release_v, NULL);
+}
+
+ScrPromise *scr_fsp_lutimes(const ScrDyn *path, const ScrDyn *atime, const ScrDyn *mtime) {
+  scr_fs_lutimes_checked(path, atime, mtime);
+  return scr_promise_settled_void();
+}
+
 ScrPromise *scr_fsp_readdir(ScrStr *path) {
   ScrArr *names = scr_fs_readdir(path);
   return scr_promise_settled_ref(names, &scr_arr_retain_v, &scr_arr_release_v, NULL);

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

@@ -132,6 +132,21 @@ static int bi_cmp(const ScrBigInt *a, const ScrBigInt *b) {
 }
 
 bool scr_bigint_eq(ScrBigInt *a, ScrBigInt *b) { return bi_cmp(a, b) == 0; }
+
+uint64_t scr_bigint_hash(const ScrBigInt *value) {
+  /* BigInts are immutable and normalized. Ignore capacity and ownership;
+   * equal values made by parsing, arithmetic or conversion hash alike. */
+  uint64_t hash = UINT64_C(0xcbf29ce484222325) ^ (uint64_t)(value->sign + 1);
+  for (size_t i = 0; i < value->len; i++) {
+    hash ^= value->limb[i];
+    hash *= UINT64_C(0x100000001b3);
+  }
+  hash ^= hash >> 30;
+  hash *= UINT64_C(0xbf58476d1ce4e5b9);
+  hash ^= hash >> 27;
+  hash *= UINT64_C(0x94d049bb133111eb);
+  return hash ^ (hash >> 31);
+}
 double scr_bigint_cmp_f64(ScrBigInt *a, ScrBigInt *b) { return (double)bi_cmp(a, b); }
 bool scr_bigint_truthy(ScrBigInt *v) { return v->sign != 0; }