@scriptc/cli-darwin-x64 0.2.3 → 0.2.4

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

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.3",
+  "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];
@@ -1333,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,
@@ -1390,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;
@@ -1402,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:
@@ -1421,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;
 }
 
@@ -1432,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_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; }
 

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

@@ -9,7 +9,7 @@
  *   markGray     trial-delete: decrement rc once per internal edge;
  *   scan         nodes still rc > 0 are externally referenced — re-blacken
  *                their subgraph and restore the trial decrements;
- *   collectWhite everything left white is a dead cycle: free it, releasing
+ *   gather       filter the scanned white set, then free it, releasing
  *                only edges that LEAVE the white set (each member's
  *                teardown releases its untraced children; traced edges were
  *                already accounted by markGray).
@@ -26,9 +26,10 @@
  *   count was already given up (which would over-decrement and free live
  *   data).
  *
- * Recursion depth equals the traced structure's depth — same property as
- * the existing recursive releases (deep lists recurse deeply; acceptable
- * for now, revisit with an explicit stack if it ever traps).
+ * The main graph phases keep a bounded depth-first walk and defer deeper
+ * traces to reusable worklists. Ordinary RC destruction and cross-generation
+ * releases are separate paths. White candidates are recorded during scan
+ * and filtered after outside roots settle, avoiding a separate gather walk.
  *
  * ── generations ──────────────────────────────────────────────────────
  * A pass costs O(objects reachable from its candidates), and a candidate
@@ -154,6 +155,12 @@ static SCR_TL ScrVec scr_cands;
 /* Nursery survivors awaiting promotion (see scr_scan_black). */
 static SCR_TL ScrVec scr_promote;
 
+/* Deferred traces cap recursive traversal without changing the common
+ * depth-first walk. Restore can run inside scan, so it has its own stack. */
+static SCR_TL ScrVec scr_pending;
+static SCR_TL ScrVec scr_restore_pending;
+#define SCR_CYC_WALK_DEPTH 64
+
 /* The gathered white set (freed after the walk completes). */
 static SCR_TL ScrVec scr_white;
 
