@scriptc/cli-darwin-arm64 0.2.5 → 0.2.6

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

@@ -185,6 +185,7 @@ static bool scr_signal_check(ScrStr *name, ScrDyn *cb) {
 
 void scr_signal_on(ScrStr *name, ScrDyn *cb, bool once) {
   if (!scr_signal_check(name, cb)) return;
+  if (!scr_context_is_main()) return;
 #ifdef __wasi__
   (void)once;
   scr_trap("scriptc: internal error: OS signal surface reached on WASI\n");
@@ -262,6 +263,7 @@ static void scr_sig_remove(ScrSigReg *reg, size_t i) {
 
 void scr_signal_off(ScrStr *name, ScrDyn *cb) {
   if (!scr_signal_check(name, cb)) return;
+  if (!scr_context_is_main()) return;
   int sig = scr_signal_from_name(name);
   if (sig < 0) sig = 0;
   ScrSigReg *reg = scr_sig_regs;
@@ -359,20 +361,20 @@ typedef struct {
   bool once;
 } ScrStdinErrL;
 
-static ScrStdinDataL *scr_stdin_data = NULL;
-static size_t scr_stdin_ndata = 0, scr_stdin_data_cap = 0;
-static ScrStdinEndL *scr_stdin_end = NULL;
-static size_t scr_stdin_nend = 0, scr_stdin_end_cap = 0;
-static ScrStdinErrL *scr_stdin_err = NULL;
-static size_t scr_stdin_nerr = 0, scr_stdin_err_cap = 0;
-static ScrPromise *scr_stdin_waiter = NULL; /* parked for-await next() */
-static bool scr_stdin_eof = false;
-static bool scr_stdin_destroyed = false;
-static bool scr_stdin_paused = false;
-static bool scr_stdin_resumed = false;
-static bool scr_stdin_read_eof = false;
-static ScrBytes *scr_stdin_buffer;
-static size_t scr_stdin_read_demand;
+static SCR_TL ScrStdinDataL *scr_stdin_data = NULL;
+static SCR_TL size_t scr_stdin_ndata = 0, scr_stdin_data_cap = 0;
+static SCR_TL ScrStdinEndL *scr_stdin_end = NULL;
+static SCR_TL size_t scr_stdin_nend = 0, scr_stdin_end_cap = 0;
+static SCR_TL ScrStdinErrL *scr_stdin_err = NULL;
+static SCR_TL size_t scr_stdin_nerr = 0, scr_stdin_err_cap = 0;
+static SCR_TL ScrPromise *scr_stdin_waiter = NULL; /* parked for-await next() */
+static SCR_TL bool scr_stdin_eof = false;
+static SCR_TL bool scr_stdin_destroyed = false;
+static SCR_TL bool scr_stdin_paused = false;
+static SCR_TL bool scr_stdin_resumed = false;
+static SCR_TL bool scr_stdin_read_eof = false;
+static SCR_TL ScrBytes *scr_stdin_buffer;
+static SCR_TL size_t scr_stdin_read_demand;
 
 void scr_stdin_on_data(ScrClosure *cb /*moves*/, void (*fn)(ScrClosure *, ScrBytes *),
                         bool once) {
@@ -682,15 +684,15 @@ typedef struct {
   ScrDyn *write_error;
 } ScrStdio;
 
-static ScrStdio scr_stdio_streams[3] = {{.fd = 0}, {.fd = 1}, {.fd = 2}};
+static SCR_TL ScrStdio scr_stdio_streams[3] = {{.fd = 0}, {.fd = 1}, {.fd = 2}};
 enum { STDIO_WRITE, STDIO_ON, STDIO_ONCE, STDIO_OFF, STDIO_PAUSE, STDIO_RESUME,
        STDIO_IS_PAUSED, STDIO_READ, STDIO_RAW, STDIO_DESTROY, STDIO_METHOD_COUNT };
 static const char *const scr_stdio_names[] = {
   "write", "on", "once", "removeListener", "pause", "resume", "isPaused", "read", "setRawMode", "destroy"
 };
-static ScrDyn *scr_stdio_methods[STDIO_METHOD_COUNT];
-static bool scr_stdio_initialized;
-static bool scr_stdio_raw;
+static SCR_TL ScrDyn *scr_stdio_methods[STDIO_METHOD_COUNT];
+static SCR_TL bool scr_stdio_initialized;
+static SCR_TL bool scr_stdio_raw;
 
 static ScrDyn *scr_stdio_refusal(const char *name) {
   char message[192];
@@ -868,7 +870,7 @@ static ScrDyn *scr_stdio_method(ScrClosure *cb, ScrDyn *const *args, size_t argc
       bytes = scr_bytes_from_str(arg->v.str, enc);
       scr_str_release(enc);
     } else if (arg->kind == SCR_DYN_BYTES && arg->v.bytes->elem == SCR_BYTES_U8) {
-      bytes = scr_bytes_retain(arg->v.bytes);
+      bytes = arg->v.bytes->shared ? scr_bytes_copy(arg->v.bytes) : scr_bytes_retain(arg->v.bytes);
     } else {
       scr_dyn_arg_type_fail("chunk", "of type string or an instance of Buffer, TypedArray, or DataView", arg);
       goto done;
@@ -1091,20 +1093,29 @@ typedef struct {
   bool once;
 } ScrExitListener;
 
-static ScrExitListener *scr_exit_ls = NULL;
-static size_t scr_exit_n = 0, scr_exit_cap = 0;
-static bool scr_exit_ran = false;
+static SCR_TL ScrExitListener *scr_exit_ls = NULL;
+static SCR_TL size_t scr_exit_n = 0, scr_exit_cap = 0;
+static SCR_TL bool scr_exit_ran = false;
 
 void scr_run_exit_listeners(double code) {
   if (scr_exit_ran) return; /* process.exit inside a listener: no recursion */
   scr_exit_ran = true;
   scr_process_in_exit = true; /* process._exiting — Node's flag */
   for (size_t i = 0; i < scr_exit_n; i++) {
+#ifdef SCR_WORKERS
+    if (scr_context_stopping()) break;
+#endif
     scr_exit_ls[i].fn(scr_exit_ls[i].cb, code);
+#ifdef SCR_WORKERS
+    if (scr_context_stopping()) break;
+#endif
     if (scr_exc_pending()) {
       /* Node: a throw in an 'exit' listener is fatal (exit code 7). */
       scr_exc_print_uncaught();
       fflush(stdout);
+#ifdef SCR_WORKERS
+      if (!scr_context_is_main()) { scr_context_stop(7); break; }
+#endif
       _Exit(7);
     }
   }
@@ -1172,14 +1183,16 @@ void scr_stdin_data_thunk_bytes(ScrClosure *cb, ScrBytes *chunk) {
 static bool scr_events_pending(void) { return scr_stdin_pending(); }
 
 static bool scr_events_watching(void) {
-  return scr_sig_watched > 0 || scr_stdin_pending();
+  return (scr_context_is_main() && scr_sig_watched > 0) || scr_stdin_pending();
 }
 
 /* One dispatch pass at a loop turn: wake-pipe bytes are consumed (safe
  * any time), flagged signals fire, and stdin is probed/served. */
 static void scr_events_dispatch(void) {
-  scr_wake_pipe_drain();
-  scr_signals_drain();
+  if (scr_context_is_main()) {
+    scr_wake_pipe_drain();
+    scr_signals_drain();
+  }
   if (scr_exc_pending()) return;
   scr_stdin_service();
 }
@@ -1188,8 +1201,8 @@ static void scr_events_dispatch(void) {
  * any signal is watched, fd 0 while stdin has a consumer. */
 static int scr_events_pollfds(int out[2]) {
   int n = 0;
-  if (scr_sig_watched > 0 && scr_wake_pipe[0] >= 0) out[n++] = scr_wake_pipe[0];
-  if (scr_stdin_pending()) out[n++] = 0;
+  if (scr_context_is_main() && scr_sig_watched > 0 && scr_wake_pipe[0] >= 0) out[n++] = scr_wake_pipe[0];
+  if (scr_context_is_main() && scr_stdin_pending()) out[n++] = 0;
   return n;
 }
 
@@ -1206,7 +1219,7 @@ static void scr_exit_atexit(void) { scr_run_exit_listeners((double)scr_exit_code
  * listeners fire first, then everything releases, then the RC audit sees
  * a clean heap. */
 static void scr_events_cleanup_atexit(void) {
-  scr_sig_cleanup();
+  if (scr_context_is_main()) scr_sig_cleanup();
   scr_stdin_settle_done();
   scr_stdin_drop_listeners();
   scr_bytes_release(scr_stdin_buffer);
@@ -1215,15 +1228,16 @@ static void scr_events_cleanup_atexit(void) {
 }
 
 void scr_events_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
+  if (!scr_context_is_main()) scr_stdin_read_eof = true;
 #ifdef __wasi__
   int stdin_flags = fcntl(0, F_GETFL, 0);
   if (stdin_flags >= 0) (void)fcntl(0, F_SETFL, stdin_flags | O_NONBLOCK);
 #endif
-  atexit(scr_events_cleanup_atexit);
-  atexit(scr_exit_atexit);
+  scr_atexit(scr_events_cleanup_atexit);
+  scr_atexit(scr_exit_atexit);
   scr_loop_set_events(&scr_events_pending, &scr_events_watching, &scr_events_dispatch,
                        &scr_events_pollfds);
   scr_process_exit_hook = &scr_run_exit_listeners;

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

@@ -97,6 +97,11 @@ struct ScrEeReg {
    * only removeAllListeners deletes: the named form drops the one key,
    * the no-argument wipe resets everything and leaves shape mode. */
   bool shape;
+  /* Owner-internal observation of empty/nonempty listener transitions. It
+   * runs before user meta events and must never invoke script or mutate the
+   * emitter. The owner keeps the borrowed context alive with the emitter. */
+  void (*observe)(void *context, const ScrStr *name, bool present);
+  void *observer_context;
 };
 
 /* The vtable of BARE `new EventEmitter()` instances; the emitted main()
@@ -111,7 +116,7 @@ static SCR_TL bool scr_ee_trace_hint_shown = false;
 
 /* Post-registration hook (scr_runtime.h): the stream unit's flow kick.
  * NULL in stream-free builds — behavior byte-identical. */
-void (*scr_emitter_on_hook)(ScrEmitter *em, ScrStr *name) = NULL;
+SCR_TL void (*scr_emitter_on_hook)(ScrEmitter *em, ScrStr *name) = NULL;
 
 /* ── entries and buckets ──────────────────────────────────────────────── */
 
@@ -137,6 +142,18 @@ static ScrEeReg *scr_ee_reg_ensure(ScrEmitter *em) {
   return em->reg;
 }
 
+void scr_emitter_observe(ScrEmitter *em,
+                        void (*observe)(void *, const ScrStr *, bool), void *context) {
+  ScrEeReg *reg = scr_ee_reg_ensure(em);
+  reg->observe = observe;
+  reg->observer_context = context;
+}
+
+static void scr_ee_observe(ScrEmitter *em, const ScrStr *name, bool present) {
+  ScrEeReg *reg = em->reg;
+  if (reg->observe) reg->observe(reg->observer_context, name, present);
+}
+
 static ScrEeBucket *scr_ee_bucket_find(ScrEeReg *reg, const char *name, size_t len) {
   if (!reg) return NULL;
   for (ScrEeBucket *b = reg->head; b; b = b->next) {
@@ -368,6 +385,7 @@ static ScrEmitter *scr_ee_add(ScrEmitter *em, ScrStr *name, ScrClosure *cb /*mov
     b->ls[b->n] = e;
   }
   b->n++;
+  if (b->n == 1) scr_ee_observe(em, name, true);
   scr_ee_warn_maybe(em, b);
   if (scr_emitter_on_hook != NULL) scr_emitter_on_hook(em, name);
   return scr_emitter_retain(em);
@@ -461,6 +479,7 @@ static void scr_ee_remove_at(ScrEmitter *em, ScrEeBucket *b, size_t i) {
   memmove(b->ls + i, b->ls + i + 1, (b->n - i - 1) * sizeof *b->ls);
   b->n--;
   ScrStr *name = scr_str_retain(b->name);
+  if (b->n == 0) scr_ee_observe(em, name, false);
   if (b->n == 0 && !em->reg->shape) scr_ee_bucket_drop(em->reg, b);
   scr_ee_entry_unref(e);
   scr_ee_emit_meta(em, "removeListener", name);
@@ -519,6 +538,7 @@ static void scr_ee_remove_all_named(ScrEmitter *em, ScrEeBucket *b, bool meta) {
   if (!meta) {
     for (size_t i = 0; i < b->n; i++) scr_ee_entry_unref(b->ls[i]);
     b->n = 0;
+    scr_ee_observe(em, b->name, false);
     scr_ee_bucket_drop(em->reg, b);
     return;
   }
@@ -695,6 +715,19 @@ bool scr_emitter_emit_flex(ScrEmitter *em, ScrStr *name, ScrDyn *const *args, si
   return scr_ee_emit_core(em, name, NULL, args, argc);
 }
 
+/* Handle event registries use checked callbacks for every tuple, including
+ * errors. Keep this separate from the statically typed Error ABI above. */
+bool scr_emitter_emit_error_flex(ScrEmitter *em, ScrDyn *error) {
+  if (!scr_ee_has(em->reg, "error")) {
+    scr_dyn_throw(scr_dyn_retain(error));
+    return false;
+  }
+  ScrStr *name = scr_str_new("error", 5);
+  bool had = scr_ee_emit_core(em, name, NULL, &error, 1);
+  scr_str_release(name);
+  return had;
+}
+
 /* emit('error', err) — Node's special event: with no 'error' listener the
  * payload THROWS (catchable; uncaught exits 1 with the error report).
  * err is borrowed; the throw takes its own +1. */

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

@@ -37,11 +37,11 @@ _Noreturn void scr_trap_fmt(const char *fmt, ...) {
 #endif /* !SCR_LIB */
 
 static SCR_TL ScrExcCell scr_main_exc; /* fiber zero (the main stack) */
-#if defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)
+#if (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES)) || defined(SCR_WORKERS)
 /* A thread-local pointer cannot be initialized with &scr_main_exc — the
  * address of a thread-local is not a constant expression — so NULL stands
- * for the main cell and every read resolves it. Fibers never exist in
- * library artifacts, so the cell only ever IS the main cell here. */
+ * for the main cell and every read resolves it. Worker executables also
+ * switch this pointer as fibers enter and leave their own exception cells. */
 static SCR_TL ScrExcCell *scr_cur;
 #define SCR_EXC_CUR() (scr_cur ? scr_cur : &scr_main_exc)
 #else
@@ -117,7 +117,12 @@ ScrStr *scr_stack_capture(void) {
 #define scr_exc_release_fn (SCR_EXC_CUR()->release_fn)
 #define scr_exc_trace_fn (SCR_EXC_CUR()->trace_fn)
 
-bool scr_exc_pending(void) { return scr_exc_kind != SCR_EXC_NONE; }
+bool scr_exc_pending(void) {
+#ifdef SCR_WORKERS
+  if (scr_context_checkpoint()) return true;
+#endif
+  return scr_exc_kind != SCR_EXC_NONE;
+}
 
 /* Release the current payload (if any) and reset to NONE. Shared by clear,
  * the uncaught printer, and every throw (replace semantics). */
@@ -212,12 +217,13 @@ void scr_rethrow(const ScrCaught *c) {
     break;
   case SCR_EXC_NONE:
     break; /* unreachable: take() never stores NONE */
+  case SCR_EXC_TERMINATE:
   case SCR_EXC_GENRET:
     /* The generator-return sentinel, stashed across an exception-path
      * finally (emitTryCatch): re-raising restores the bare kind — no
      * payload exists. */
     scr_exc_reset();
-    scr_exc_kind = SCR_EXC_GENRET;
+    scr_exc_kind = c->kind;
     break;
   }
 }
@@ -279,6 +285,7 @@ ScrStr *scr_caught_to_string(const ScrCaught *c) {
      * boxes print this too where Node would vary (SEMANTICS.md). */
     return scr_str_new("[object Object]", 15);
   case SCR_EXC_NONE:
+  case SCR_EXC_TERMINATE:
   case SCR_EXC_GENRET: /* unreachable: take() never stores NONE/the sentinel */
     break;
   }
@@ -428,10 +435,13 @@ static SCR_TL int scr_exit_code_hint = 0;
 void scr_exit_code_note(int code) { scr_exit_code_hint = code; }
 int scr_exit_code_hint_get(void) { return scr_exit_code_hint; }
 
-int (*scr_uncaught_exception_hook)(bool from_promise) = NULL;
-static bool scr_uncaught_handler_failed = false;
+SCR_TL int (*scr_uncaught_exception_hook)(bool from_promise) = NULL;
+static SCR_TL bool scr_uncaught_handler_failed = false;
 
 bool scr_exc_handle_uncaught(bool from_promise) {
+#ifdef SCR_WORKERS
+  if (scr_context_stopping()) return false;
+#endif
   if (!scr_exc_pending()) return true;
   if (!scr_uncaught_exception_hook || scr_uncaught_handler_failed) return false;
   int result = scr_uncaught_exception_hook(from_promise);
@@ -440,6 +450,14 @@ bool scr_exc_handle_uncaught(bool from_promise) {
 }
 
 void scr_exc_print_uncaught(void) {
+#ifdef SCR_WORKERS
+  if (scr_context_stopping()) { scr_exc_clear(); return; }
+  if (scr_context_report_error) {
+    scr_exit_code_note(scr_uncaught_handler_failed ? 7 : 1);
+    scr_context_report_error();
+    return;
+  }
+#endif
   scr_exit_code_note(scr_uncaught_handler_failed ? 7 : 1);
   /* Settle any runtime-internal stdout fragment before the stderr line when
    * both share an fd. JavaScript-visible writes already flush themselves. */
@@ -477,6 +495,7 @@ void scr_exc_print_uncaught(void) {
     break;
   case SCR_EXC_NONE: /* main only calls this when pending */
   case SCR_EXC_GENRET: /* unreachable: the trampoline consumes the sentinel */
+  case SCR_EXC_TERMINATE:
     fputs("(no exception)", stderr);
     break;
   }

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

@@ -1618,7 +1618,7 @@ static void sf_collector_append(SfCollector *c, const ScrBytes *bytes) {
     c->data = next;
     c->cap = cap;
   }
-  memcpy(c->data + c->len, bytes->data, bytes->len);
+  scr_bytes_read(bytes, 0, c->data + c->len, bytes->len);
   c->len = need;
 }
 
@@ -3536,8 +3536,8 @@ static char *sf_all_proxy;
 static char *sf_no_proxy;
 
 static char *sf_env_copy(const char *lower, const char *upper) {
-  const char *value = getenv(lower);
-  if (!value || value[0] == '\0') value = getenv(upper);
+  const char *value = scr_getenv(lower);
+  if (!value || value[0] == '\0') value = scr_getenv(upper);
   if (!value || value[0] == '\0') return NULL;
   size_t len = strlen(value);
   char *copy = malloc(len + 1);
@@ -3547,7 +3547,7 @@ static char *sf_env_copy(const char *lower, const char *upper) {
 }
 
 static void sf_proxy_snapshot(void) {
-  const char *optin = getenv("NODE_USE_ENV_PROXY");
+  const char *optin = scr_getenv("NODE_USE_ENV_PROXY");
   sf_proxy_enabled = optin && strcmp(optin, "1") == 0;
   if (!sf_proxy_enabled) return;
   sf_http_proxy = sf_env_copy("http_proxy", "HTTP_PROXY");
@@ -4597,6 +4597,7 @@ static void sf_on_data(ScrClosure *cb, ScrBytes *chunk) {
     return;
   }
 
+  SCR_BYTES_SNAPSHOT(chunk);
   sf_inflate_append(t, chunk->data, chunk->len);
   sf_inflate_process(t);
   sf_release(t);
@@ -5045,7 +5046,9 @@ ScrDyn *scr_fetch_response_new(ScrDyn *body, ScrDyn *init) {
       !(body->kind == SCR_DYN_HANDLE &&
         body->v.handle.tag == SCR_DYNH_WEB_STREAM)) {
     if (body->kind == SCR_DYN_BYTES) {
-      body_bytes = scr_bytes_from_data(body->v.bytes->data, body->v.bytes->len * scr_bytes_elem_size(body->v.bytes->elem));
+      ScrBytes *raw = scr_bytes_raw_view(body->v.bytes);
+      body_bytes = scr_bytes_copy(raw);
+      scr_bytes_release(raw);
     } else {
       ScrStr *text =
           body->kind == SCR_DYN_STR
@@ -5397,7 +5400,7 @@ static ScrDyn *sf_data_response(ScrStr *url) {
   }
   bytes->len = n;
   if (base64) {
-    ScrStr *encoded = scr_str_new((const char *)bytes->data, bytes->len);
+    ScrStr *encoded = scr_bytes_string(bytes, 0, bytes->len);
     ScrStr *encoding = scr_str_new("base64", 6);
     ScrBytes *decoded = scr_bytes_from_str(encoded, encoding);
     scr_str_release(encoded); scr_str_release(encoding); scr_bytes_release(bytes); bytes = decoded;
@@ -5768,7 +5771,7 @@ static void sf_teardown(void) {
 }
 
 void scr_fetch_install(void) {
-  static bool installed;
+  static SCR_TL bool installed;
   if (installed) return;
   installed = true;
   scr_tls_ca_install();
@@ -5808,7 +5811,7 @@ static void sf_signal_teardown(void) {
   while (sf_reason_signals) sf_signal_drop_reason(sf_reason_signals);
 }
 static void sf_signal_install(void) {
-  static bool installed;
+  static SCR_TL bool installed;
   if (installed) return;
   installed = true;
   scr_dyn_handle_install(SCR_DYNH_ABORT_SIGNAL, &sf_signal_ops);
@@ -6001,9 +6004,9 @@ typedef struct FxTransfer {
   struct FxTransfer *next;
 } FxTransfer;
 
-static FxTransfer *fx_live = NULL; /* registry: +1 each */
-static size_t fx_nlive = 0;
-static int fx_next_id = 1;
+static SCR_TL FxTransfer *fx_live = NULL; /* registry: +1 each */
+static SCR_TL size_t fx_nlive = 0;
+static SCR_TL int fx_next_id = 1;
 
 static FxTransfer *fx_retain(FxTransfer *t) {
   t->rc++;
@@ -6305,15 +6308,15 @@ static bool fx_bad_port(int port) {
 
 /* ── env proxy (NODE_USE_ENV_PROXY=1, undici's EnvHttpProxyAgent) ────── */
 
-static bool fx_proxy_enabled;
-static char *fx_http_proxy;
-static char *fx_https_proxy;
-static char *fx_all_proxy;
-static char *fx_no_proxy;
+static SCR_TL bool fx_proxy_enabled;
+static SCR_TL char *fx_http_proxy;
+static SCR_TL char *fx_https_proxy;
+static SCR_TL char *fx_all_proxy;
+static SCR_TL char *fx_no_proxy;
 
 static char *fx_env_copy(const char *lower, const char *upper) {
-  const char *v = getenv(lower);
-  if (v == NULL || v[0] == '\0') v = getenv(upper);
+  const char *v = scr_getenv(lower);
+  if (v == NULL || v[0] == '\0') v = scr_getenv(upper);
   if (v == NULL || v[0] == '\0') return NULL;
   size_t len = strlen(v);
   char *copy = malloc(len + 1);
@@ -6323,7 +6326,7 @@ static char *fx_env_copy(const char *lower, const char *upper) {
 }
 
 static void fx_proxy_snapshot(void) {
-  const char *optin = getenv("NODE_USE_ENV_PROXY");
+  const char *optin = scr_getenv("NODE_USE_ENV_PROXY");
   fx_proxy_enabled = optin != NULL && strcmp(optin, "1") == 0;
   /* Snapshot even without Node's global opt-in: Vercel's dispatcher is a
    * request-local proxy activation over the same startup environment. */
@@ -7500,7 +7503,7 @@ static void fx_teardown(void) {
  * on real sockets the loop's own poller sleeps on, and armed island
  * timers cap that sleep through the loop's island-deadline hook. */
 void scr_fetch_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
   scr_tls_ca_install();

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

@@ -366,7 +366,7 @@ static JSValue fx_host_start(JSContext *ctx, JSValueConst this_val, int argc,
   JSValue envproxyv = JS_GetPropertyStr(ctx, req, "useEnvProxy");
   bool use_env_proxy = JS_ToBool(ctx, envproxyv) > 0;
   JS_FreeValue(ctx, envproxyv);
-  const char *global_env_proxy = getenv("NODE_USE_ENV_PROXY");
+  const char *global_env_proxy = scr_getenv("NODE_USE_ENV_PROXY");
   use_env_proxy = use_env_proxy ||
                   (global_env_proxy != NULL &&
                    strcmp(global_env_proxy, "1") == 0);

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

@@ -2,12 +2,12 @@
 
 #include <stdlib.h>
 
-/* The process-global retained-registration ledger. Format-4 script-thread
+/* The context-local retained-registration ledger. Format-4 script-thread
  * tables use the lock-free path in this always-linked unit. Format-5 foreign
  * tables install an optional teardown hook owned by scr_ffi_queue.c, keeping
  * all queue/thread machinery out of unrelated binaries. */
-static ScrFfiTable *scr_ffi_tables;
-static bool scr_ffi_exit_registered;
+static SCR_TL ScrFfiTable *scr_ffi_tables;
+static SCR_TL bool scr_ffi_exit_registered;
 
 static void scr_ffi_oom(void) { scr_trap("scriptc: out of memory\n"); }
 

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

@@ -385,6 +385,7 @@ void scr_file_handle_write_file(ScrFileHandle *h, ScrStr *data) {
 }
 
 void scr_file_handle_write_file_bytes(ScrFileHandle *h, ScrBytes *data) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_file_handle_write_all(h, data->data,
                             data->len * scr_bytes_elem_size(data->elem));
 }

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

@@ -115,7 +115,7 @@ static const char *scr_http_reason(int code) {
   return "unknown";
 }
 
-static ScrDyn *scr_http_status_codes_value;
+static SCR_TL ScrDyn *scr_http_status_codes_value;
 
 static void scr_http_status_codes_cleanup(void) {
   scr_dyn_release(scr_http_status_codes_value);
@@ -135,7 +135,7 @@ ScrDyn *scr_http_status_codes(void) {
       scr_str_release(value);
     }
     scr_http_status_codes_value = codes;
-    atexit(scr_http_status_codes_cleanup);
+    scr_atexit(scr_http_status_codes_cleanup);
   }
   return scr_dyn_retain(scr_http_status_codes_value);
 }
@@ -148,7 +148,7 @@ static const char *const scr_http_methods_table[] = {
   "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE",
 };
 
-static ScrArr *scr_http_methods_value;
+static SCR_TL ScrArr *scr_http_methods_value;
 
 static void scr_http_methods_cleanup(void) {
   scr_arr_release(scr_http_methods_value);
@@ -164,7 +164,7 @@ ScrArr *scr_http_methods(void) {
       scr_arr_push_ref(methods, scr_str_new(name, strlen(name)));
     }
     scr_http_methods_value = methods;
-    atexit(scr_http_methods_cleanup);
+    scr_atexit(scr_http_methods_cleanup);
   }
   return scr_arr_retain(scr_http_methods_value);
 }
@@ -179,12 +179,12 @@ ScrArr *scr_http_methods(void) {
  * a request-registration hook so server.on("request", ...) on an
  * h2-tagged server ctx routes to the h2 request list. The vtable's
  * typedef lives in scr_runtime.h (both units name it). */
-static const ScrHttpH2Ops *scr_http_h2_ops = NULL;
-static void (*scr_http_h2_request_hook)(void *h2ctx, ScrClosure *cb /*moves*/,
+static SCR_TL const ScrHttpH2Ops *scr_http_h2_ops = NULL;
+static SCR_TL void (*scr_http_h2_request_hook)(void *h2ctx, ScrClosure *cb /*moves*/,
                                          void *fn, bool once) = NULL;
-static void (*scr_http_h2_connect_hook)(void *h2ctx, ScrClosure *cb /*moves*/,
+static SCR_TL void (*scr_http_h2_connect_hook)(void *h2ctx, ScrClosure *cb /*moves*/,
                                         void *h1_fn, void *h2_fn, bool once) = NULL;
-static void (*scr_http_h2_upgrade_hook)(void *h2ctx, ScrClosure *cb /*moves*/,
+static SCR_TL void (*scr_http_h2_upgrade_hook)(void *h2ctx, ScrClosure *cb /*moves*/,
                                         void *fn, bool once) = NULL;
 
 void scr_http_set_h2_ops(const ScrHttpH2Ops *ops) { scr_http_h2_ops = ops; }
@@ -247,7 +247,7 @@ struct ScrHttpReq {
 };
 
 #ifdef SCR_RC_AUDIT
-static long scr_http_live = 0;
+static SCR_TL long scr_http_live = 0;
 long scr_http_live_count(void) { return scr_http_live; }
 #endif
 
@@ -1510,6 +1510,7 @@ void scr_http_res_write_str(ScrHttpRes *r, ScrStr *data /*borrowed*/) {
 }
 
 void scr_http_res_write_bytes(ScrHttpRes *r, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   double expected;
   if (r->head_sent && scr_http_res_expected_length(r, &expected) &&
       (double)(r->strict_bytes_written + (data->len * scr_bytes_elem_size(data->elem))) > expected) {
@@ -1642,6 +1643,7 @@ void scr_http_res_end_str(ScrHttpRes *r, ScrStr *data /*borrowed*/) {
 }
 
 void scr_http_res_end_bytes(ScrHttpRes *r, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_http_res_end_raw(r, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem)));
 }
 
@@ -1790,8 +1792,8 @@ typedef struct {
   void *h; /* +1 */
 } ScrHttpEmit;
 
-static ScrHttpEmit *scr_http_emits = NULL;
-static size_t scr_http_emits_head = 0, scr_http_emits_len = 0, scr_http_emits_cap = 0;
+static SCR_TL ScrHttpEmit *scr_http_emits = NULL;
+static SCR_TL size_t scr_http_emits_head = 0, scr_http_emits_len = 0, scr_http_emits_cap = 0;
 
 static void scr_http_client_release_internal(struct ScrHttpClientReq *c);
 static void scr_http_client_settle(struct ScrHttpClientReq *c);
@@ -1804,7 +1806,7 @@ static void scr_http_client_emit_abort(struct ScrHttpClientReq *c);
  * has drained for the last time, teardown paths that would queue close
  * emits (scr_net_cleanup_atexit freeing in-flight parsers) discard the
  * payload instead — nothing will ever sweep again. */
-static bool scr_http_exiting = false;
+static SCR_TL bool scr_http_exiting = false;
 
 static void scr_http_emit_release(ScrHttpEmit *e);
 
@@ -2007,10 +2009,10 @@ static void scr_http_cleanup_atexit(void) {
 /* One-time wiring into the net sweep (both createServer and request call
  * through here). */
 static void scr_http_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_http_cleanup_atexit);
+  scr_atexit(scr_http_cleanup_atexit);
   scr_net_set_proto_sweep(&scr_http_proto_pending, &scr_http_proto_sweep);
 }
 
@@ -3186,7 +3188,7 @@ struct ScrHttpClientReq {
   struct ScrHttpClientReq *next;
 };
 
-static ScrHttpClientReq *scr_http_clients = NULL; /* registry: +1 each */
+static SCR_TL ScrHttpClientReq *scr_http_clients = NULL; /* registry: +1 each */
 
 ScrHttpClientReq *scr_http_client_retain(ScrHttpClientReq *c) {
   if (c->rc != SIZE_MAX) c->rc++;
@@ -3552,6 +3554,7 @@ void scr_http_client_write_str(ScrHttpClientReq *c, ScrStr *data /*borrowed*/) {
 }
 
 void scr_http_client_write_bytes(ScrHttpClientReq *c, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_http_client_write_raw(c, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem)));
 }
 
@@ -3608,6 +3611,7 @@ void scr_http_client_end_str(ScrHttpClientReq *c, ScrStr *data /*borrowed*/) {
 }
 
 void scr_http_client_end_bytes(ScrHttpClientReq *c, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_http_client_end_raw(c, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem)));
 }
 
@@ -4277,7 +4281,7 @@ typedef struct ScrHttpAgent {
   struct ScrHttpAgent *next;
 } ScrHttpAgent;
 
-static ScrHttpAgent *scr_http_agents = NULL; /* registry: +1 each, atexit-swept */
+static SCR_TL ScrHttpAgent *scr_http_agents = NULL; /* registry: +1 each, atexit-swept */
 
 static ScrHttpAgent *scr_http_agent_retain(ScrHttpAgent *a) {
   a->rc++;