@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

package/dist/lib/runtime-sources/src/scr_bytes.test.c

@@ -0,0 +1,85 @@
+#include "scr_runtime.h"
+#include <assert.h>
+#include <math.h>
+#include <string.h>
+
+long scr_bytes_live_count(void);
+
+/* Foreign wrappers may alias without a shared owner and may be unaligned. */
+static ScrBytes *external(uint8_t *data, ScrBytesElem elem, size_t count) {
+  ScrBytes *view = scr_bytes_from_external(data, count * scr_bytes_elem_size(elem));
+  view->elem = elem;
+  view->len = count;
+  return view;
+}
+
+static void external_set(void) {
+  const size_t starts[] = {1, 9, 41, 3001};
+  uint8_t storage[6000], expected[6000];
+  for (ScrBytesElem from = SCR_BYTES_U8; from <= SCR_BYTES_U8C; from++) {
+    for (ScrBytesElem to = SCR_BYTES_U8; to <= SCR_BYTES_U8C; to++) {
+      for (size_t j = 0; j < sizeof starts / sizeof starts[0]; j++) {
+        memset(storage, 0x5a, sizeof storage);
+        ScrBytes *src = external(storage + 9, from, 259);
+        ScrBytes *dst = external(storage + starts[j], to, 263);
+        for (size_t i = 0; i < src->len; i++) scr_bytes_set(src, i, (double)i * 3.5 - 257);
+        memcpy(expected, storage, sizeof storage);
+        ScrBytes *want = external(expected + starts[j], to, 263);
+        for (size_t i = 0; i < src->len; i++) scr_bytes_set(want, i + 2, scr_bytes_get(src, i));
+        scr_bytes_set_from(dst, src, 2);
+        assert(!scr_exc_pending());
+        assert(memcmp(storage, expected, sizeof storage) == 0);
+        scr_bytes_release(want);
+        scr_bytes_release(dst);
+        scr_bytes_release(src);
+      }
+    }
+  }
+}
+
+static void copied_storage(void) {
+  /* Same-kind copies preserve NaN payloads, signed zero and ownership. */
+  const uint64_t bits[] = {UINT64_C(0x7ff8000000000042), UINT64_C(0x8000000000000000),
+                           UINT64_C(0xfff0000000000000)};
+  ScrBytes *src = scr_bytes_new(SCR_BYTES_F64, 3);
+  memcpy(src->data, bits, sizeof bits);
+  ScrBytes *copy = scr_bytes_convert(SCR_BYTES_F64, src);
+  ScrBytes *slice = scr_bytes_slice(src, 0, 3);
+  assert(copy->data != src->data && slice->data != src->data);
+  assert(memcmp(copy->data, bits, sizeof bits) == 0);
+  assert(memcmp(slice->data, bits, sizeof bits) == 0);
+  ScrBytes *view = scr_bytes_subarray(copy, 1, 3);
+  scr_bytes_release(copy);
+  scr_bytes_release(src);
+  assert(memcmp(view->data, bits + 1, sizeof bits - sizeof bits[0]) == 0);
+  scr_bytes_release(view);
+  scr_bytes_release(slice);
+}
+
+static void filled_storage(void) {
+  uint8_t storage[2200], expected[2200];
+  const double values[] = {-0.0, -1.5, 2.5, 255.5, 4294967297.0, NAN, INFINITY};
+  for (ScrBytesElem elem = SCR_BYTES_U8; elem <= SCR_BYTES_U8C; elem++) {
+    for (size_t j = 0; j < sizeof values / sizeof values[0]; j++) {
+      memset(storage, 0xa5, sizeof storage);
+      memcpy(expected, storage, sizeof storage);
+      ScrBytes *dst = external(storage + 1, elem, 263);
+      ScrBytes *want = external(expected + 1, elem, 263);
+      for (size_t i = 2; i < 261; i++) scr_bytes_set(want, i, values[j]);
+      ScrBytes *result = scr_bytes_fill_elem(dst, values[j], 2, 261);
+      assert(result == dst && dst->rc == 2);
+      assert(memcmp(storage, expected, sizeof storage) == 0);
+      scr_bytes_release(result);
+      scr_bytes_release(dst);
+      scr_bytes_release(want);
+    }
+  }
+}
+
+void scr_bytes_test_bulk_storage(void) {
+  long before = scr_bytes_live_count();
+  external_set();
+  copied_storage();
+  filled_storage();
+  assert(scr_bytes_live_count() == before);
+}

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

