@scriptc/cli-darwin-arm64 0.2.4 → 0.2.6

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

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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();
@@ -455,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);
@@ -498,52 +548,56 @@ ScrArr *scr_arr_new_ref(void *(*elem_retain)(void *),
   return a;
 }
 
-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, 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];
-          a->present[i] = 0;
-          a->data[i] = 0;
-          if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
-        }
-      }
-      while (a->sparse_len > 0) {
-        size_t i = a->sparse_len - 1;
-        uint64_t old = a->sparse[i].slot;
-        uint8_t state = a->sparse[i].state;
-        a->sparse_len = i;
-        if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
-      }
-      while (a->prop_len > 0) {
-        size_t i = a->prop_len - 1;
-        uint64_t old = a->props[i].slot;
-        uint8_t state = a->props[i].state;
-        free(a->props[i].key);
-        a->prop_len = i;
+static void scr_arr_destroy(void *object) {
+  ScrArr *a = object;
+  scr_dyn_release(a->metadata);
+  a->metadata = NULL;
+  if (scr_elem_is_ref(a->elem)) {
+    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];
+        a->present[i] = 0;
+        a->data[i] = 0;
         if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
       }
     }
-    if (a->elem_trace) {
-      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);
+    while (a->sparse_len > 0) {
+      size_t i = a->sparse_len - 1;
+      uint64_t old = a->sparse[i].slot;
+      uint8_t state = a->sparse[i].state;
+      a->sparse_len = i;
+      if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
+    }
+    while (a->prop_len > 0) {
+      size_t i = a->prop_len - 1;
+      uint64_t old = a->props[i].slot;
+      uint8_t state = a->props[i].state;
+      free(a->props[i].key);
+      a->prop_len = i;
+      if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
+    }
+  }
+  if (a->elem_trace) {
+    scr_arr_gc_free(a);
+  } else {
+    free(a->data);
+    free(a->sparse);
+    for (size_t i = 0; i < a->prop_len; i++) free(a->props[i].key);
+    free(a->props);
 #ifdef SCR_RC_AUDIT
-      scr_live_arrays--;
+    scr_live_arrays--;
 #endif
-      scr_weak_dispose(a);
-      free(a);
-    }
+    scr_weak_dispose(a);
+    free(a);
+  }
+}
+
+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_rc_destroy(a, scr_arr_destroy);
   } else if (a->elem_trace) {
     scr_cyc_on_release(a); /* possible cycle root; may collect */
   }
@@ -649,6 +703,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;
@@ -678,6 +742,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
@@ -854,6 +988,10 @@ void *scr_arr_get_ref(ScrArr *a, double i) {
   return p;
 }
 
+void *scr_arr_borrow_ref(ScrArr *a, double i) {
+  return scr_slot_to_ptr(scr_arr_require_slot(a, i));
+}
+
 /* ── writes: i == len appends ──────────────────────────────────────────── */
 
 static void scr_arr_set_slot(ScrArr *a, double i, uint64_t slot) {
@@ -924,10 +1062,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;
@@ -962,6 +1123,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;
@@ -1003,6 +1171,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);
@@ -1030,11 +1206,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++) {
@@ -1064,6 +1275,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++) {
@@ -1113,6 +1337,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);
@@ -1169,6 +1401,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++) {
@@ -1215,6 +1457,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);
@@ -1377,6 +1643,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];
@@ -1396,6 +1666,169 @@ ScrArr *scr_arr_slice(ScrArr *a, double start, double end) {
   return out;
 }
 
