@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

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

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

@@ -148,7 +148,7 @@ static ScrStr *util_style_replace(const ScrStr *text, const char *close,
 }
 
 static bool util_style_env_nonempty(const char *name) {
-  const char *value = getenv(name);
+  const char *value = scr_getenv(name);
   return value && *value;
 }
 
@@ -174,7 +174,7 @@ done:
 /* styleText only needs the color/no-color distinction, rather than the
  * full 4/8/24-bit depth. Follow the ordering of Node 24 internal/tty. */
 static bool util_style_terminal_colors(void) {
-  const char *force = getenv("FORCE_COLOR");
+  const char *force = scr_getenv("FORCE_COLOR");
   if (force) {
     bool enabled = !strcmp(force, "") || !strcmp(force, "true") ||
       !strcmp(force, "1") || !strcmp(force, "2") || !strcmp(force, "3");
@@ -192,21 +192,21 @@ static bool util_style_terminal_colors(void) {
     }
     return enabled;
   }
-  const char *term = getenv("TERM");
+  const char *term = scr_getenv("TERM");
   if (util_style_env_nonempty("NO_COLOR") || util_style_env_nonempty("NODE_DISABLE_COLORS") ||
       (term && !strcmp(term, "dumb"))) return false;
 #ifdef _WIN32
   return true;
 #endif
   if (util_style_env_nonempty("TMUX")) return true;
-  if (getenv("TF_BUILD") && getenv("AGENT_NAME")) return true;
-  if (getenv("CI")) {
+  if (scr_getenv("TF_BUILD") && scr_getenv("AGENT_NAME")) return true;
+  if (scr_getenv("CI")) {
     static const char *const ci[] = { "APPVEYOR", "BUILDKITE", "CIRCLECI", "DRONE", "GITEA_ACTIONS", "GITHUB_ACTIONS", "GITLAB_CI", "TRAVIS" };
-    for (size_t i = 0; i < sizeof ci / sizeof ci[0]; i++) if (getenv(ci[i])) return true;
-    const char *name = getenv("CI_NAME");
+    for (size_t i = 0; i < sizeof ci / sizeof ci[0]; i++) if (scr_getenv(ci[i])) return true;
+    const char *name = scr_getenv("CI_NAME");
     return name && !strcmp(name, "codeship");
   }
-  const char *teamcity = getenv("TEAMCITY_VERSION");
+  const char *teamcity = scr_getenv("TEAMCITY_VERSION");
   if (teamcity) {
     const char *p = teamcity;
     if (!strncmp(p, "9.", 2)) {
@@ -218,10 +218,10 @@ static bool util_style_terminal_colors(void) {
     while (*p >= '0' && *p <= '9') p++;
     return p - teamcity >= 2 && *p == '.';
   }
-  const char *program = getenv("TERM_PROGRAM");
+  const char *program = scr_getenv("TERM_PROGRAM");
   if (program && (!strcmp(program, "iTerm.app") || !strcmp(program, "HyperTerm") ||
                   !strcmp(program, "MacTerm") || !strcmp(program, "Apple_Terminal"))) return true;
-  const char *colorterm = getenv("COLORTERM");
+  const char *colorterm = scr_getenv("COLORTERM");
   if (colorterm && (!strcmp(colorterm, "truecolor") || !strcmp(colorterm, "24bit"))) return true;
   if (term) {
     if (strstr(term, "truecolor") || !strncmp(term, "xterm-256", 9)) return true;
@@ -294,7 +294,7 @@ ScrStr *scr_util_style_text(const ScrDyn *format, const ScrDyn *text, const ScrD
           scr_dyn_arg_type_fail("stream", "an instance of ReadableStream, WritableStream, or Stream", stream); goto done;
         }
       }
-      colorize = getenv("FORCE_COLOR") ? util_style_terminal_colors() :
+      colorize = scr_getenv("FORCE_COLOR") ? util_style_terminal_colors() :
         scr_process_is_tty(fd) && util_style_terminal_colors();
     }
   }

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

@@ -121,11 +121,11 @@ struct ScrWatcher {
   struct ScrWatcher *next; /* the open-watcher registry (+1 each) */
 };
 
-static ScrWatcher *scr_watchers = NULL;
-static size_t scr_watchers_open = 0; /* liveness: open (unclosed) watchers */
+static SCR_TL ScrWatcher *scr_watchers = NULL;
+static SCR_TL size_t scr_watchers_open = 0; /* liveness: open (unclosed) watchers */
 
 #ifdef SCR_HAVE_KQUEUE
-static int scr_watch_kq = -1; /* created with the first watch; lives forever */
+static SCR_TL int scr_watch_kq = -1; /* created with the first watch; lives forever */
 
 /* Arms the vnode filter for a watcher's current fd. EV_CLEAR: state resets
  * at delivery, so an unserviced event never busy-spins the idle poll (the
@@ -145,7 +145,7 @@ static bool scr_watch_arm(ScrWatcher *w) {
 #endif
 
 #ifdef SCR_HAVE_INOTIFY
-static int scr_watch_ino = -1; /* created with the first watch; lives forever */
+static SCR_TL int scr_watch_ino = -1; /* created with the first watch */
 
 /* libuv's subscription mask: name-level events for directory watches,
  * self events for the file case, IN_IGNORED arriving for free. */
@@ -557,12 +557,22 @@ static void scr_watch_cleanup_atexit(void) {
     scr_watcher_drop_listeners(w);
     scr_watcher_release(w);
   }
+#ifdef SCR_WORKERS
+#ifdef SCR_HAVE_KQUEUE
+  if (scr_watch_kq >= 0) close(scr_watch_kq);
+  scr_watch_kq = -1;
+#endif
+#ifdef SCR_HAVE_INOTIFY
+  if (scr_watch_ino >= 0) close(scr_watch_ino);
+  scr_watch_ino = -1;
+#endif
+#endif
 }
 
 void scr_watch_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_watch_cleanup_atexit);
