@scriptc/cli-darwin-arm64 0.2.5 → 0.2.6

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

@@ -1,4 +1,5 @@
 #include "scr_runtime.h"
+#include "scr_key.h"
 
 #include <math.h>
 #include <stdio.h>
@@ -88,17 +89,25 @@ static SCR_TL ScrSidx scr_sidx_sparse_tab[SCR_SIDX_N];
 static SCR_TL ScrSidx scr_sidx_cursor_tab[SCR_SIDX_N];
 static SCR_TL unsigned scr_sidx_sparse_clock;
 static SCR_TL unsigned scr_sidx_cursor_clock;
+static SCR_TL unsigned scr_sidx_sparse_live;
 static SCR_TL bool scr_sidx_cleanup_registered;
+/* Counts both tiers, independent of the wrapping eviction clocks. A transfer
+ * moves one active entry; only clearing or initializing changes the count. */
+static SCR_TL size_t scr_sidx_active;
 
-static void scr_sidx_clear(ScrSidx *e) {
+static void scr_sidx_clear(ScrSidx *e, unsigned *live) {
+  if (e->s) {
+    scr_sidx_active--;
+    if (live) (*live)--;
+  }
   free(e->points);
   memset(e, 0, sizeof(*e));
 }
 
 static void scr_sidx_reset_all(void) {
   for (int i = 0; i < SCR_SIDX_N; i++) {
-    scr_sidx_clear(&scr_sidx_sparse_tab[i]);
-    scr_sidx_clear(&scr_sidx_cursor_tab[i]);
+    scr_sidx_clear(&scr_sidx_sparse_tab[i], &scr_sidx_sparse_live);
+    scr_sidx_clear(&scr_sidx_cursor_tab[i], NULL);
   }
   scr_sidx_sparse_clock = 0;
   scr_sidx_cursor_clock = 0;
@@ -121,6 +130,7 @@ void scr_sidx_test_reset_steps(void) {
 size_t scr_sidx_test_walk_steps(void) { return scr_sidx_walk_steps; }
 size_t scr_sidx_test_searches(void) { return scr_sidx_searches; }
 void scr_sidx_test_reset_cache(void) { scr_sidx_reset_all(); }
+size_t scr_sidx_test_active(void) { return scr_sidx_active; }
 size_t scr_sidx_test_entries(void) {
   size_t n = 0;
   for (int i = 0; i < SCR_SIDX_N; i++)
@@ -140,24 +150,48 @@ size_t scr_sidx_test_points(void) {
 #define SCR_SIDX_SEARCH() ((void)0)
 #endif
 
-static void scr_sidx_purge(const ScrStr *s) {
+/* Share cleanup across release and scratch reuse; callers inline only the
+ * empty-cache check. */
+static __attribute__((noinline)) void scr_sidx_purge_active(const ScrStr *s) {
   /* These are deliberately fixed four-entry tables, never an unbounded
    * receiver registry. Releasing an unrelated temporary therefore does at
    * most eight pointer comparisons and cannot grow with live strings. */
   for (int i = 0; i < SCR_SIDX_N; i++) {
     if (scr_sidx_sparse_tab[i].s == s)
-      scr_sidx_clear(&scr_sidx_sparse_tab[i]);
+      scr_sidx_clear(&scr_sidx_sparse_tab[i], &scr_sidx_sparse_live);
     if (scr_sidx_cursor_tab[i].s == s)
-      scr_sidx_clear(&scr_sidx_cursor_tab[i]);
+      scr_sidx_clear(&scr_sidx_cursor_tab[i], NULL);
   }
 }
 
-static void scr_sidx_init(ScrSidx *e, const ScrStr *s) {
+static void scr_sidx_purge(const ScrStr *s) {
+  if (scr_sidx_active) scr_sidx_purge_active(s);
+}
+
+static void scr_sidx_init(ScrSidx *e, const ScrStr *s, unsigned *live) {
   memset(e, 0, sizeof(*e));
   e->s = s;
+  scr_sidx_active++;
+  if (live) (*live)++;
   e->u16len = SCR_U16_UNKNOWN;
 }
 
+/* Reuse sparse-tier holes left by short-lived receivers before evicting a live index.
+ * Round-robin eviction remains bounded when every slot is occupied. */
+static ScrSidx *scr_sidx_claim(ScrSidx *table, unsigned *clock, unsigned *live) {
+  /* A full tier needs no second slot scan after the failed lookup. */
+  for (size_t offset = 0; *live < SCR_SIDX_N && offset < SCR_SIDX_N; offset++) {
+    size_t index = (*clock + offset) % SCR_SIDX_N;
+    if (!table[index].s) {
+      *clock = (unsigned)(index + 1);
+      return &table[index];
+    }
+  }
+  ScrSidx *entry = &table[(*clock)++ % SCR_SIDX_N];
+  scr_sidx_clear(entry, live);
+  return entry;
+}
+
 /* Short strings retain the historical hot cursor without contending with the
  * sparse residency. Large strings claim only the sparse tier; an in-place
  * append that crosses the threshold moves its exact cursor frontier into
@@ -178,17 +212,14 @@ static ScrSidx *scr_sidx(const ScrStr *s) {
     for (int i = 0; i < SCR_SIDX_N; i++) {
       ScrSidx *old = &scr_sidx_cursor_tab[i];
       if (old->s != s) continue;
-      ScrSidx *e = &scr_sidx_sparse_tab[
-          scr_sidx_sparse_clock++ % SCR_SIDX_N];
-      scr_sidx_clear(e);
+      ScrSidx *e = scr_sidx_claim(scr_sidx_sparse_tab, &scr_sidx_sparse_clock, &scr_sidx_sparse_live);
       *e = *old;
+      scr_sidx_sparse_live++;
       memset(old, 0, sizeof(*old)); /* ownership moved to the sparse tier */
       return e;
     }
-    ScrSidx *e =
-        &scr_sidx_sparse_tab[scr_sidx_sparse_clock++ % SCR_SIDX_N];
-    scr_sidx_clear(e);
-    scr_sidx_init(e, s);
+    ScrSidx *e = scr_sidx_claim(scr_sidx_sparse_tab, &scr_sidx_sparse_clock, &scr_sidx_sparse_live);
+    scr_sidx_init(e, s, &scr_sidx_sparse_live);
     return e;
   }
   ScrSidx *tab = scr_sidx_cursor_tab;
@@ -197,8 +228,8 @@ static ScrSidx *scr_sidx(const ScrStr *s) {
     if (tab[i].s == s) return &tab[i];
   }
   ScrSidx *e = &tab[(*clock)++ % SCR_SIDX_N];
-  scr_sidx_clear(e);
-  scr_sidx_init(e, s);
+  scr_sidx_clear(e, NULL);
+  scr_sidx_init(e, s, NULL);
   return e;
 }
 
@@ -208,6 +239,7 @@ static ScrSidx *scr_sidx(const ScrStr *s) {
  * receiver may move from the cursor tier to the sparse tier on its next
  * lookup, so invalidate either possible entry. */
 static void scr_sidx_concat_append(const ScrStr *s, size_t oldlen) {
+  if (scr_sidx_active == 0) return;
   for (int i = 0; i < SCR_SIDX_N; i++) {
     ScrSidx *entries[] = {&scr_sidx_sparse_tab[i], &scr_sidx_cursor_tab[i]};
     for (size_t j = 0; j < sizeof(entries) / sizeof(entries[0]); j++) {
@@ -381,7 +413,7 @@ ScrStr *scr_str_concat_parts(ScrStr *const *parts, size_t count) {
 }
 
 bool scr_str_eq(ScrStr *a, ScrStr *b) {
-  return a == b || (a->len == b->len && memcmp(a->data, b->data, a->len) == 0);
+  return a == b || (a->len == b->len && scr_key_equal(a->data, b->data, a->len));
 }
 
 int scr_str_cmp(ScrStr *a, ScrStr *b) {
@@ -391,62 +423,29 @@ int scr_str_cmp(ScrStr *a, ScrStr *b) {
   return a->len < b->len ? -1 : (a->len > b->len ? 1 : 0);
 }
 
-/* UTF-16 code-unit comparison over well-formed UTF-8 (the default
- * Array.sort/toSorted and URLSearchParams.sort order). Byte order ALMOST
- * matches — the exception is U+E000..U+FFFF (3-byte UTF-8, single high code
- * units) vs supplementary code points (4-byte UTF-8, surrogate pairs
- * 0xD800..0xDFFF): bytes put the 4-byte form last, code units put it first.
- * Decode code points and compare their leading UTF-16 units. */
-static uint32_t scr_str_lead_u16(const unsigned char *s, size_t len,
-                                size_t *adv) {
-  unsigned char b = s[0];
-  uint32_t cp;
-  size_t n;
-  if (b < 0x80) {
-    cp = b; n = 1;
-  } else if ((b & 0xe0) == 0xc0) {
-    cp = b & 0x1fu; n = 2;
-  } else if ((b & 0xf0) == 0xe0) {
-    cp = b & 0x0fu; n = 3;
-  } else {
-    cp = b & 0x07u; n = 4;
-  }
-  if (n > len) n = len; /* defensive: strings are well-formed by contract */
-  for (size_t i = 1; i < n; i++) cp = (cp << 6) | (s[i] & 0x3fu);
-  *adv = n;
-  if (cp >= 0x10000) return 0xd800 + ((cp - 0x10000) >> 10);
-  return cp;
-}
-
+/* UTF-16 ordering over well-formed UTF-8. Equal bytes can be skipped even
+ * inside a multibyte character: unequal continuation bytes preserve code
+ * point order. Only differing lead bytes for U+E000..U+FFFF versus a
+ * supplementary character reverse byte order, because the latter starts
+ * with a UTF-16 high surrogate below U+E000. */
 int scr_str_cmp_u16(ScrStr *a, ScrStr *b) {
-  size_t ia = 0, ib = 0;
-  while (ia < a->len && ib < b->len) {
-    size_t na, nb;
-    uint32_t ua = scr_str_lead_u16(
-        (const unsigned char *)a->data + ia, a->len - ia, &na);
-    uint32_t ub = scr_str_lead_u16(
-        (const unsigned char *)b->data + ib, b->len - ib, &nb);
-    if (ua != ub) return ua < ub ? -1 : 1;
-    /* Equal leading units: equal whole code points (both single units or
-     * both pairs with equal highs — lows only differ if cps differ). */
-    if (na == 4 && nb == 4) {
-      uint32_t cpa = 0, cpb = 0;
-      for (size_t i = 0; i < 4; i++) {
-        cpa = (cpa << 6) |
-              (i == 0 ? (unsigned char)a->data[ia] & 0x07u
-                      : (unsigned char)a->data[ia + i] & 0x3fu);
-        cpb = (cpb << 6) |
-              (i == 0 ? (unsigned char)b->data[ib] & 0x07u
-                      : (unsigned char)b->data[ib + i] & 0x3fu);
-      }
-      if (cpa != cpb) return cpa < cpb ? -1 : 1;
-    }
-    ia += na;
-    ib += nb;
-  }
-  if (ia < a->len) return 1;
-  if (ib < b->len) return -1;
-  return 0;
+  if (a == b) return 0;
+  size_t common = a->len < b->len ? a->len : b->len;
+  size_t i = 0;
+  while (common - i >= sizeof(uint64_t)) {
+    uint64_t left, right;
+    memcpy(&left, a->data + i, sizeof(left));
+    memcpy(&right, b->data + i, sizeof(right));
+    if (left != right) break;
+    i += sizeof(left);
+  }
+  while (i < common && a->data[i] == b->data[i]) i++;
+  if (i == common) return (a->len > b->len) - (a->len < b->len);
+  unsigned char left = (unsigned char)a->data[i];
+  unsigned char right = (unsigned char)b->data[i];
+  if (left >= 0xf0 && right >= 0xee && right <= 0xef) return -1;
+  if (right >= 0xf0 && left >= 0xee && left <= 0xef) return 1;
+  return left < right ? -1 : 1;
 }
 
 /* ── interned strings ─────────────────────────────────────────────────
@@ -1178,9 +1177,43 @@ ScrStr *scr_str_slice(ScrStr *s, double start, double end) {
   return scr_str_slice_units(s, e, from, to);
 }
 
+void scr_str_slice_range(ScrStr *s, double start, double end, bool substring,
+                         ScrStringSlice *out) {
+  ScrSidx *e = scr_sidx(s);
+  size_t length = scr_sidx_len(s, e);
+  double a = scr_to_integer_or_infinity(start), b = scr_to_integer_or_infinity(end);
+  size_t from, to;
+  if (substring) {
+    from = a <= 0 ? 0 : a >= (double)length ? length : (size_t)a;
+    to = b <= 0 ? 0 : b >= (double)length ? length : (size_t)b;
+    if (from > to) { size_t swap = from; from = to; to = swap; }
+  } else {
+    from = scr_slice_boundary(a, length);
+    to = scr_slice_boundary(b, length);
+  }
+  out->start = from;
+  out->length = to > from ? to - from : 0;
+  out->split = 0;
+  if (out->length) {
+    bool first, last;
+    (void)scr_u16_to_byte_c(s, e, from, &first);
+    (void)scr_u16_to_byte_c(s, e, to, &last);
+    out->split = (first ? 1u : 0u) | (last ? 2u : 0u);
+  }
+}
+
+double scr_str_slice_char_code_at(ScrStr *s, const ScrStringSlice *range, double index) {
+  double unit = scr_to_integer_or_infinity(index);
+  if (!(unit >= 0) || unit >= (double)range->length) return NAN;
+  if ((unit == 0 && (range->split & 1u)) ||
+      (unit == (double)(range->length - 1) && (range->split & 2u))) return 0xFFFD;
+  return scr_str_char_code_at(s, (double)range->start + unit);
+}
+
 static ScrStr *scr_str_slice_units(ScrStr *s, ScrSidx *e,
                                     size_t from, size_t to) {
   if (from >= to) return scr_str_empty();
+  if (from == 0 && to == e->u16len) return scr_str_retain(s);
 
   bool from_mid, to_mid;
   size_t from_b = scr_u16_to_byte_c(s, e, from, &from_mid);
@@ -1190,8 +1223,14 @@ static ScrStr *scr_str_slice_units(ScrStr *s, ScrSidx *e,
   size_t content_b = from_mid ? from_b + 4 : from_b;
   size_t content_len = to_b - content_b;
 
-  if (!from_mid && !to_mid)
-    return scr_str_from_span(s->data + from_b, content_len);
+  if (!from_mid && !to_mid) {
+    ScrStr *result = scr_str_from_span(s->data + from_b, content_len);
+    /* Unit boundaries already prove the exact output length. Preserve it
+     * instead of decoding a potentially megabyte-sized copy on .length.
+     * Index checkpoints remain lazy and owned by the result's cache slot. */
+    if (content_len >= SCR_SIDX_MIN_BYTES) scr_sidx(result)->u16len = to - from;
+    return result;
+  }
 
   /* Divergence: JS would emit the lone surrogate half; we emit U+FFFD. */
   size_t total = content_len + (from_mid ? SCR_REPLACEMENT_LEN : 0) +
@@ -1317,15 +1356,6 @@ static const struct { size_t rc; size_t len; size_t cap; char data[4]; }
 /* Split owns a fresh array and appends only present string values. Fill an
  * available dense slot directly; ordinary push handles growth and the sparse
  * boundary. The array remains valid after every append, including RC audit. */
-static void scr_str_split_append(ScrArr *out, ScrStr *value) {
-  if (out->len < out->cap) {
-    out->data[out->len] = (uint64_t)(uintptr_t)value;
-    out->present[out->len++] = SCR_ARR_VALUE;
-  } else {
-    scr_arr_push_ref(out, value);
-  }
-}
-
 /* split(separator, limit) with a STRING separator (ECMA-262 22.1.3.23):
  * limit is ToUint32'd; zero returns [] and reaching the limit stops before
  * any later separator probes. The no-limit wrapper supplies 2^32-1.
@@ -1338,38 +1368,119 @@ static void scr_str_split_append(ScrArr *out, ScrStr *value) {
  * yield the two lone surrogate halves, each half is U+FFFD here
  * (divergence 2 — the same substitution the island's boundary marshal
  * applied). Borrows both; returns a +1 string[]. */
-ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit_num) {
-  ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
-  uint32_t limit = scr_to_uint32(limit_num);
-  if (limit == 0) return out;
-  if (sep->len == 0) {
-    size_t i = 0;
-    while (i < s->len) {
-      size_t adv;
-      uint32_t cp = scr_utf8_decode(s->data + i, &adv);
-      if (cp >= 0x10000) { /* two units in JS: both halves become U+FFFD */
-        scr_str_split_append(out, scr_str_retain((ScrStr *)&scr_lit_fffd));
-        if (out->len == limit) return out;
-        scr_str_split_append(out, scr_str_retain((ScrStr *)&scr_lit_fffd));
-      } else {
-        scr_str_split_append(out, scr_str_from_span(s->data + i, adv));
-      }
-      if (out->len == limit) return out;
-      i += adv;
+void scr_str_split_cursor_init(ScrSplitCursor *cursor, uint32_t limit) {
+  cursor->offset = 0;
+  cursor->remaining = limit;
+  cursor->pending_unit = 0;
+}
+
+static ScrStr *scr_str_split_piece(const char *bytes, size_t len, ScrStr **scratch) {
+  if (!scratch || len <= 4) return scr_str_from_span(bytes, len);
+  ScrStr *piece = *scratch;
+  if (piece && piece->rc == 1 && piece->cap >= len) {
+    /* The scratch owner is the only remaining reference. Invalidate all
+     * metadata before replacing bytes, just as unique concatenation does. */
+    scr_short_forget(piece);
+    scr_sidx_purge(piece);
+    memcpy(piece->data, bytes, len);
+    piece->len = len;
+    piece->data[len] = '\0';
+  } else {
+    ScrStr *fresh = scr_str_alloc_raw(len, len < 64 ? 64 : len);
+    memcpy(fresh->data, bytes, len);
+    fresh->data[len] = '\0';
+    *scratch = fresh;
+    scr_str_release(piece);
+    piece = fresh;
+  }
+  return scr_str_retain(piece);
+}
+
+/* Both eager and loop consumers use the same boundary state machine.
+ * Eager consumers select the unit/substring path once before their loop. */
+static const char *scr_str_split_span(ScrStr *s, ScrStr *sep,
+                                     ScrSplitCursor *cursor, bool units,
+                                     size_t *len) {
+  if (cursor->remaining == 0 || cursor->offset > s->len) return NULL;
+  if (units) {
+    if (cursor->pending_unit) {
+      cursor->pending_unit = 0;
+      cursor->remaining--;
+      *len = 3;
+      return scr_lit_fffd.data;
     }
-    return out;
-  }
-  size_t start = 0;
+    if (cursor->offset == s->len) return NULL;
+    size_t start = cursor->offset, adv;
+    uint32_t cp = scr_utf8_decode(s->data + start, &adv);
+    cursor->offset += adv;
+    cursor->remaining--;
+    if (cp >= 0x10000) {
+      cursor->pending_unit = 1;
+      *len = 3;
+      return scr_lit_fffd.data;
+    }
+    *len = adv;
+    return s->data + start;
+  }
+  size_t start = cursor->offset;
+  const char *found = scr_byte_find(s->data + start, s->len - start,
+                                    sep->data, sep->len);
+  size_t end = found ? (size_t)(found - s->data) : s->len;
+  /* String allocations reserve the header and terminator, so len + 1
+   * cannot overflow. This sentinel includes a final empty trailing piece. */
+  cursor->offset = found ? end + sep->len : s->len + 1;
+  cursor->remaining--;
+  *len = end - start;
+  return s->data + start;
+}
+
+/* The source snapshot owns these bytes through the current iteration.
+ * A consumer that stores or otherwise exposes the piece materializes it
+ * with ordinary string ownership instead. */
+const char *scr_str_split_cursor_span(ScrStr *s, ScrStr *sep, ScrSplitCursor *cursor,
+                                     size_t *length) {
+  return scr_str_split_span(s, sep, cursor, sep->len == 0, length);
+}
+
+ScrStr *scr_str_split_materialize(const char *bytes, size_t length, ScrStr **scratch) {
+  return scr_str_split_piece(bytes, length, scratch);
+}
+
+ScrStr *scr_str_split_cursor_next(ScrStr *s, ScrStr *sep, ScrSplitCursor *cursor,
+                                  ScrStr **scratch) {
+  size_t len;
+  const char *bytes = scr_str_split_span(s, sep, cursor, sep->len == 0, &len);
+  if (!bytes) return NULL;
+  if (bytes == scr_lit_fffd.data) return scr_str_retain((ScrStr *)&scr_lit_fffd);
+  return scr_str_split_piece(bytes, len, scratch);
+}
+
+/* Move a bounded batch of pieces into array storage in one operation.
+ * This avoids a second separator scan and preserves sparse overflow. */
+static void scr_str_split_fill(ScrArr *out, ScrStr *s, ScrStr *sep,
+                               ScrSplitCursor *cursor, bool units) {
+  uint64_t slots[64];
   for (;;) {
-    const char *found = scr_byte_find(s->data + start, s->len - start,
-                                       sep->data, sep->len);
-    if (!found) break;
-    size_t at = (size_t)(found - s->data);
-    scr_str_split_append(out, scr_str_from_span(s->data + start, at - start));
-    if (out->len == limit) return out;
-    start = at + sep->len;
-  }
-  scr_str_split_append(out, scr_str_from_span(s->data + start, s->len - start));
+    size_t count = 0, len;
+    const char *bytes;
+    while (count < 64 && (bytes = scr_str_split_span(s, sep, cursor, units, &len))) {
+      ScrStr *piece = bytes == scr_lit_fffd.data
+                       ? scr_str_retain((ScrStr *)&scr_lit_fffd)
+                       : scr_str_from_span(bytes, len);
+      slots[count++] = (uint64_t)(uintptr_t)piece;
+    }
+    if (count) scr_arr_push_many(out, count, slots);
+    if (count < 64) return;
+  }
+}
+
+ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit_num) {
+  uint32_t limit = scr_to_uint32(limit_num);
+  ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
+  ScrSplitCursor cursor;
+  scr_str_split_cursor_init(&cursor, limit);
+  if (sep->len == 0) scr_str_split_fill(out, s, sep, &cursor, true);
+  else scr_str_split_fill(out, s, sep, &cursor, false);
   return out;
 }
 

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

@@ -100,19 +100,19 @@ struct ScrTestCtx {
   ScrTestHooks hooks[4]; /* suites and root only */
 };
 
-static ScrTestCtx *scr_test_root = NULL;
+static SCR_TL ScrTestCtx *scr_test_root = NULL;
 /* Where registrations attach: the suite body being collected or the test
  * currently running (its nested test()/t.test() calls are subtests). */
-static ScrTestCtx *scr_test_reg_parent = NULL;
-static bool scr_test_runner_spawned = false;
-static bool scr_test_run_done = false;
-static long scr_test_ct_tests = 0, scr_test_ct_suites = 0, scr_test_ct_pass = 0,
+static SCR_TL ScrTestCtx *scr_test_reg_parent = NULL;
+static SCR_TL bool scr_test_runner_spawned = false;
+static SCR_TL bool scr_test_run_done = false;
+static SCR_TL long scr_test_ct_tests = 0, scr_test_ct_suites = 0, scr_test_ct_pass = 0,
             scr_test_ct_fail = 0, scr_test_ct_skipped = 0, scr_test_ct_todo = 0;
-static double scr_test_t0 = 0;
-static bool scr_test_suite_hook_failed = false;
+static SCR_TL double scr_test_t0 = 0;
+static SCR_TL bool scr_test_suite_hook_failed = false;
 
 #ifdef SCR_RC_AUDIT
-static long scr_testctx_live = 0;
+static SCR_TL long scr_testctx_live = 0;
 long scr_testctx_live_count(void) { return scr_testctx_live; }
 #endif
 

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

@@ -141,9 +141,9 @@ static ssize_t scr_tls_w32_write(int fd, const void *buf, size_t len) {
 
 /* ── the unit RNG (one CTR_DRBG, lazily seeded) ──────────────────────── */
 
-static mbedtls_entropy_context scr_tls_entropy;
-static mbedtls_ctr_drbg_context scr_tls_drbg;
-static bool scr_tls_rng_ready = false;
+static SCR_TL mbedtls_entropy_context scr_tls_entropy;
+static SCR_TL mbedtls_ctr_drbg_context scr_tls_drbg;
+static SCR_TL bool scr_tls_rng_ready = false;
 
 /* Defined with the dyn-member hooks at the tail of this file; registered
  * from rng_init so every TLS entry point installs the TLSSocket member
@@ -206,7 +206,7 @@ struct ScrSecureCtx {
 };
 
 #ifdef SCR_RC_AUDIT
-static long scr_live_secure_ctx = 0;
+static SCR_TL long scr_live_secure_ctx = 0;
 long scr_secure_ctx_live_count(void) { return scr_live_secure_ctx; }
 #endif
 
@@ -345,16 +345,16 @@ typedef struct ScrTlsCli {
  * first (macOS ships it; Alpine links it), then Debian/Ubuntu's
  * ca-certificates.crt, Fedora/RHEL's ca-bundle.crt, and openSUSE's
  * ca-bundle.pem. */
-static mbedtls_x509_crt scr_tls_system_roots;
-static bool scr_tls_system_roots_loaded = false;
+static SCR_TL mbedtls_x509_crt scr_tls_system_roots;
+static SCR_TL bool scr_tls_system_roots_loaded = false;
 
 /* setDefaultCACertificates' replacement anchors (scr_tls_ca.c — always
  * compiled alongside this unit): parsed lazily per generation, so each
  * set re-parses once and every later dial reuses the chain. An EMPTY
  * replacement keeps an initialized, certificate-free chain — every
  * verification fails, Node's own consequence of trusting nothing. */
-static mbedtls_x509_crt scr_tls_override_roots;
-static uint64_t scr_tls_override_parsed_gen = 0;
+static SCR_TL mbedtls_x509_crt scr_tls_override_roots;
+static SCR_TL uint64_t scr_tls_override_parsed_gen = 0;
 
 #ifdef _WIN32
 static void scr_tls_add_windows_ca(void *ctx, const unsigned char *der, size_t len) {
@@ -633,7 +633,7 @@ static void scr_tls_verify_msg(ScrTlsSock *t, char *out, size_t n) {
 /* The socket whose handshake this unit is driving — f_sni's route back
  * to the answered context (single-threaded runtime; set around
  * mbedtls_ssl_handshake). */
-static ScrTlsSock *scr_tls_current = NULL;
+static SCR_TL ScrTlsSock *scr_tls_current = NULL;
 
 /* Defined with the other transport ops below; the answer path needs the
  * table's identity to re-find its engine from the boxed socket. */
@@ -1105,7 +1105,7 @@ static ScrBytes *scr_tls_pem_dyn(const ScrDyn *v, const char *what, bool concat)
     memcpy(b->data, v->v.str->data, v->v.str->len);
     return b;
   }
-  if (scr_dyn_bytes_is(v, SCR_BYTES_U8)) return scr_dyn_bytes_unbox(v);
+  if (scr_dyn_bytes_is(v, SCR_BYTES_U8)) return v->v.bytes->shared ? scr_bytes_copy(v->v.bytes) : scr_dyn_bytes_unbox(v);
   if (v->kind == SCR_DYN_ARR) {
     if (v->v.arr.len == 0) {
       ScrJsonBuf b;
@@ -1138,9 +1138,9 @@ static ScrBytes *scr_tls_pem_dyn(const ScrDyn *v, const char *what, bool concat)
     size_t off = 0;
     for (size_t i = 0; i < v->v.arr.len; i++) {
       const ScrDyn *e = v->v.arr.items[i];
-      const char *p = e->kind == SCR_DYN_STR ? e->v.str->data : (const char *)e->v.bytes->data;
       size_t n = e->kind == SCR_DYN_STR ? e->v.str->len : e->v.bytes->len;
-      memcpy(b->data + off, p, n);
+      if (e->kind == SCR_DYN_STR) memcpy(b->data + off, e->v.str->data, n);
+      else scr_bytes_read(e->v.bytes, 0, b->data + off, n);
       off += n;
       b->data[off++] = '\n'; /* PEM blocks join on line boundaries */
     }

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

@@ -33,16 +33,23 @@
 /* The per-type caches: +1 held here for the process lifetime (an atexit
  * teardown releases them so the RC audit stays clean). 'default' also
  * keeps the concatenated PEM buffer scr_tls.c parses into anchors. */
-static ScrArr *scr_ca_bundled = NULL;
-static ScrArr *scr_ca_system = NULL;
-static ScrArr *scr_ca_extra = NULL;
-static ScrArr *scr_ca_default = NULL;
-static char *scr_ca_extra_buf = NULL;
-static size_t scr_ca_extra_len = 0;
-static bool scr_ca_installed = false;
-static char *scr_ca_override_buf = NULL;
-static size_t scr_ca_override_len = 0;
-static uint64_t scr_ca_override_gen = 0; /* 0 = never set */
+static SCR_TL ScrArr *scr_ca_bundled = NULL;
+static SCR_TL ScrArr *scr_ca_system = NULL;
+static SCR_TL ScrArr *scr_ca_extra = NULL;
+static SCR_TL ScrArr *scr_ca_default = NULL;
+static SCR_TL char *scr_ca_extra_buf = NULL;
+static SCR_TL size_t scr_ca_extra_len = 0;
+static SCR_TL bool scr_ca_installed = false;
+static SCR_TL char *scr_ca_override_buf = NULL;
+static SCR_TL size_t scr_ca_override_len = 0;
+static SCR_TL uint64_t scr_ca_override_gen = 0; /* 0 = never set */
+
+#ifdef SCR_WORKERS
+/* Published during executable startup, before any worker exists. The main
+ * context owns these raw bytes until all its children have been joined. */
+static const char *scr_ca_initial_extra;
+static size_t scr_ca_initial_extra_len;
+#endif
 
 static void scr_ca_oom(void) {
   fputs("scriptc: out of memory\n", stderr);
@@ -62,12 +69,12 @@ static void scr_ca_teardown(void) {
   scr_ca_override_buf = NULL;
 }
 
-static bool scr_ca_teardown_armed = false;
+static SCR_TL bool scr_ca_teardown_armed = false;
 
 static void scr_ca_arm_teardown(void) {
   if (!scr_ca_teardown_armed) {
     scr_ca_teardown_armed = true;
-    atexit(scr_ca_teardown);
+    scr_atexit(scr_ca_teardown);
   }
 }
 
@@ -145,10 +152,25 @@ void scr_tls_ca_install(void) {
   if (scr_ca_installed) return;
   scr_ca_installed = true;
   scr_ca_arm_teardown();
+#ifdef SCR_WORKERS
+  if (!scr_context_is_main()) {
+    if (scr_ca_initial_extra) {
+      scr_ca_extra_len = scr_ca_initial_extra_len;
+      scr_ca_extra_buf = malloc(scr_ca_extra_len + 1);
+      if (!scr_ca_extra_buf) scr_ca_oom();
+      memcpy(scr_ca_extra_buf, scr_ca_initial_extra, scr_ca_extra_len + 1);
+    }
+    return;
+  }
+#endif
   const char *path = getenv("NODE_EXTRA_CA_CERTS");
   if (path != NULL && path[0] != '\0') {
     scr_ca_extra_buf = scr_ca_read_file(path, &scr_ca_extra_len);
   }
+#ifdef SCR_WORKERS
+  scr_ca_initial_extra = scr_ca_extra_buf;
+  scr_ca_initial_extra_len = scr_ca_extra_len;
+#endif
 }
 
 bool scr_tls_ca_extra_pem(const char **pem, size_t *len) {

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

@@ -67,15 +67,20 @@ ScrUnion *scr_union_new_ref(uint32_t tag, void *v, void *(*retain)(void *),
   return u;
 }
 
+static void scr_union_destroy(void *object) {
+  ScrUnion *u = object;
+  if (u->arm_release) u->arm_release(scr_union_peek(u));
+#ifdef SCR_RC_AUDIT
+  scr_live_unions--;
+#endif
+  scr_cyc_free(u);
+}
+
 void scr_union_release(ScrUnion *u) {
   if (!u || u->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
   if (--u->rc == 0) {
     scr_cyc_on_dead(u);
-    if (u->arm_release) u->arm_release(scr_union_peek(u));
-#ifdef SCR_RC_AUDIT
-    scr_live_unions--;
-#endif
-    scr_cyc_free(u);
+    scr_rc_destroy(u, scr_union_destroy);
   } else {
     scr_cyc_on_release(u); /* possible cycle root; may collect — u is done */
   }

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

@@ -184,6 +184,7 @@ static bool util_deep_equal(const ScrDyn *a, const ScrDyn *b, bool skip,
   if (a->kind == SCR_DYN_BYTES) {
     const ScrBytes *x = a->v.bytes, *y = b->v.bytes;
     if (x->elem != y->elem || x->len != y->len) return false;
+    SCR_SHARED_GUARD(x, y);
     size_t length = x->len * scr_bytes_elem_size(x->elem);
     if (length && memcmp(x->data, y->data, length)) return false;
   }