+/* Default ordering of primitive arrays cannot call user code. Keep each
+ * payload owned by its source while sorting raw slots, then publish the
+ * complete permutation without per-comparison retains or releases. */
+typedef struct {
+  uint64_t value;
+  char text[32];
+} ScrNumberSortKey;
+
+typedef struct {
+  ScrElemKind kind;
+  const ScrNumberSortKey *numbers;
+} ScrPrimitiveOrder;
+
+static int scr_arr_primitive_compare(uint64_t left, uint64_t right,
+                                      const ScrPrimitiveOrder *order) {
+  if (order->kind == SCR_ELEM_STR)
+    return scr_str_cmp_u16(scr_slot_to_ptr(left), scr_slot_to_ptr(right));
+  if (order->kind == SCR_ELEM_BOOL) return (left > right) - (left < right);
+  return strcmp(order->numbers[left].text, order->numbers[right].text);
+}
+
+/* Natural runs preserve ordered inputs. Reverse strictly descending runs
+ * only, insert after ties, and merge from the left on equality. Allocate
+ * scratch only when there is more than one completed run. */
+static void scr_arr_primitive_order(uint64_t *values, size_t count,
+                                     const ScrPrimitiveOrder *order) {
+  if (count < 2) return;
+  size_t local_runs[64], *runs = local_runs, run_cap = 64, run_count = 1;
+  runs[0] = 0;
+  for (size_t start = 0; start < count;) {
+    size_t end = start + 1;
+    if (end < count) {
+      bool descending = scr_arr_primitive_compare(values[start], values[end], order) > 0;
+      end++;
+      while (end < count &&
+             (scr_arr_primitive_compare(values[end - 1], values[end], order) > 0) == descending)
+        end++;
+      if (descending) {
+        for (size_t left = start, right = end - 1; left < right; left++, right--) {
+          uint64_t value = values[left];
+          values[left] = values[right];
+          values[right] = value;
+        }
+      }
+    }
+    size_t limit = count - start < 16 ? count : start + 16;
+    while (end < limit) {
+      uint64_t value = values[end];
+      size_t low = start, high = end;
+      while (low < high) {
+        size_t mid = low + (high - low) / 2;
+        if (scr_arr_primitive_compare(values[mid], value, order) > 0) high = mid;
+        else low = mid + 1;
+      }
+      memmove(values + low + 1, values + low, (end - low) * sizeof(*values));
+      values[low] = value;
+      end++;
+    }
+    if (run_count == run_cap) {
+      if (run_cap > SIZE_MAX / 2 / sizeof(*runs)) scr_arr_oom();
+      size_t *next = malloc(run_cap * 2 * sizeof(*runs));
+      if (!next) scr_arr_oom();
+      memcpy(next, runs, run_count * sizeof(*runs));
+      if (runs != local_runs) free(runs);
+      runs = next;
+      run_cap *= 2;
+    }
+    runs[run_count++] = end;
+    start = end;
+  }
+  if (run_count > 2) {
+    if (count > SIZE_MAX / sizeof(*values)) scr_arr_oom();
+    uint64_t *scratch = malloc(count * sizeof(*scratch));
+    if (!scratch) scr_arr_oom();
+    uint64_t *src = values, *dst = scratch;
+    while (run_count > 2) {
+      size_t next_run = 1;
+      for (size_t run = 0; run + 1 < run_count; run += 2) {
+        size_t start = runs[run], mid = runs[run + 1];
+        size_t end = run + 2 < run_count ? runs[run + 2] : count;
+        if (mid == end || scr_arr_primitive_compare(src[mid - 1], src[mid], order) <= 0) {
+          memcpy(dst + start, src + start, (end - start) * sizeof(*dst));
+        } else {
+          size_t left = start, right = mid, out = start;
+          while (left < mid && right < end) {
+            dst[out++] = scr_arr_primitive_compare(src[left], src[right], order) > 0
+                ? src[right++] : src[left++];
+          }
+          if (left < mid) memcpy(dst + out, src + left, (mid - left) * sizeof(*dst));
+          else if (right < end) memcpy(dst + out, src + right, (end - right) * sizeof(*dst));
+        }
+        runs[next_run++] = end;
+      }
+      run_count = next_run;
+      uint64_t *swap = src; src = dst; dst = swap;
+    }
+    if (src != values) memcpy(values, src, count * sizeof(*values));
+    free(scratch);
+  }
+  if (runs != local_runs) free(runs);
+}
+
+ScrArr *scr_arr_sort_primitive(ScrArr *a, bool copy) {
+  if (a->elem != SCR_ELEM_STR && a->elem != SCR_ELEM_F64 && a->elem != SCR_ELEM_BOOL)
+    scr_trap("scriptc: invalid primitive array ordering\n");
+  if (a->len == 0) return copy ? scr_arr_new(a->elem, 0) : scr_arr_retain(a);
+  size_t dense = a->len < a->cap ? a->len : a->cap;
+  size_t count = 0, undefined_count = 0;
+  for (size_t i = 0; i < dense; i++) {
+    count += a->present[i] == SCR_ARR_VALUE;
+    undefined_count += a->present[i] == SCR_ARR_UNDEFINED;
+  }
+  for (size_t i = 0; i < a->sparse_len; i++) {
+    count += a->sparse[i].state == SCR_ARR_VALUE;
+    undefined_count += a->sparse[i].state == SCR_ARR_UNDEFINED;
+  }
+  if (count > SIZE_MAX / sizeof(uint64_t)) scr_arr_oom();
+  uint64_t *values = count ? malloc(count * sizeof(*values)) : NULL;
+  if (count && !values) scr_arr_oom();
+  size_t used = 0;
+  for (size_t i = 0; i < dense; i++)
+    if (a->present[i] == SCR_ARR_VALUE) values[used++] = a->data[i];
+  for (size_t i = 0; i < a->sparse_len; i++)
+    if (a->sparse[i].state == SCR_ARR_VALUE) values[used++] = a->sparse[i].slot;
+  ScrNumberSortKey *numbers = NULL;
+  if (a->elem == SCR_ELEM_F64 && count > 1) {
+    if (count > SIZE_MAX / sizeof(*numbers)) scr_arr_oom();
+    numbers = malloc(count * sizeof(*numbers));
+    if (!numbers) scr_arr_oom();
+    for (size_t i = 0; i < count; i++) {
+      numbers[i].value = values[i];
+      scr_f64_to_str(scr_slot_to_f64(values[i]), numbers[i].text);
+      values[i] = i;
+    }
+  }
+  ScrPrimitiveOrder order = {a->elem, numbers};
+  scr_arr_primitive_order(values, count, &order);
+  if (numbers) {
+    for (size_t i = 0; i < count; i++) values[i] = numbers[values[i]].value;
+    free(numbers);
+  }
+  size_t present = copy ? a->len : count + undefined_count;
+  ScrArr *out = copy ? scr_arr_new(a->elem, present) : a;
+  if (copy) out->len = a->len;
+  if (!copy && scr_arr_is_dense(a)) {
+    if (count) memcpy(a->data, values, count * sizeof(*values));
+    memset(a->present, SCR_ARR_VALUE, count);
+    memset(a->present + count, SCR_ARR_UNDEFINED, undefined_count);
+    scr_arr_clear_dense(a, count + undefined_count, a->len - count - undefined_count);
+    if (undefined_count) memset(a->data + count, 0, undefined_count * sizeof(*a->data));
+  } else {
+    ScrArrStorage old = {0};
+    if (!copy) old = scr_arr_take_storage(a);
+    for (size_t i = 0; i < count; i++)
+      scr_arr_store_owned(out, i, copy ? scr_elem_retain_slot(a, values[i]) : values[i]);
+    for (size_t i = count; i < present; i++)
+      scr_arr_store_state_owned(out, i, 0, SCR_ARR_UNDEFINED);
+    if (!copy) scr_arr_free_storage(&old);
+  }
+  free(values);
+  return copy ? out : scr_arr_retain(a);
+}
+
 ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
   size_t cap = 64;
   /* String widths are already known. Size once to avoid growth and copying

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

@@ -361,6 +361,7 @@ void scr_assert_deep_result(bool equal, bool negated, ScrStr *msg, bool has_msg)
  * by construction (the frontend's same-static-type gate), but the elem
  * check stays: a defensive answer beats a miscompare. */
 static bool scr_assert_bytes_content_eq(const ScrBytes *a, const ScrBytes *b) {
+  SCR_SHARED_GUARD(a, b);
   if (a->elem != b->elem || a->len != b->len) return false;
   size_t nbytes = a->len * scr_bytes_elem_size(a->elem);
   return nbytes == 0 || memcmp(a->data, b->data, nbytes) == 0;
@@ -542,8 +543,7 @@ static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
       if (a->buffer != b->buffer) return false; /* the prototype gate */
       const ScrBytes *x = a->v.bytes, *y = b->v.bytes;
       if (x->elem != y->elem || x->len != y->len) return false;
-      size_t nbytes = x->len * scr_bytes_elem_size(x->elem);
-      return nbytes == 0 || memcmp(x->data, y->data, nbytes) == 0;
+      return scr_assert_bytes_content_eq(x, y);
     }
     case SCR_DYN_ARR: {
       if (a->v.arr.len != b->v.arr.len) return false;
@@ -712,7 +712,7 @@ static void scr_assert_cf_value(ScrAssertBuf *b, const ScrDyn *d, size_t indent,
         ab_char(b, '\n');
         scr_assert_cf_pad(b, indent + 2);
         char tmp[40];
-        size_t n = scr_assert_inspect_f64((double)((const unsigned char *)bs->data)[i], tmp);
+        size_t n = scr_assert_inspect_f64(scr_bytes_get(bs, (double)i), tmp);
         ab_bytes(b, tmp, n);
         if (i + 1 < bs->len) ab_char(b, ',');
       }