@@ -35,46 +35,44 @@ static void scr_bytes_io_oom(void) {
   scr_trap("scriptc: out of memory\n");
 }
 
-/* ── fs (the Buffer forms of scr_lib.c's utf8 pair) ────────────────────── */
+static bool scr_fs_read_encoding_valid(ScrStr *encoding) {
+  if (encoding->len == 0 || scr_bytes_is_encoding(encoding)) return true;
+  ScrDyn *value = scr_dyn_new_str(encoding);
+  scr_dyn_arg_value_fail("encoding", "is invalid encoding", value);
+  scr_dyn_release(value);
+  return false;
+}
 
-ScrBytes *scr_fs_read_file_bytes(ScrStr *path) {
-  FILE *f = fopen(path->data, "rb");
-  if (!f) {
-    scr_fs_throw(errno, "open", path);
-    return NULL;
-  }
-  size_t cap = 4096, len = 0;
-  uint8_t *buf = malloc(cap);
-  if (!buf) scr_bytes_io_oom();
-  for (;;) {
-    if (cap - len < 2048) {
-      cap *= 2;
-      uint8_t *grown = realloc(buf, cap);
-      if (!grown) scr_bytes_io_oom();
-      buf = grown;
-    }
-    size_t n = fread(buf + len, 1, cap - len, f);
-    len += n;
-    if (n == 0) break;
-  }
-  if (ferror(f)) {
-    int e = errno;
-    fclose(f);
-    free(buf);
-    scr_fs_throw(e, "read", path);
-    return NULL;
+static ScrStr *scr_fs_decode_read(ScrBytes *bytes, ScrStr *encoding) {
+  if (!bytes) return NULL;
+  ScrStr *text;
+  if (encoding->len == 0) {
+    ScrStr *utf8 = scr_str_new("utf8", 4);
+    text = scr_bytes_to_str(bytes, utf8);
+    scr_str_release(utf8);
+  } else {
+    text = scr_bytes_to_str_checked(bytes, encoding);
   }
-  fclose(f);
-  ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)len);
-  memcpy(b->data, buf, len);
-  free(buf);
-  return b;
+  scr_bytes_release(bytes);
+  return text;
+}
+
+ScrStr *scr_fs_read_file_encoded(ScrStr *path, ScrStr *encoding) {
+  if (!scr_fs_read_encoding_valid(encoding)) return NULL;
+  return scr_fs_decode_read(scr_fs_read_file_bytes(path), encoding);
+}
+
+ScrStr *scr_fs_read_fd_encoded(double fd, ScrStr *encoding) {
+  if (!scr_fs_read_encoding_valid(encoding)) return NULL;
+  return scr_fs_decode_read(scr_fs_read_fd_bytes(fd), encoding);
 }
 
+/* ── fs (the Buffer forms of scr_lib.c's utf8 pair) ────────────────────── */
+
 /* readFileSync's runtime-encoding form (a JS helper's untyped `enc`
  * parameter — test/common fixtures.js): undefined/null answer a Buffer,
- * utf8 answers a string, Node's other real encodings meet the loud
- * not-supported ladder, unknown names throw ERR_UNKNOWN_ENCODING, and an
+ * a supported encoding answers a string, invalid names throw
+ * ERR_INVALID_ARG_VALUE before reading, and an
  * options object dispatches on its `encoding` member (Node's form). +1
  * dyn value, or NULL with the exception pending. */
 ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc) {
@@ -82,7 +80,8 @@ ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc) {
     ScrDyn *ev = scr_dyn_obj_get((ScrDyn *)enc, "encoding", 8); /* borrowed */
     return scr_fs_read_file_sync_dyn(path, ev ? ev : scr_dyn_undefined());
   }
