@scriptc/cli-darwin-arm64 0.2.3 → 0.2.5

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

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

@@ -147,10 +147,14 @@ static void scr_arr_grow_dense(ScrArr *a, size_t need) {
     cap *= 2;
   }
   if (cap > SCR_ARR_DENSE_LIMIT) cap = SCR_ARR_DENSE_LIMIT;
-  uint64_t *data = realloc(a->data, cap * sizeof(uint64_t));
+  /* Values and states share one allocation. Move the old states before
+   * publishing the larger capacity: their previous location is now part
+   * of the value area. Existing data and state pointers keep their ABI. */
+  if (cap > SIZE_MAX / (sizeof(uint64_t) + sizeof(uint8_t))) scr_arr_oom();
+  uint64_t *data = realloc(a->data, cap * (sizeof(uint64_t) + sizeof(uint8_t)));
   if (!data) scr_arr_oom();
-  uint8_t *present = realloc(a->present, cap);
-  if (!present) scr_arr_oom();
+  uint8_t *present = (uint8_t *)(data + cap);
+  if (a->cap) memmove(present, (uint8_t *)(data + a->cap), a->cap);
   memset(present + a->cap, 0, cap - a->cap);
   a->data = data;
   a->present = present;
@@ -397,11 +401,58 @@ static ScrArrStorage scr_arr_take_storage(ScrArr *a) {
 
 static void scr_arr_free_storage(ScrArrStorage *s) {
   free(s->data);
-  free(s->present);
   free(s->sparse);
   memset(s, 0, sizeof(*s));
 }
 
+/* Dense storage may still contain holes and explicit undefined. These
+ * operations move ownership with the slots and move the states alongside
+ * them; they never inspect an uninitialized hole payload. */
+static bool scr_arr_is_dense(const ScrArr *a) {
+  return a->len <= a->cap && a->sparse_len == 0;
+}
+
+static void scr_arr_move_dense(ScrArr *a, size_t to, size_t from, size_t count) {
+  if (count == 0) return;
+  memmove(a->data + to, a->data + from, count * sizeof(*a->data));
+  memmove(a->present + to, a->present + from, count);
+}
+
+static void scr_arr_clear_dense(ScrArr *a, size_t from, size_t count) {
+  if (count == 0) return;
+  memset(a->present + from, SCR_ARR_HOLE, count);
+  memset(a->data + from, 0, count * sizeof(*a->data));
+}
+
+/* The destination owns no values in this range. Only retain adapters run
+ * while copying references: no release can collect an intermediate copy.
+ * Self-appends use disjoint ranges after reserving capacity. */
+static void scr_arr_copy_dense(ScrArr *dst, size_t to, const ScrArr *src,
+                                size_t from, size_t count, bool reverse,
+                                bool materialize_holes) {
+  if (count == 0) return;
+  if (!reverse) {
+    memcpy(dst->data + to, src->data + from, count * sizeof(*dst->data));
+    memcpy(dst->present + to, src->present + from, count);
+  } else {
+    for (size_t i = 0; i < count; i++) {
+      size_t source = from + count - i - 1;
+      memcpy(dst->data + to + i, src->data + source, sizeof(*dst->data));
+      dst->present[to + i] = src->present[source];
+    }
+  }
+  bool refs = scr_elem_is_ref(src->elem);
+  if (!refs && !materialize_holes) return;
+  for (size_t i = to; i < to + count; i++) {
+    if (dst->present[i] == SCR_ARR_VALUE) {
+      if (refs) dst->data[i] = scr_elem_retain_slot(src, dst->data[i]);
+    } else if (materialize_holes && dst->present[i] == SCR_ARR_HOLE) {
+      dst->data[i] = 0;
+      dst->present[i] = SCR_ARR_UNDEFINED;
+    }
+  }
+}
+
 ScrArr *scr_arr_new(ScrElemKind elem, size_t initial_cap) {
   ScrArr *a = malloc(sizeof(ScrArr));
   if (!a) scr_arr_oom();
@@ -434,8 +485,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++) {
@@ -453,7 +506,6 @@ void scr_arr_trace_v(void *a0, ScrTraceVisit visit, void *ctx) {
 static void scr_arr_gc_free(void *a0) {
   ScrArr *a = (ScrArr *)a0;
   free(a->data);
-  free(a->present);
   free(a->sparse);
   for (size_t i = 0; i < a->prop_len; i++) free(a->props[i].key);
   free(a->props);
@@ -503,7 +555,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];
@@ -532,7 +584,6 @@ void scr_arr_release(ScrArr *a) {
       scr_arr_gc_free(a);
     } else {
       free(a->data);
-      free(a->present);
       free(a->sparse);
       for (size_t i = 0; i < a->prop_len; i++) free(a->props[i].key);
       free(a->props);
@@ -647,6 +698,16 @@ void scr_arr_copy_range_ex(ScrArr *dst, size_t dst_start, const ScrArr *src,
                            size_t src_start, size_t count, bool reverse,
                            bool materialize_holes) {
   if (count == 0) return;
+  if (src != dst && src_start <= src->cap && count <= src->cap - src_start &&
+      dst_start <= dst->cap && count <= dst->cap - dst_start) {
+    size_t empty = 0;
+    while (empty < count && dst->present[dst_start + empty] == SCR_ARR_HOLE) empty++;
+    if (empty == count) {
+      scr_arr_copy_dense(dst, dst_start, src, src_start, count, reverse,
+                         materialize_holes);
+      return;
+    }
+  }
   size_t end = src_start + count;
   size_t dense_start = src_start < src->cap ? src_start : src->cap;
   size_t dense_end = end < src->cap ? end : src->cap;
@@ -676,6 +737,76 @@ void scr_arr_copy_range_ex(ScrArr *dst, size_t dst_start, const ScrArr *src,
   }
 }
 
+static size_t scr_arr_relative_index(double value, size_t length) {
+  double integer = isnan(value) ? 0 : trunc(value);
+  if (integer < 0) integer += (double)length;
+  return integer <= 0 ? 0 : integer >= (double)length ? length : (size_t)integer;
+}
+
+ScrArr *scr_arr_copy_within(ScrArr *a, double target, double start, double end) {
+  size_t to = scr_arr_relative_index(target, a->len);
+  size_t from = scr_arr_relative_index(start, a->len);
+  size_t last = scr_arr_relative_index(end, a->len);
+  size_t count = last > from ? last - from : 0;
+  if (count > a->len - to) count = a->len - to;
+  if (count == 0 || from == to) return scr_arr_retain(a);
+  if (!scr_elem_is_ref(a->elem) && from < a->cap && count <= a->cap - from &&
+      to < a->cap && count <= a->cap - to) {
+    scr_arr_move_dense(a, to, from, count);
+    return scr_arr_retain(a);
+  }
+  bool backwards = from < to && to - from < count;
+  for (size_t i = 0; i < count; i++) {
+    size_t offset = backwards ? count - i - 1 : i;
+    uint64_t slot = 0;
+    uint8_t state = scr_arr_state_at(a, from + offset, &slot);
+    if (state == SCR_ARR_HOLE) {
+      scr_arr_delete(a, (double)(to + offset));
+    } else {
+      if (state == SCR_ARR_VALUE) slot = scr_elem_retain_slot(a, slot);
+      /* Each replacement publishes its edge before releasing the previous
+       * owner; cycle collection can run between successive positions. */
+      scr_arr_replace_state_owned(a, to + offset, slot, state);
+    }
+  }
+  return scr_arr_retain(a);
+}
+
+static ScrArr *scr_arr_fill_slot(ScrArr *a, uint64_t slot, uint8_t state,
+                                  double start, double end) {
+  size_t from = scr_arr_relative_index(start, a->len);
+  size_t until = scr_arr_relative_index(end, a->len);
+  if (from >= until) return scr_arr_retain(a);
+  bool refs = scr_elem_is_ref(a->elem);
+  if (!refs && until <= SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, until);
+    for (size_t i = from; i < until; i++) a->data[i] = slot;
+    memset(a->present + from, state, until - from);
+  } else {
+    for (size_t i = from; i < until; i++) {
+      uint64_t value = refs && state == SCR_ARR_VALUE ? scr_elem_retain_slot(a, slot) : slot;
+      scr_arr_replace_state_owned(a, i, value, state);
+    }
+  }
+  return scr_arr_retain(a);
+}
+
+ScrArr *scr_arr_fill_f64(ScrArr *a, double value, double start, double end) {
+  return scr_arr_fill_slot(a, scr_slot_from_f64(value), SCR_ARR_VALUE, start, end);
+}
+
+ScrArr *scr_arr_fill_bool(ScrArr *a, bool value, double start, double end) {
+  return scr_arr_fill_slot(a, value ? 1 : 0, SCR_ARR_VALUE, start, end);
+}
+
+ScrArr *scr_arr_fill_ref(ScrArr *a, void *value, double start, double end) {
+  return scr_arr_fill_slot(a, scr_slot_from_ptr(value), SCR_ARR_VALUE, start, end);
+}
+
+ScrArr *scr_arr_fill_undefined(ScrArr *a, double start, double end) {
+  return scr_arr_fill_slot(a, 0, SCR_ARR_UNDEFINED, start, end);
+}
+
 /* ── Math.max/min over one spread number[] ─────────────────────────────
  * The JS fold exactly (ECMA Math.max/min applied to the elements): any
  * NaN poisons the result, +0 beats -0 for max (the reverse for min), and
@@ -922,10 +1053,33 @@ double scr_arr_push_ref(ScrArr *a, void *v) {
   return scr_arr_push_slot(a, scr_slot_from_ptr(v));
 }
 
+double scr_arr_push_many(ScrArr *a, size_t count, const uint64_t *slots) {
+  if (count > SCR_ARR_MAX_LENGTH - a->len) scr_arr_oom();
+  size_t from = a->len, next = from + count;
+  if (next <= SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, next);
+    if (count) {
+      memcpy(a->data + from, slots, count * sizeof(*slots));
+      memset(a->present + from, SCR_ARR_VALUE, count);
+    }
+  } else {
+    for (size_t i = 0; i < count; i++) scr_arr_store_owned(a, from + i, slots[i]);
+  }
+  a->len = next;
+  return (double)next;
+}
+
 double scr_arr_push_spread(ScrArr *a, const ScrArr *src) {
   size_t old_len = a->len;
   size_t add = src->len;
   if (add > SCR_ARR_MAX_LENGTH - old_len) scr_arr_oom();
+  if (scr_arr_is_dense(a) && scr_arr_is_dense(src) &&
+      old_len + add <= SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, old_len + add);
+    scr_arr_copy_dense(a, old_len, src, 0, add, false, true);
+    a->len += add;
+    return (double)a->len;
+  }
   if (src == a) {
     ScrArrStorage old = scr_arr_take_storage(a);
     a->len = 0;
@@ -960,6 +1114,13 @@ double scr_arr_concat_copy(ScrArr *a, const ScrArr *src) {
   size_t old_len = a->len;
   size_t add = src->len;
   if (add > SCR_ARR_MAX_LENGTH - old_len) scr_arr_oom();
+  if (scr_arr_is_dense(a) && scr_arr_is_dense(src) &&
+      old_len + add <= SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, old_len + add);
+    scr_arr_copy_dense(a, old_len, src, 0, add, false, false);
+    a->len += add;
+    return (double)a->len;
+  }
   if (src == a) {
     ScrArrStorage old = scr_arr_take_storage(a);
     a->len = 0;
@@ -1001,6 +1162,14 @@ static double scr_arr_unshift_slot(ScrArr *a, uint64_t slot) {
     scr_arr_trap_oob((double)a->len, a->len);
   }
   size_t old_len = a->len;
+  if (scr_arr_is_dense(a) && old_len < SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, old_len + 1);
+    scr_arr_move_dense(a, 1, 0, old_len);
+    a->data[0] = slot;
+    a->present[0] = SCR_ARR_VALUE;
+    a->len++;
+    return (double)a->len;
+  }
   ScrArrStorage old = scr_arr_take_storage(a);
   a->len = 0;
   scr_arr_store_owned(a, 0, slot);
@@ -1028,11 +1197,46 @@ double scr_arr_unshift_ref(ScrArr *a, void *v) {
   return scr_arr_unshift_slot(a, scr_slot_from_ptr(v));
 }
 
+double scr_arr_unshift_many(ScrArr *a, size_t count, const uint64_t *slots) {
+  size_t old_len = a->len;
+  if (count == 0) return (double)old_len;
+  if (count > SCR_ARR_MAX_LENGTH - old_len) scr_arr_oom();
+  if (scr_arr_is_dense(a) && old_len + count <= SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, old_len + count);
+    scr_arr_move_dense(a, count, 0, old_len);
+    memcpy(a->data, slots, count * sizeof(*slots));
+    memset(a->present, SCR_ARR_VALUE, count);
+  } else {
+    ScrArrStorage old = scr_arr_take_storage(a);
+    for (size_t i = 0; i < count; i++) scr_arr_store_owned(a, i, slots[i]);
+    for (size_t i = 0; i < old.cap; i++) {
+      if (old.present[i] != SCR_ARR_HOLE)
+        scr_arr_store_state_owned(a, i + count, old.data[i], old.present[i]);
+    }
+    for (size_t i = 0; i < old.sparse_len; i++) {
+      scr_arr_store_state_owned(a, old.sparse[i].index + count,
+                                old.sparse[i].slot, old.sparse[i].state);
+    }
+    scr_arr_free_storage(&old);
+  }
+  a->len = old_len + count;
+  return (double)a->len;
+}
+
 double scr_arr_unshift_spread(ScrArr *a, const ScrArr *src) {
   size_t old_len = a->len;
   size_t add = src->len;
   if (add == 0) return (double)old_len;
   if (add > SCR_ARR_MAX_LENGTH - old_len) scr_arr_oom();
+  if (scr_arr_is_dense(a) && scr_arr_is_dense(src) &&
+      old_len + add <= SCR_ARR_DENSE_LIMIT) {
+    scr_arr_grow_dense(a, old_len + add);
+    scr_arr_move_dense(a, add, 0, old_len);
+    /* A self-spread reads the original values at their moved location. */
+    scr_arr_copy_dense(a, 0, src, src == a ? add : 0, add, false, true);
+    a->len += add;
+    return (double)a->len;
+  }
   ScrArrStorage old = scr_arr_take_storage(a);
   a->len = 0;
   for (size_t i = 0; i < add; i++) {
@@ -1062,6 +1266,19 @@ double scr_arr_unshift_spread(ScrArr *a, const ScrArr *src) {
 
 ScrArr *scr_arr_reverse(ScrArr *a) {
   size_t len = a->len;
+  if (scr_arr_is_dense(a)) {
+    for (size_t i = 0; i < len / 2; i++) {
+      size_t j = len - i - 1;
+      uint64_t slot;
+      memcpy(&slot, a->data + i, sizeof slot);
+      memcpy(a->data + i, a->data + j, sizeof slot);
+      memcpy(a->data + j, &slot, sizeof slot);
+      uint8_t state = a->present[i];
+      a->present[i] = a->present[j];
+      a->present[j] = state;
+    }
+    return scr_arr_retain(a);
+  }
   ScrArrStorage old = scr_arr_take_storage(a);
   a->len = len;
   for (size_t i = 0; i < old.cap; i++) {
@@ -1111,6 +1328,14 @@ uint8_t scr_arr_shift_state(ScrArr *a, uint64_t *slot_out) {
   if (slot_out) *slot_out = 0;
   if (a->len == 0) return SCR_ARR_HOLE;
   size_t old_len = a->len;
+  if (scr_arr_is_dense(a)) {
+    uint8_t state = a->present[0];
+    if (slot_out && state == SCR_ARR_VALUE) *slot_out = a->data[0];
+    scr_arr_move_dense(a, 0, 1, old_len - 1);
+    scr_arr_clear_dense(a, old_len - 1, 1);
+    a->len--;
+    return state;
+  }
   ScrArrStorage old = scr_arr_take_storage(a);
   uint64_t s = 0;
   uint8_t state = scr_arr_state_at_storage(&old, 0, &s);
@@ -1167,6 +1392,16 @@ ScrArr *scr_arr_splice(ScrArr *a, double start, double deleteCount) {
           : scr_arr_new(a->elem, n ? n : 1);
   out->len = n;
   size_t old_len = a->len;
+  if (scr_arr_is_dense(a)) {
+    if (n) {
+      memcpy(out->data, a->data + from, n * sizeof(*a->data));
+      memcpy(out->present, a->present + from, n);
+    }
+    scr_arr_move_dense(a, from, from + n, old_len - from - n);
+    scr_arr_clear_dense(a, old_len - n, n);
+    a->len -= n;
+    return out;
+  }
   ScrArrStorage old = scr_arr_take_storage(a);
   a->len = 0;
   for (size_t i = 0; i < old.cap; i++) {
@@ -1213,6 +1448,30 @@ ScrArr *scr_arr_splice_insert(ScrArr *a, double start, double deleteCount,
   double d0 = isnan(deleteCount) ? 0 : trunc(deleteCount);
   size_t n = d0 <= 0 ? 0 : d0 >= avail ? (size_t)avail : (size_t)d0;
   if (items->len > SCR_ARR_MAX_LENGTH - (a->len - n)) scr_arr_oom();
+  size_t add = items->len, next_len = a->len - n + add;
+  if (scr_arr_is_dense(a) && scr_arr_is_dense(items) &&
+      next_len <= SCR_ARR_DENSE_LIMIT) {
+    /* Snapshot an aliased argument before changing the receiver. Ordinary
+     * callers have already materialized variadic arguments, so this copy
+     * is needed only by direct self-spread runtime callers. */
+    ScrArr *snapshot = items == a ? scr_arr_slice(a, 0, INFINITY) : NULL;
+    if (snapshot) items = snapshot;
+    ScrArr *removed = a->elem == SCR_ELEM_REF
+        ? scr_arr_new_ref(a->elem_retain, a->elem_release, a->elem_trace, n)
+        : scr_arr_new(a->elem, n);
+    if (n) {
+      memcpy(removed->data, a->data + from, n * sizeof(*a->data));
+      memcpy(removed->present, a->present + from, n);
+    }
+    removed->len = n;
+    scr_arr_grow_dense(a, next_len);
+    scr_arr_move_dense(a, from + add, from + n, a->len - from - n);
+    scr_arr_copy_dense(a, from, items, 0, add, false, true);
+    if (next_len < a->len) scr_arr_clear_dense(a, next_len, a->len - next_len);
+    a->len = next_len;
+    scr_arr_release(snapshot);
+    return removed;
+  }
   ScrArr *removed = scr_arr_splice(a, start, deleteCount);
   ScrArr *tail = scr_arr_splice(a, (double)from, INFINITY);
   scr_arr_push_spread(a, items);
@@ -1333,21 +1592,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,
@@ -1370,6 +1634,10 @@ ScrArr *scr_arr_slice(ScrArr *a, double start, double end) {
           ? scr_arr_new_ref(a->elem_retain, a->elem_release, a->elem_trace, n ? n : 1)
           : scr_arr_new(a->elem, n ? n : 1);
   out->len = n;
+  if (to <= a->cap) {
+    scr_arr_copy_dense(out, 0, a, from, n, false, false);
+    return out;
+  }
   for (size_t i = 0; i < a->cap && i < to; i++) {
     if (i < from || a->present[i] == SCR_ARR_HOLE) continue;
     uint8_t state = a->present[i];
@@ -1390,11 +1658,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;
@@ -1402,16 +1683,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:
@@ -1421,8 +1702,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;
 }
 
@@ -1432,25 +1712,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_async.test.ts

@@ -14,20 +14,30 @@ test("fiber stacks commit on demand and preserve large frames across suspension"
   try {
     const bin = join(dir, "fiber-stacks");
     await execFileAsync("clang", [
-      "-std=c11", "-O1", "-Wall", "-Wextra", "-Wno-deprecated-declarations",
+      "-std=c11",
+      "-O1",
+      "-Wall",
+      "-Wextra",
+      "-Wno-deprecated-declarations",
       "-pthread",
       ...(sanitize ? ["-fsanitize=address,undefined", "-DSCR_RC_AUDIT"] : []),
       ...(process.platform === "linux" ? ["-D_GNU_SOURCE"] : []),
       join(import.meta.dirname, "scr_async.test.c"),
-      ...EXECUTABLE_RUNTIME_SOURCES
-        .filter((name) => name !== "scr_async.c")
-        .map((name) => join(import.meta.dirname, name)),
+      ...EXECUTABLE_RUNTIME_SOURCES.filter((name) => name !== "scr_async.c").map((name) =>
+        join(import.meta.dirname, name),
+      ),
       ...(process.platform === "linux" ? ["-lm"] : []),
-      "-o", bin,
+      "-o",
+      bin,
     ]);
     const result = await execFileAsync(bin);
     expect(result.stdout).toBe("fiber stacks stay lazy and preserve large suspended frames\n");
-    expect(result.stderr.replace(/^==\d+==WARNING: ASan doesn't fully support makecontext\/swapcontext.*\n/gm, "")).toBe("");
+    expect(
+      result.stderr.replace(
+        /^==\d+==WARNING: ASan doesn't fully support makecontext\/swapcontext.*\n/gm,
+        "",
+      ),
+    ).toBe("");
   } finally {
     await rm(dir, { recursive: true, force: true });
   }

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; }