+  scr_atexit(scr_watch_cleanup_atexit);
   scr_loop_set_watch(&scr_watch_pending, &scr_watch_dispatch, &scr_watch_pollfd);
 }

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

@@ -0,0 +1,232 @@
+#include "scr_worker.h"
+
+#ifdef SCR_WORKERS
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <limits.h>
+#ifdef _WIN32
+#include <process.h>
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+struct ScrWorkerThread {
+  atomic_size_t references;
+  atomic_bool cancel;
+  atomic_bool port_closed;
+  uint64_t id;
+  uint32_t root;
+  ScrWorkerEntry entry;
+  ScrMailbox *inbox;
+  ScrMailbox *parent;
+  ScrMessage *data;
+  ScrContextEnv *environment;
+  int argc;
+  char **argv;
+  bool joined;
+#ifdef _WIN32
+  HANDLE thread;
+#else
+  pthread_t thread;
+#endif
+};
+
+static atomic_uint_fast64_t scr_worker_next_id = 1;
+static SCR_TL ScrWorkerThread *scr_worker_current;
+static SCR_TL ScrDyn *scr_worker_local_data;
+
+static ScrMailEvent *scr_worker_event(unsigned kind, uint64_t source,
+                                     int code, ScrMessage *message) {
+  ScrMailEvent *event = calloc(1, sizeof(*event));
+  if (!event) scr_trap("scriptc: out of memory\n");
+  *event = (ScrMailEvent){.kind = kind, .source = source, .code = code, .message = message};
+  return event;
+}
+
+ScrWorkerThread *scr_worker_thread_retain(ScrWorkerThread *worker) {
+  atomic_fetch_add_explicit(&worker->references, 1, memory_order_relaxed);
+  return worker;
+}
+
+void scr_worker_thread_release(ScrWorkerThread *worker) {
+  if (!worker || atomic_fetch_sub_explicit(&worker->references, 1, memory_order_acq_rel) != 1) return;
+#ifdef _WIN32
+  if (worker->thread) CloseHandle(worker->thread);
+#else
+  if (!worker->joined) (void)pthread_detach(worker->thread);
+#endif
+  scr_mailbox_release(worker->inbox);
+  scr_mailbox_release(worker->parent);
+  scr_message_free(worker->data);
+  scr_context_env_free(worker->environment);
+  for (int i = 0; i < worker->argc; i++) free(worker->argv[i]);
+  free(worker->argv);
+  free(worker);
+}
+
+static void scr_worker_data_cleanup(void) {
+  ScrDyn *data = scr_worker_local_data;
+  scr_worker_local_data = NULL;
+  scr_dyn_release(data);
+}
+
+ScrDyn *scr_worker_data(void) {
+  if (!scr_worker_current) return scr_dyn_new_null();
+  if (!scr_worker_local_data) {
+    ScrDyn *data = scr_message_decode(scr_worker_current->data);
+    if (!data) return NULL;
+    scr_worker_local_data = data;
+    if (scr_context_atexit(scr_worker_data_cleanup) != 0) scr_trap("scriptc: out of memory\n");
+    scr_message_free(scr_worker_current->data);
+    scr_worker_current->data = NULL;
+  }
+  return scr_dyn_retain(scr_worker_local_data);
+}
+
+ScrMailbox *scr_worker_inbox(void) {
+  return scr_worker_current ? scr_worker_current->inbox : NULL;
+}
+
+double scr_worker_root(void) { return scr_worker_current ? (double)scr_worker_current->root : -1; }
+int scr_worker_argc(void) { return scr_worker_current ? scr_worker_current->argc : 0; }
+char **scr_worker_argv(void) { return scr_worker_current ? scr_worker_current->argv : NULL; }
+
+uint64_t scr_worker_thread_id(const ScrWorkerThread *worker) { return worker->id; }
+
+void scr_worker_thread_terminate(ScrWorkerThread *worker) {
+  atomic_store_explicit(&worker->cancel, true, memory_order_relaxed);
+  scr_mailbox_post(worker->inbox, scr_worker_event(SCR_WORKER_WAKE, 0, 0, NULL));
+}
+
+bool scr_worker_thread_post(ScrWorkerThread *worker, ScrMessage *message) {
+  if (atomic_load_explicit(&worker->port_closed, memory_order_relaxed)) {
+    scr_message_free(message);
+    return false;
+  }
+  return scr_mailbox_post(worker->inbox, scr_worker_event(SCR_WORKER_MESSAGE, 0, 0, message));
+}
+
+void scr_worker_port_close(void) {
+  if (scr_worker_current)
+    atomic_store_explicit(&scr_worker_current->port_closed, true, memory_order_relaxed);
+}
+
+bool scr_worker_post_parent(ScrMessage *message) {
+  if (!scr_worker_current) { scr_message_free(message); return false; }
+  return scr_mailbox_post(scr_worker_current->parent,
+    scr_worker_event(SCR_WORKER_MESSAGE, scr_worker_current->id, 0, message));
+}
+
+static void scr_worker_report_error(void) {
+  ScrCaught *caught = scr_exc_take();
+  ScrDyn *value = scr_caught_to_dyn(caught);
+  ScrMessage *message = scr_message_encode(value);
+  scr_dyn_release(value);
+  scr_caught_release(caught);
+  if (!message) {
+    scr_exc_clear();
+    static const char text[] = "Serializing an uncaught exception failed";
+    scr_throw_error_msg_code(SCR_ERR_ERROR, text, sizeof text - 1, "ERR_WORKER_UNSERIALIZABLE_ERROR");
+    caught = scr_exc_take();
+    value = scr_caught_to_dyn(caught);
+    message = scr_message_encode(value);
+    scr_dyn_release(value);
+    scr_caught_release(caught);
+  }
+  scr_mailbox_post(scr_worker_current->parent,
+    scr_worker_event(SCR_WORKER_ERROR, scr_worker_current->id, 0, message));
+}
+
+static void scr_worker_thread_run(ScrWorkerThread *worker) {
+  scr_context_enter(worker->id);
+  scr_context_stop_flag(&worker->cancel);
+  scr_context_env_enter(worker->environment);
+  worker->environment = NULL;
+  scr_worker_current = worker;
+  scr_context_report_error = scr_worker_report_error;
+  scr_mailbox_post(worker->parent, scr_worker_event(SCR_WORKER_ONLINE, worker->id, 0, NULL));
+  int code = worker->entry(worker->root);
+  scr_mailbox_close(worker->inbox);
+  scr_context_cleanup();
+  scr_worker_current = NULL;
+  /* Cleanup may itself finish owner-bound native operations. Publish exit
+   * only once none of those operations can touch the worker's script heap. */
+  scr_mailbox_post(worker->parent, scr_worker_event(SCR_WORKER_EXIT, worker->id, code, NULL));
+  scr_worker_thread_release(worker);
+}
+
+#ifdef _WIN32
+static unsigned __stdcall scr_worker_thread_main(void *data) {
+  scr_worker_thread_run(data);
+  return 0;
+}
+#else
+static void *scr_worker_thread_main(void *data) {
+  scr_worker_thread_run(data);
+  return NULL;
+}
+#endif
+
+ScrWorkerThread *scr_worker_thread_start(ScrWorkerEntry entry, uint32_t root,
+                                        ScrMessage *data, ScrMailbox *parent,
+                                        ScrArr *arguments) {
+  ScrWorkerThread *worker = calloc(1, sizeof(*worker));
+  if (!worker) scr_trap("scriptc: out of memory\n");
+  atomic_init(&worker->references, 2); /* owner and native thread */
+  atomic_init(&worker->cancel, false);
+  atomic_init(&worker->port_closed, false);
+  worker->id = atomic_fetch_add_explicit(&scr_worker_next_id, 1, memory_order_relaxed);
+  worker->entry = entry;
+  worker->root = root;
+  worker->data = data;
+  worker->environment = scr_context_env_capture();
+  worker->parent = scr_mailbox_retain(parent);
+  if (arguments) {
+    if (arguments->len > INT_MAX) scr_trap("scriptc: too many worker arguments\n");
+    worker->argc = (int)arguments->len;
+    worker->argv = calloc(arguments->len + 1, sizeof(*worker->argv));
+    if (!worker->argv) scr_trap("scriptc: out of memory\n");
+    for (size_t i = 0; i < arguments->len; i++) {
+      ScrStr *text = scr_arr_get_ref(arguments, (double)i);
+      worker->argv[i] = malloc(text->len + 1);
+      if (!worker->argv[i]) scr_trap("scriptc: out of memory\n");
+      memcpy(worker->argv[i], text->data, text->len + 1);
+      scr_str_release(text);
+    }
+  }
+  worker->inbox = scr_mailbox_new();
+  if (!worker->inbox) goto failed;
+#ifdef _WIN32
+  worker->thread = (HANDLE)_beginthreadex(NULL, 0, scr_worker_thread_main, worker, 0, NULL);
+  if (!worker->thread) goto failed;
+#else
+  if (pthread_create(&worker->thread, NULL, scr_worker_thread_main, worker) != 0) goto failed;
+#endif
+  return worker;
+failed:
+  for (int i = 0; i < worker->argc; i++) free(worker->argv[i]);
+  free(worker->argv);
+  scr_context_env_free(worker->environment);
+  scr_mailbox_release(worker->inbox);
+  scr_mailbox_release(worker->parent);
+  scr_message_free(worker->data);
+  free(worker);
+  if (!scr_exc_pending()) {
+    static const char message[] = "Could not start worker thread";
+    scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "ERR_WORKER_INIT_FAILED");
+  }
+  return NULL;
+}
+
+void scr_worker_thread_join(ScrWorkerThread *worker) {
+  if (worker->joined) return;
+#ifdef _WIN32
+  if (WaitForSingleObject(worker->thread, INFINITE) != WAIT_OBJECT_0)
+    scr_trap("scriptc: worker join failed\n");
+#else
+  if (pthread_join(worker->thread, NULL) != 0) scr_trap("scriptc: worker join failed\n");
+#endif
+  worker->joined = true;
+}
+#endif