-  if (enc->kind == SCR_DYN_UNDEF || enc->kind == SCR_DYN_NULL) {
+  if (enc->kind == SCR_DYN_UNDEF || enc->kind == SCR_DYN_NULL ||
+      (enc->kind == SCR_DYN_STR && enc->v.str->len == 0)) {
     ScrBytes *b = scr_fs_read_file_bytes(path);
     if (!b) return NULL;
     ScrDyn *d = scr_dyn_new_buffer(b);
@@ -90,32 +89,11 @@ ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc) {
     return d;
   }
   if (enc->kind == SCR_DYN_STR) {
-    const ScrStr *e = enc->v.str;
-    if ((e->len == 4 && memcmp(e->data, "utf8", 4) == 0) ||
-        (e->len == 5 && memcmp(e->data, "utf-8", 5) == 0)) {
-      ScrStr *text = scr_fs_read_file(path);
-      if (!text) return NULL;
-      ScrDyn *d = scr_dyn_new_str(text);
-      scr_str_release(text);
-      return d;
-    }
-    static const char *const known[] = { "ascii", "latin1", "binary", "base64",
-      "base64url", "hex", "ucs2", "ucs-2", "utf16le", "utf-16le", NULL };
-    for (size_t i = 0; known[i]; i++) {
-      if (e->len == strlen(known[i]) && memcmp(e->data, known[i], e->len) == 0) {
-        char msg[128];
-        int n = snprintf(msg, sizeof msg,
-                         "readFileSync with encoding '%s' is not supported yet (only 'utf8' and Buffer reads here)",
-                         known[i]);
-        scr_throw_error_msg(SCR_ERR_ERROR, msg, (size_t)n);
-        return NULL;
-      }
-    }
-    char msg[128];
-    int n = snprintf(msg, sizeof msg, "Unknown encoding: %.*s",
-                     (int)(e->len < 64 ? e->len : 64), e->data);
-    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)n, "ERR_UNKNOWN_ENCODING");
-    return NULL;
+    ScrStr *text = scr_fs_read_file_encoded(path, enc->v.str);
+    if (!text) return NULL;
+    ScrDyn *value = scr_dyn_new_str(text);
+    scr_str_release(text);
+    return value;
   }
   {
     /* Kind rendering stays local: scr_dyn_specific_type lives in the
@@ -127,6 +105,7 @@ ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc) {
 }
 
 static void scr_fs_write_bytes_common(ScrStr *path, const ScrBytes *data, const char *mode) {
+  SCR_BYTES_SNAPSHOT(data);
   FILE *f = fopen(path->data, mode);
   if (!f) {
     scr_fs_throw(errno, "open", path);
@@ -277,7 +256,7 @@ static double scr_fs_cb_open(const ScrStr *path, const ScrDyn *flag, double mode
 static ScrStr *scr_fs_cb_path(const ScrDyn *value, const char *name) {
   if (!scr_fs_path_chk(value, name)) return NULL;
   ScrStr *path = value->kind == SCR_DYN_STR ? scr_str_retain(value->v.str)
-    : scr_str_new((const char *)value->v.bytes->data, value->v.bytes->len);
+    : scr_bytes_string(value->v.bytes, 0, value->v.bytes->len);
   if (memchr(path->data, 0, path->len)) {
     scr_fs_invalid_named_path(value, path, name);
     scr_str_release(path);
@@ -995,11 +974,13 @@ ScrBytes *scr_crypto_random_bytes(double n) {
 /* ── process.stdout/stderr.write(buf) ──────────────────────────────────── */
 
 bool scr_process_stdout_write_bytes(const ScrBytes *b, const ScrStr *encoding) {
+  SCR_BYTES_SNAPSHOT(b);
   (void)encoding;
   return scr_stdio_write(1, b->data, b->len * scr_bytes_elem_size(b->elem));
 }
 
 bool scr_process_stderr_write_bytes(const ScrBytes *b, const ScrStr *encoding) {
+  SCR_BYTES_SNAPSHOT(b);
   (void)encoding;
   return scr_stdio_write(2, b->data, b->len * scr_bytes_elem_size(b->elem));
 }
@@ -1322,7 +1303,7 @@ static void scr_fs_exists_fire(ScrClosure *self) {
     ans = scr_fs_exists(p);
     scr_str_release(p);
   } else if (scr_dyn_bytes_is(path, SCR_BYTES_U8)) {
-    ScrStr *p = scr_str_new((const char *)path->v.bytes->data, path->v.bytes->len);
+    ScrStr *p = scr_bytes_string(path->v.bytes, 0, path->v.bytes->len);
     ans = scr_fs_exists(p);
     scr_str_release(p);
   }
@@ -1471,7 +1452,7 @@ void scr_fs_lchmod_chk(const ScrDyn *path, const ScrDyn *mode, const ScrDyn *cb,
 #ifdef __APPLE__
 static void scr_fs_lchmod_apply(const ScrDyn *path, const ScrDyn *mode) {
   ScrStr *p = path->kind == SCR_DYN_STR ? scr_str_retain(path->v.str)
-                                        : scr_str_new((const char *)path->v.bytes->data, path->v.bytes->len);
+                                        : scr_bytes_string(path->v.bytes, 0, path->v.bytes->len);
   double m = mode->kind == SCR_DYN_NUM ? mode->v.num : (double)strtol(mode->v.str->data, NULL, 8);
   if (lchmod(p->data, (mode_t)m) != 0) scr_fs_throw(errno, "lchmod", p);
   scr_str_release(p);

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

@@ -1261,9 +1261,9 @@ struct ScrChildWriter {
   struct ScrChildWriter *next; /* the service registry (+1) */
 };
 
-static ScrChildStream *scr_child_streams = NULL;
-static size_t scr_child_streams_watching = 0;
-static ScrChildWriter *scr_child_writers = NULL;
+static SCR_TL ScrChildStream *scr_child_streams = NULL;
+static SCR_TL size_t scr_child_streams_watching = 0;
+static SCR_TL ScrChildWriter *scr_child_writers = NULL;
 static bool scr_child_writers_pending(void);
 static void scr_child_writers_service(void);
 static void scr_child_writer_child_settled(ScrChildWriter *w);
@@ -1304,14 +1304,14 @@ struct ScrChild {
   struct ScrChild *next; /* the pending registry */
 };
 
-static ScrChild *scr_children = NULL;
-static ScrChild *scr_children_closing = NULL;
-static size_t scr_children_reffed_n = 0;
+static SCR_TL ScrChild *scr_children = NULL;
+static SCR_TL ScrChild *scr_children_closing = NULL;
+static SCR_TL size_t scr_children_reffed_n = 0;
 /* Pending children the handle wait can NOT represent — spawn failures
  * awaiting their first-pass settle. While any exist, scr_children_wait
  * declines and the loop keeps the ~1ms polling cap (the POSIX arm's
  * unwatched fallback, exactly). */
-static size_t scr_children_unwatched = 0;
+static SCR_TL size_t scr_children_unwatched = 0;
 
 static void scr_child_drop_terminal_listeners(ScrChild *c) {
   scr_child_drop_spawn_listeners(c);
@@ -1685,7 +1685,7 @@ void scr_child_stream_thunk_str(ScrClosure *cb, ScrStr *chunk) {
 
 #define SCR_CHILD_WRITER_HWM 16384
 
-static const char *scr_child_writer_err_code = NULL;
+static SCR_TL const char *scr_child_writer_err_code = NULL;
 
 static void scr_child_writer_drop_zero_listeners(ScrChildWriter *w) {
   for (size_t i = 0; i < w->n_drain; i++) scr_closure_release(w->drain_ls[i].cb);
@@ -1908,6 +1908,7 @@ bool scr_child_writer_write_string(ScrChildWriter *w, const ScrStr *data) {
 }
 
 bool scr_child_writer_write_bytes(ScrChildWriter *w, const ScrBytes *data) {
+  SCR_BYTES_SNAPSHOT(data);
   return scr_child_writer_write(w, data->data, data->len);
 }
 
@@ -2431,12 +2432,12 @@ void scr_child_err_thunk0(ScrClosure *cb, ScrStr *msg) {
   ((void (*)(ScrClosure *))cb->fn)(cb);
 }
 
-static const char *scr_child_err_code = NULL;
+static SCR_TL const char *scr_child_err_code = NULL;
 
 /* The errno name embedded in an errnoException-style message — the
  * POSIX arm's parser, shared story (see its comment). */
 static const char *scr_err_msg_code(const ScrStr *msg) {
-  static char buf[32];
+  static SCR_TL char buf[32];
   const char *sp = strchr((const char *)msg->data, ' ');
   if (sp == NULL || sp[1] != 'E') return NULL;
   const char *tok = sp + 1;
@@ -3541,11 +3542,11 @@ struct ScrChildWriter {
   struct ScrChildWriter *next; /* the service registry (+1) */
 };
 
-static ScrChildStream *scr_child_streams = NULL;
+static SCR_TL ScrChildStream *scr_child_streams = NULL;
 /* Streams with a live consumer (data listener, not yet EOF): the loop's
  * keep-alive and service predicate. */
-static size_t scr_child_streams_watching = 0;
-static ScrChildWriter *scr_child_writers = NULL;
+static SCR_TL size_t scr_child_streams_watching = 0;
+static SCR_TL ScrChildWriter *scr_child_writers = NULL;
 static bool scr_child_writers_pending(void);
 static void scr_child_writers_service(void);
 static void scr_child_writer_child_settled(ScrChildWriter *w);
@@ -3588,18 +3589,18 @@ struct ScrChild {
   struct ScrChild *next; /* the pending registry */
 };
 
-static ScrChild *scr_children = NULL; /* unsettled children (registry +1) */
-static ScrChild *scr_children_closing = NULL; /* exited, waiting for stdio EOF */
-static size_t scr_children_reffed_n = 0; /* unsettled AND reffed (liveness) */
+static SCR_TL ScrChild *scr_children = NULL; /* unsettled children (registry +1) */
+static SCR_TL ScrChild *scr_children_closing = NULL; /* exited, waiting for stdio EOF */
+static SCR_TL size_t scr_children_reffed_n = 0; /* unsettled AND reffed (liveness) */
 
 /* Children the kqueue can NOT wake the loop for (spawn failures awaiting
  * their first-pass settle, exit-filter registration failures, every child
  * on a non-kqueue platform): while any exist, scr_children_wait refuses
  * and the loop keeps the polling cap for them. */
-static size_t scr_children_unwatched = 0;
+static SCR_TL size_t scr_children_unwatched = 0;
 
 #ifdef SCR_HAVE_KQUEUE
-static int scr_child_kq = -1; /* created with the first spawn; lives forever */
+static SCR_TL int scr_child_kq = -1; /* created with the first spawn; lives forever */
 
 /* Arms NOTE_EXIT for a freshly spawned pid. False = the child cannot be
  * watched (it already exited and EVFILT_PROC refuses zombies — the very
@@ -3622,7 +3623,7 @@ static void scr_child_unwatch(pid_t pid) { (void)pid; }
 #endif
 
 #ifdef SCR_CHILD_HAVE_PIDFD
-static int scr_child_ep = -1; /* created with the first spawn; lives forever */
+static SCR_TL int scr_child_ep = -1; /* created with the first spawn; lives forever */
 
 /* pid -> pidfd, so the reap can CLOSE the pidfd (it polls readable from
  * exit until closed — kqueue's ONESHOT drop has no epoll analogue). A
@@ -3632,8 +3633,8 @@ typedef struct {
   int pidfd;
 } ScrChildPidfd;
 
-static ScrChildPidfd *scr_child_pidfds = NULL;
-static size_t scr_child_pidfds_n = 0, scr_child_pidfds_cap = 0;
+static SCR_TL ScrChildPidfd *scr_child_pidfds = NULL;
+static SCR_TL size_t scr_child_pidfds_n = 0, scr_child_pidfds_cap = 0;
 
 /* Arms an exit wakeup for a freshly spawned pid: pidfd_open registered
  * EPOLLIN. False = the child cannot be watched (ENOSYS on pre-5.3
@@ -4225,7 +4226,7 @@ void scr_child_stream_thunk_str(ScrClosure *cb, ScrStr *chunk) {
 
 #define SCR_CHILD_WRITER_HWM 65536
 
-static const char *scr_child_writer_err_code = NULL;
+static SCR_TL const char *scr_child_writer_err_code = NULL;
 
 static void scr_child_writer_drop_zero_listeners(ScrChildWriter *w) {
   for (size_t i = 0; i < w->n_drain; i++) scr_closure_release(w->drain_ls[i].cb);
@@ -4432,6 +4433,7 @@ bool scr_child_writer_write_string(ScrChildWriter *w, const ScrStr *data) {
 }
 
 bool scr_child_writer_write_bytes(ScrChildWriter *w, const ScrBytes *data) {
+  SCR_BYTES_SNAPSHOT(data);
   return scr_child_writer_write(w, data->data, data->len);
 }
 
@@ -4970,6 +4972,22 @@ void scr_children_teardown(void) {
     scr_child_drop_listeners(c);
     scr_child_release(c);
   }
+#ifdef SCR_WORKERS
+  /* Watchers belong to the script context, which can end long before the
+   * process. Release their OS handles and reusable pid index at loop exit. */
+#ifdef SCR_HAVE_KQUEUE
+  if (scr_child_kq >= 0) close(scr_child_kq);
+  scr_child_kq = -1;
+#endif
+#ifdef SCR_CHILD_HAVE_PIDFD
+  for (size_t i = 0; i < scr_child_pidfds_n; i++) close(scr_child_pidfds[i].pidfd);
+  free(scr_child_pidfds);
+  scr_child_pidfds = NULL;
+  scr_child_pidfds_n = scr_child_pidfds_cap = 0;
+  if (scr_child_ep >= 0) close(scr_child_ep);
+  scr_child_ep = -1;
+#endif
+#endif
 }
 
 void scr_child_on_exit(ScrChild *c, ScrClosure *cb /*moves*/, ScrChildExitFn fn) {
@@ -5039,7 +5057,7 @@ void scr_child_err_thunk0(ScrClosure *cb, ScrStr *msg) {
  * Node's `code` on the constructed error (the thunk signature is shared
  * with scr_net.c's error events, which parse theirs out of the message
  * below). NULL outside a spawn-failure settle. */
-static const char *scr_child_err_code = NULL;
+static SCR_TL const char *scr_child_err_code = NULL;
 
 /* [.code on event errors — net/http/dgram parity with spawn failures]
  * The errno name embedded in an errnoException-style message ("connect
@@ -5054,7 +5072,7 @@ static const char *scr_child_err_code = NULL;
  * valid until the next call, or NULL for code-less messages ("socket
  * hang up" stays undefined — divergence 54's documented bound). */
 static const char *scr_err_msg_code(const ScrStr *msg) {
-  static char buf[32];
+  static SCR_TL char buf[32];
   const char *sp = strchr((const char *)msg->data, ' ');
   if (sp == NULL || sp[1] != 'E') return NULL;
   const char *tok = sp + 1;
@@ -5541,10 +5559,10 @@ struct ScrIpc {
   struct ScrIpc *next;
 };
 
-static ScrIpc *scr_ipcs = NULL;
-static ScrIpc *scr_process_ipc = NULL;
-static double scr_process_fork_id = -2;
-static bool scr_ipc_cleanup_registered = false;
+static SCR_TL ScrIpc *scr_ipcs = NULL;
+static SCR_TL ScrIpc *scr_process_ipc = NULL;
+static SCR_TL double scr_process_fork_id = -2;
+static SCR_TL bool scr_ipc_cleanup_registered = false;
 
 static ScrIpc *scr_ipc_retain(ScrIpc *ipc) {
   if (ipc && ipc->rc != SIZE_MAX) ipc->rc++;
@@ -5633,7 +5651,7 @@ static void scr_ipc_stream_data(ScrClosure *closure, ScrBytes *chunk) {
     if (!ipc->buffer) scr_trap("out of memory");
     ipc->buffer_cap = cap;
   }
-  memcpy(ipc->buffer + ipc->buffer_len, chunk->data, chunk->len);
+  scr_bytes_read(chunk, 0, ipc->buffer + ipc->buffer_len, chunk->len);
   ipc->buffer_len = need;
   size_t consumed = 0;
   for (size_t i = 0; i < ipc->buffer_len; i++) {
@@ -5705,7 +5723,7 @@ static ScrIpc *scr_ipc_new(ScrChildStream *reader, ScrChildWriter *writer) {
                             &scr_ipc_writer_error, false);
   if (!scr_ipc_cleanup_registered) {
     scr_ipc_cleanup_registered = true;
-    atexit(scr_ipc_global_cleanup);
+    scr_atexit(scr_ipc_global_cleanup);
   }
   return ipc;
 }

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

@@ -112,15 +112,20 @@ static void scr_box_release_payload(ScrBox *b, void *p) {
   }
 }
 
+static void scr_box_destroy(void *object) {
+  ScrBox *b = object;
+  scr_box_release_payload(b, scr_box_ptr(b));
+#ifdef SCR_RC_AUDIT
+  scr_live_boxes--;
+#endif
+  scr_cyc_free(b);
+}
+
 void scr_box_release(ScrBox *b) {
   if (!b || b->rc == SIZE_MAX) return; /* NULL: a switch jumped past the decl */
   if (--b->rc == 0) {
     scr_cyc_on_dead(b);
-    scr_box_release_payload(b, scr_box_ptr(b));
-#ifdef SCR_RC_AUDIT
-    scr_live_boxes--;
-#endif
-    scr_cyc_free(b);
+    scr_rc_destroy(b, scr_box_destroy);
   } else {
     scr_cyc_on_release(b); /* possible cycle root; may collect — b is done */
   }
@@ -193,16 +198,21 @@ ScrClosure *scr_closure_new(void *fn, size_t ncaps) {
   return c;
 }
 
+static void scr_closure_destroy(void *object) {
+  ScrClosure *c = object;
+  for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
+  scr_box_release(c->props); /* NULL-tolerant */
+#ifdef SCR_RC_AUDIT
+  scr_live_closures--;
+#endif
+  scr_cyc_free(c);
+}
+
 void scr_closure_release(ScrClosure *c) {
   if (!c || c->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
   if (--c->rc == 0) {
     scr_cyc_on_dead(c);
-    for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
-    scr_box_release(c->props); /* NULL-tolerant */
-#ifdef SCR_RC_AUDIT
-    scr_live_closures--;
-#endif
-    scr_cyc_free(c);
+    scr_rc_destroy(c, scr_closure_destroy);
   } else {
     scr_cyc_on_release(c); /* possible cycle root; may collect — c is done */
   }

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

@@ -107,9 +107,12 @@ static void scr_enable_utf8_console_output(void) {
 }
 #endif
 
-void scr_runtime_abi_v6(void) {}
+void scr_runtime_abi_v7(void) {}
 
 void scr_init(void) {
+#ifdef SCR_WORKERS
+  if (scr_context_is_main()) {
+#endif
 #ifdef _WIN32
   /* The CRT opens std streams in TEXT mode, which writes \n as \r\n. Node
    * on Windows does NOT translate — console.log emits \n whether stdout is
@@ -133,16 +136,19 @@ void scr_init(void) {
    * stream immediately. */
   static char outbuf[1 << 16];
   setvbuf(stdout, outbuf, _IOFBF, sizeof outbuf);
+#ifdef SCR_WORKERS
+  }
+#endif
   /* atexit is LIFO; registration order makes exit run: library cleanup
    * (registered later, in scr_lib_init) → cycle collection → RC audit →
    * flush → Windows console-code-page restore. The final collection frees
    * cycles the program dropped, so the audit (and ASan's leak check) see
    * them as freed, not leaked. */
-  atexit(scr_flush_at_exit);
+  scr_atexit(scr_flush_at_exit);
 #ifdef SCR_RC_AUDIT
-  atexit(scr_rc_audit_at_exit);
+  scr_atexit(scr_rc_audit_at_exit);
 #endif
-  atexit(scr_collect_cycles_at_exit);
+  scr_atexit(scr_collect_cycles_at_exit);
 }
 #endif /* !SCR_LIB — a library artifact never touches host stdio modes/buffering and
         * registers no atexit handlers: scr_init and its exit hooks (the
@@ -154,7 +160,7 @@ void scr_init(void) {
  * the stream differs. */
 /* A real definition lets relocatable library links localize this hook;
  * a tentative common symbol stays externally visible on Mach-O. */
-bool (*scr_stdio_write_hook)(int fd, const void *data, size_t len) = NULL;
+SCR_TL bool (*scr_stdio_write_hook)(int fd, const void *data, size_t len) = NULL;
 
 static void scr_console_write(FILE *out, size_t n, const ScrLogArg *args) {
   if (scr_stdio_write_hook) {
@@ -192,6 +198,15 @@ static void scr_console_write(FILE *out, size_t n, const ScrLogArg *args) {
     if (scr_exc_pending()) scr_exc_clear();
     return;
   }
+  /* Formatting a single line uses several libc calls. Hold the stream lock
+   * for that whole chunk so concurrent workers cannot interleave arguments. */
+#ifdef SCR_WORKERS
+#ifdef _WIN32
+  _lock_file(out);
+#else
+  flockfile(out);
+#endif
+#endif
   char numbuf[32];
   for (size_t i = 0; i < n; i++) {
     if (i > 0) fputc(' ', out);
@@ -221,6 +236,13 @@ static void scr_console_write(FILE *out, size_t n, const ScrLogArg *args) {
    * Keep the C buffer only as a formatter coalescing detail: a caller
    * observing a live child must see this line before the next JS turn. */
   fflush(out);
+#ifdef SCR_WORKERS
+#ifdef _WIN32
+  _unlock_file(out);
+#else
+  funlockfile(out);
+#endif
+#endif
 }
 
 void scr_console_log(size_t n, const ScrLogArg *args) {