@@ -281,14 +288,15 @@ void scr_cyc_on_dead(void *obj) {
 void scr_cyc_on_release(void *obj) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
   h->color = SCR_CYC_PURPLE;
-  if (!h->buffered) {
-    ScrVec *b = &scr_roots[h->gen];
-    if (b->n == b->cap) scr_cyc_grow(b);
-    h->buffered = 1;
-    h->buf_index = b->n;
-    b->v[b->n++] = obj;
-    scr_cyc_nbuffered++;
-  }
+  /* Releasing an existing candidate cannot advance the trigger. A pass
+   * always re-arms after its teardowns, including any candidates they add. */
+  if (h->buffered) return;
+  ScrVec *b = &scr_roots[h->gen];
+  if (b->n == b->cap) scr_cyc_grow(b);
+  h->buffered = 1;
+  h->buf_index = b->n;
+  b->v[b->n++] = obj;
+  scr_cyc_nbuffered++;
   /* Never re-entered: a teardown's releases of untraced children can buffer
    * new candidates mid-collection, but they only wait for the next pass. */
   if (!scr_collecting && scr_cyc_nbuffered >= scr_cyc_trigger)
@@ -306,69 +314,68 @@ void scr_cyc_on_release(void *obj) {
   ((child) == NULL || SCR_RC(child) == SIZE_MAX \
    || scr_cyc_hdr(child)->gen > scr_gen_limit)
 
-static void scr_mark_gray(void *obj);
+/* Trace callbacks forward an integer depth through their opaque context;
+ * it is never dereferenced. The ABI already carries it through every edge. */
+static void scr_mark_gray(void *obj, uintptr_t depth);
 static void scr_mg_visit(void *child, void *ctx) {
-  (void)ctx;
   if (SCR_CYC_SKIP(child)) return;
-  SCR_RC(child) -= 1; /* trial-delete this internal edge */
-  scr_mark_gray(child);
+  SCR_RC(child) -= 1;
+  scr_mark_gray(child, (uintptr_t)ctx);
 }
-static void scr_mark_gray(void *obj) {
+static void scr_mark_gray(void *obj, uintptr_t depth) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
   if (h->color == SCR_CYC_GRAY) return;
   h->color = SCR_CYC_GRAY;
-  h->trace(obj, scr_mg_visit, NULL);
+  if (depth == SCR_CYC_WALK_DEPTH) {
+    scr_cyc_push(&scr_pending, obj);
+    return;
+  }
+  h->trace(obj, scr_mg_visit, (void *)(depth + 1));
 }
 
-static void scr_scan_black(void *obj);
+static void scr_scan_black(void *obj, uintptr_t depth);
 static void scr_sb_visit(void *child, void *ctx) {
-  (void)ctx;
   if (SCR_CYC_SKIP(child)) return;
-  SCR_RC(child) += 1; /* restore the trial decrement */
-  if (scr_cyc_hdr(child)->color != SCR_CYC_BLACK) scr_scan_black(child);
+  SCR_RC(child) += 1;
+  if (scr_cyc_hdr(child)->color != SCR_CYC_BLACK)
+    scr_scan_black(child, (uintptr_t)ctx);
 }
-static void scr_scan_black(void *obj) {
+static void scr_scan_black(void *obj, uintptr_t depth) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
   h->color = SCR_CYC_BLACK;
-  /* Blackening is what proves a walked object survives, so this is where
-   * promotion is decided — but it is only RECORDED here. Raising `gen` now
-   * would hide the object from SCR_CYC_SKIP partway through the pass, and
-   * this phase has trial decrements left to restore. */
-  if (h->gen < SCR_CYC_MATURE)
-    scr_cyc_push(&scr_promote, obj);
-  h->trace(obj, scr_sb_visit, NULL);
+  if (h->gen < SCR_CYC_MATURE) scr_cyc_push(&scr_promote, obj);
+  if (depth == SCR_CYC_WALK_DEPTH) {
+    scr_cyc_push(&scr_restore_pending, obj);
+    return;
+  }
+  h->trace(obj, scr_sb_visit, (void *)(depth + 1));
 }
 
-static void scr_scan(void *obj);
+static void scr_scan(void *obj, uintptr_t depth);
 static void scr_scan_visit(void *child, void *ctx) {
-  (void)ctx;
   if (SCR_CYC_SKIP(child)) return;
-  scr_scan(child);
+  scr_scan(child, (uintptr_t)ctx);
 }
-static void scr_scan(void *obj) {
+static void scr_scan(void *obj, uintptr_t depth) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
   if (h->color != SCR_CYC_GRAY) return;
   if (SCR_RC(obj) > 0) {
-    /* Externally referenced: this whole subgraph stays. */
-    scr_scan_black(obj);
+    scr_scan_black(obj, 0);
+    while (scr_restore_pending.n) {
+      void *next = scr_restore_pending.v[--scr_restore_pending.n];
+      scr_cyc_hdr(next)->trace(next, scr_sb_visit, NULL);
+    }
     return;
   }
   h->color = SCR_CYC_WHITE;
-  h->trace(obj, scr_scan_visit, NULL);
-}
-
-static void scr_collect_white(void *obj);
-static void scr_cw_visit(void *child, void *ctx) {
-  (void)ctx;
-  if (SCR_CYC_SKIP(child)) return;
-  scr_collect_white(child);
-}
-static void scr_collect_white(void *obj) {
-  ScrCycHdr *h = scr_cyc_hdr(obj);
-  if (h->color != SCR_CYC_WHITE || h->buffered) return;
-  h->color = SCR_CYC_DOOMED; /* gathered — don't gather twice */
-  h->trace(obj, scr_cw_visit, NULL);
+  /* Record each whitened object once. A later outside root can restore it;
+   * filter the list only after every scan finishes. No gather trace needed. */
   scr_cyc_push(&scr_white, obj);
+  if (depth == SCR_CYC_WALK_DEPTH) {
+    scr_cyc_push(&scr_pending, obj);
+    return;
+  }
+  h->trace(obj, scr_scan_visit, (void *)(depth + 1));
 }
 
 /* ── cross-generation edges ───────────────────────────────────────────── */
@@ -443,12 +450,10 @@ static size_t scr_cyc_pass(unsigned gen_limit) {
   scr_gen_limit = gen_limit;
 
   /* markRoots: keep live candidates (still purple), drop the rest — an
-   * object re-retained since buffering is black; one grayed by an earlier
-   * candidate's walk is already covered by that candidate's subgraph. The
-   * buffers are drained up front (markGray only touches counts directly,
-   * so nothing can re-buffer underneath us) which leaves collectWhite free
-   * to gather members of an earlier root's cycle. Candidates ABOVE the
-   * limit keep their buffer slots and wait for a full pass. */
+   * object re-retained since buffering is black. Drain the buffers before
+   * walking: tracing only adjusts counts and worklists, so nothing can
+   * re-buffer underneath us. Candidates ABOVE the limit keep their slots
+   * and wait for a full pass. */
   scr_cands.n = 0;
   for (unsigned g = 0; g <= gen_limit; g++) {
     for (size_t i = 0; i < scr_roots[g].n; i++) {
@@ -460,12 +465,31 @@ static size_t scr_cyc_pass(unsigned gen_limit) {
     }
     scr_roots[g].n = 0;
   }
-  for (size_t i = 0; i < scr_cands.n; i++) scr_mark_gray(scr_cands.v[i]);
-
-  for (size_t i = 0; i < scr_cands.n; i++) scr_scan(scr_cands.v[i]);
+  for (size_t i = 0; i < scr_cands.n; i++) scr_mark_gray(scr_cands.v[i], 0);
+  while (scr_pending.n) {
+    void *obj = scr_pending.v[--scr_pending.n];
+    scr_cyc_hdr(obj)->trace(obj, scr_mg_visit, NULL);
+  }
 
   scr_white.n = 0;
-  for (size_t i = 0; i < scr_cands.n; i++) scr_collect_white(scr_cands.v[i]);
+  for (size_t i = 0; i < scr_cands.n; i++) scr_scan(scr_cands.v[i], 0);
+  while (scr_pending.n) {
+    void *obj = scr_pending.v[--scr_pending.n];
+    /* A later outside root may have restored this deferred white node and
+     * its descendants already. Never scan a black node's edges again. */
+    if (scr_cyc_hdr(obj)->color == SCR_CYC_WHITE)
+      scr_cyc_hdr(obj)->trace(obj, scr_scan_visit, NULL);
+  }
+
+  size_t dead = 0;
+  for (size_t i = 0; i < scr_white.n; i++) {
+    void *obj = scr_white.v[i];
+    ScrCycHdr *h = scr_cyc_hdr(obj);
+    if (h->color != SCR_CYC_WHITE) continue;
+    h->color = SCR_CYC_DOOMED;
+    scr_white.v[dead++] = obj;
+  }
+  scr_white.n = dead;
 
   /* Pin the cross-generation targets of everything about to be freed, while
    * `gen` still holds the values the walk filtered on (promotion below is

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

@@ -1039,12 +1039,20 @@ ScrDyn *scr_dyn_undefined(void) {
   return &undef;
 }
 
-ScrDyn *scr_dyn_new_null(void) { return scr_dyn_alloc(SCR_DYN_NULL); }
+/* Primitive nodes have no mutable properties or observable box identity.
+ * As with undefined, SIZE_MAX keeps them out of RC and cycle bookkeeping;
+ * callers retain the ordinary owned-result and ownership-transfer contracts. */
+ScrDyn *scr_dyn_new_null(void) {
+  static ScrDyn value = { .rc = SIZE_MAX, .kind = SCR_DYN_NULL };
+  return &value;
+}
 
 ScrDyn *scr_dyn_new_bool(bool b) {
-  ScrDyn *d = scr_dyn_alloc(SCR_DYN_BOOL);
-  d->v.b = b;
-  return d;
+  static ScrDyn values[2] = {
+    { .rc = SIZE_MAX, .kind = SCR_DYN_BOOL, .v.b = false },
+    { .rc = SIZE_MAX, .kind = SCR_DYN_BOOL, .v.b = true },
+  };
+  return &values[b ? 1 : 0];
 }
 
 ScrDyn *scr_dyn_new_bigint(ScrBigInt *value) {
@@ -6013,19 +6021,15 @@ static ScrDyn *scr_json_value(ScrJsonP *p) {
   }
   if (c == 't') {
     if (!scr_json_lit(p, "true", 4)) return NULL;
-    ScrDyn *d = scr_dyn_alloc(SCR_DYN_BOOL);
-    d->v.b = true;
-    return d;
+    return scr_dyn_new_bool(true);
   }
   if (c == 'f') {
     if (!scr_json_lit(p, "false", 5)) return NULL;
-    ScrDyn *d = scr_dyn_alloc(SCR_DYN_BOOL);
-    d->v.b = false;
-    return d;
+    return scr_dyn_new_bool(false);
   }
   if (c == 'n') {
     if (!scr_json_lit(p, "null", 4)) return NULL;
-    return scr_dyn_alloc(SCR_DYN_NULL);
+    return scr_dyn_new_null();
   }
   if (c == '-' || (c >= '0' && c <= '9')) return scr_json_number(p);
   scr_json_throw_token(p);

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

@@ -7345,33 +7345,62 @@ void *scr_caught_check_obj(const ScrCaught *c, size_t pre, size_t post,
  * walk folded into one call; no user code runs mid-drain, so the
  * live-iteration rules are moot). Borrows the set; the array is +1,
  * string elements retained into it by the iter_key read. */
+static bool scr_set_to_arr_sparse(const ScrMap *s, ScrArr *out) {
+  if (out->cap >= s->nlive) return false;
+  /* Large capacities deliberately use sparse array storage. Keep the
+   * ordinary append path when the allocator declined dense storage. */
+  for (size_t i = 0; i < s->nentries; i++) {
+    if (!s->entries[i].hash) continue;
+    if (out->elem == SCR_ELEM_F64) scr_arr_push_f64(out, scr_map_iter_key_f64(s, (double)i));
+    else if (out->elem == SCR_ELEM_BOOL) scr_arr_push_bool(out, scr_map_iter_key_bool(s, (double)i));
+    else if (out->elem == SCR_ELEM_STR) scr_arr_push_ref(out, scr_map_iter_key_str(s, (double)i));
+    else scr_arr_push_ref(out, scr_map_iter_key_ref(s, (double)i));
+  }
+  return true;
+}
+
 ScrArr *scr_set_to_arr_f64(const ScrMap *s) {
-  size_t n = (size_t)scr_map_iter_count(s);
-  ScrArr *out = scr_arr_new(SCR_ELEM_F64, (size_t)scr_map_size(s));
-  for (size_t i = 0; i < n; i++) {
-    if (!scr_map_iter_live(s, (double)i)) continue;
-    scr_arr_push_f64(out, scr_map_iter_key_f64(s, (double)i));
+  ScrArr *out = scr_arr_new(SCR_ELEM_F64, s->nlive);
+  if (scr_set_to_arr_sparse(s, out)) return out;
+  for (size_t i = 0; i < s->nentries; i++) {
+    if (!s->entries[i].hash) continue;
+    out->data[out->len] = s->entries[i].key;
+    out->present[out->len++] = SCR_ARR_VALUE;
+  }
+  return out;
+}
+
+ScrArr *scr_set_to_arr_bool(const ScrMap *s) {
+  ScrArr *out = scr_arr_new(SCR_ELEM_BOOL, s->nlive);
+  if (scr_set_to_arr_sparse(s, out)) return out;
+  for (size_t i = 0; i < s->nentries; i++) {
+    if (!s->entries[i].hash) continue;
+    out->data[out->len] = s->entries[i].key;
+    out->present[out->len++] = SCR_ARR_VALUE;
   }
   return out;
 }
 
 ScrArr *scr_set_to_arr_str(const ScrMap *s) {
-  size_t n = (size_t)scr_map_iter_count(s);
-  ScrArr *out = scr_arr_new(SCR_ELEM_STR, (size_t)scr_map_size(s));
-  for (size_t i = 0; i < n; i++) {
-    if (!scr_map_iter_live(s, (double)i)) continue;
-    scr_arr_push_ref(out, scr_map_iter_key_str(s, (double)i));
+  ScrArr *out = scr_arr_new(SCR_ELEM_STR, s->nlive);
+  if (scr_set_to_arr_sparse(s, out)) return out;
+  for (size_t i = 0; i < s->nentries; i++) {
+    if (!s->entries[i].hash) continue;
+    scr_str_retain((ScrStr *)(uintptr_t)s->entries[i].key);
+    out->data[out->len] = s->entries[i].key;
+    out->present[out->len++] = SCR_ARR_VALUE;
   }
   return out;
 }
 
 ScrArr *scr_set_to_arr_ref(const ScrMap *s) {
-  size_t n = (size_t)scr_map_iter_count(s);
-  /* The drained array inherits the elements' ownership and cycle edges. */
-  ScrArr *out = scr_arr_new_ref(s->key_retain, s->key_release, s->key_trace, (size_t)scr_map_size(s));
-  for (size_t i = 0; i < n; i++) {
-    if (!scr_map_iter_live(s, (double)i)) continue;
-    scr_arr_push_ref(out, scr_map_iter_key_ref(s, (double)i));
+  ScrArr *out = scr_arr_new_ref(s->key_retain, s->key_release, s->key_trace, s->nlive);
+  if (scr_set_to_arr_sparse(s, out)) return out;
+  for (size_t i = 0; i < s->nentries; i++) {
+    if (!s->entries[i].hash) continue;
+    s->key_retain((void *)(uintptr_t)s->entries[i].key);
+    out->data[out->len] = s->entries[i].key;
+    out->present[out->len++] = SCR_ARR_VALUE;
   }
   return out;
 }