package/dist/lib/runtime-sources/src/scr_worker.h

@@ -0,0 +1,42 @@
+#ifndef SCR_WORKER_H
+#define SCR_WORKER_H
+
+#include "scr_mailbox.h"
+
+/* A thread carries only neutral transport state and an immutable compiled
+ * entry point. Script-visible handles and listeners stay in their owner's
+ * runtime heap. The entry initializes that thread's runtime before user code;
+ * the thread wrapper drains its context before publishing the exit event. */
+typedef struct ScrWorkerThread ScrWorkerThread;
+typedef int (*ScrWorkerEntry)(uint32_t root);
+
+enum {
+  SCR_WORKER_ONLINE = 1,
+  SCR_WORKER_MESSAGE,
+  SCR_WORKER_ERROR,
+  SCR_WORKER_EXIT,
+  SCR_WORKER_WAKE,
+  SCR_WORKER_STDOUT,
+  SCR_WORKER_STDERR,
+};
+
+/* Consumes data, including on failure. Borrows the parent's mailbox. */
+ScrWorkerThread *scr_worker_thread_start(ScrWorkerEntry entry, uint32_t root,
+                                        ScrMessage *data, ScrMailbox *parent,
+                                        ScrArr *arguments);
+ScrWorkerThread *scr_worker_thread_retain(ScrWorkerThread *worker);
+void scr_worker_thread_release(ScrWorkerThread *worker);
+/* Join is owner-only and idempotent. The caller holds a reference. */
+void scr_worker_thread_join(ScrWorkerThread *worker);
+void scr_worker_thread_terminate(ScrWorkerThread *worker);
+uint64_t scr_worker_thread_id(const ScrWorkerThread *worker);
+/* Posting consumes the message even after the destination has closed. */
+bool scr_worker_thread_post(ScrWorkerThread *worker, ScrMessage *message);
+bool scr_worker_post_parent(ScrMessage *message);
+void scr_worker_port_close(void);
+/* Current-thread access: inbox is borrowed, data is a retained local value. */
+ScrMailbox *scr_worker_inbox(void);
+void scr_loop_set_workers(bool (*pending)(void), bool (*ready)(void), void (*dispatch)(void),
+                          int (*pollfd)(void), void (*wait)(double));
+
+#endif