@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

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

@@ -0,0 +1,167 @@
+#include "scr_runtime.h"
+
+#ifdef SCR_WORKERS
+#include <stdlib.h>
+#include <stdatomic.h>
+
+void scr_runtime_workers_v7(void) {}
+
+typedef struct ScrContextExit {
+  void (*fn)(void);
+  struct ScrContextExit *next;
+} ScrContextExit;
+
+static SCR_TL ScrContextExit *scr_context_exits;
+static SCR_TL uint64_t scr_context_id;
+static SCR_TL const atomic_bool *scr_context_cancel;
+static SCR_TL bool scr_context_stopped;
+SCR_TL void (*scr_context_report_error)(void);
+
+typedef struct { char *name; char *value; } ScrContextEnvEntry;
+struct ScrContextEnv { size_t count; ScrContextEnvEntry *entries; };
+static SCR_TL ScrContextEnv *scr_context_environment;
+
+static char *scr_context_text_copy(const char *value) {
+  size_t length = strlen(value);
+  char *copy = malloc(length + 1);
+  if (!copy) scr_trap("scriptc: out of memory\n");
+  memcpy(copy, value, length + 1);
+  return copy;
+}
+
+ScrContextEnv *scr_context_env_capture(void) {
+  ScrArr *pairs = scr_env_pairs();
+  ScrContextEnv *environment = calloc(1, sizeof(*environment));
+  if (!environment) scr_trap("scriptc: out of memory\n");
+  environment->count = pairs->len / 2;
+  environment->entries = calloc(environment->count ? environment->count : 1, sizeof(*environment->entries));
+  if (!environment->entries) scr_trap("scriptc: out of memory\n");
+  for (size_t i = 0; i < environment->count; i++) {
+    ScrStr *key = scr_arr_get_ref(pairs, (double)(2 * i));
+    ScrStr *value = scr_arr_get_ref(pairs, (double)(2 * i + 1));
+    environment->entries[i] = (ScrContextEnvEntry){scr_context_text_copy(key->data), scr_context_text_copy(value->data)};
+    scr_str_release(key); scr_str_release(value);
+  }
+  scr_arr_release(pairs);
+  return environment;
+}
+
+void scr_context_env_free(ScrContextEnv *environment) {
+  if (!environment) return;
+  for (size_t i = 0; i < environment->count; i++) {
+    free(environment->entries[i].name); free(environment->entries[i].value);
+  }
+  free(environment->entries); free(environment);
+}
+
+static void scr_context_env_cleanup(void) {
+  scr_context_env_free(scr_context_environment);
+  scr_context_environment = NULL;
+}
+
+void scr_context_env_enter(ScrContextEnv *environment) {
+  scr_context_environment = environment;
+  if (scr_context_atexit(scr_context_env_cleanup)) scr_trap("scriptc: out of memory\n");
+}
+
+const char *scr_context_getenv(const char *name) {
+  if (!scr_context_environment) return getenv(name);
+  for (size_t i = 0; i < scr_context_environment->count; i++)
+    if (!strcmp(scr_context_environment->entries[i].name, name)) return scr_context_environment->entries[i].value;
+  return NULL;
+}
+
+bool scr_context_env_set(const char *name, const char *value) {
+  ScrContextEnv *environment = scr_context_environment;
+  if (!environment) return false;
+  for (size_t i = 0; i < environment->count; i++) {
+    ScrContextEnvEntry *entry = &environment->entries[i];
+    if (strcmp(entry->name, name)) continue;
+    char *copy = value ? scr_context_text_copy(value) : NULL;
+    free(entry->value);
+    entry->value = copy;
+    if (!copy) {
+      free(entry->name);
+      memmove(entry, entry + 1, (--environment->count - i) * sizeof(*entry));
+    }
+    return true;
+  }
+  if (value) {
+    ScrContextEnvEntry *entries = realloc(environment->entries, (environment->count + 1) * sizeof(*entries));
+    if (!entries) scr_trap("scriptc: out of memory\n");
+    environment->entries = entries;
+    entries[environment->count++] = (ScrContextEnvEntry){scr_context_text_copy(name), scr_context_text_copy(value)};
+  }
+  return true;
+}
+
+ScrArr *scr_context_env_pairs(void) {
+  if (!scr_context_environment) return NULL;
+  ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
+  for (size_t i = 0; i < scr_context_environment->count; i++) {
+    const ScrContextEnvEntry *entry = &scr_context_environment->entries[i];
+    scr_arr_push_ref(out, scr_str_new(entry->name, strlen(entry->name)));
+    scr_arr_push_ref(out, scr_str_new(entry->value, strlen(entry->value)));
+  }
+  return out;
+}
+
+void scr_context_enter(uint64_t thread_id) { scr_context_id = thread_id; }
+bool scr_context_is_main(void) { return scr_context_id == 0; }
+uint64_t scr_context_thread_id(void) { return scr_context_id; }
+double scr_context_thread_number(void) { return (double)scr_context_id; }
+
+void scr_context_stop_flag(const void *flag) { scr_context_cancel = flag; }
+bool scr_context_stopping(void) { return scr_context_stopped; }
+
+void scr_context_stop(int code) {
+  scr_context_stopped = true;
+  scr_exit_code_note(code);
+  scr_exc_clear();
+  scr_exc_current_cell()->kind = SCR_EXC_TERMINATE;
+}
+
+bool scr_context_checkpoint(void) {
+  if (!scr_context_stopped && scr_context_cancel &&
+      atomic_load_explicit(scr_context_cancel, memory_order_relaxed)) scr_context_stop(1);
+  if (!scr_context_stopped) return false;
+  /* Each fiber has its own exception cell. Reinstall the sentinel after a
+   * context switch or a runtime continuation consumes its pending payload. */
+  if (scr_exc_current_cell()->kind != SCR_EXC_TERMINATE) {
+    scr_exc_clear();
+    scr_exc_current_cell()->kind = SCR_EXC_TERMINATE;
+  }
+  return true;
+}
+
+int scr_context_atexit(void (*fn)(void)) {
+  ScrContextExit *entry = malloc(sizeof(*entry));
+  if (!entry) return -1;
+  entry->fn = fn;
+  entry->next = scr_context_exits;
+  scr_context_exits = entry;
+  return 0;
+}
+
+void scr_context_cleanup(void) {
+  scr_loop_context_shutdown();
+  /* Pop before calling: a callback may register further cleanup. Those
+   * registrations run first, just as newly registered libc exit handlers do.
+   * Repeated cleanup is harmless after the list has been drained. */
+  while (scr_context_exits) {
+    ScrContextExit *entry = scr_context_exits;
+    scr_context_exits = entry->next;
+    void (*fn)(void) = entry->fn;
+    free(entry);
+    fn();
+  }
+  scr_exc_clear();
+  scr_cyc_context_cleanup();
+}
+#else
+bool scr_context_is_main(void) { return true; }
+double scr_context_thread_number(void) { return 0; }
+double scr_worker_root(void) { return -1; }
+ScrDyn *scr_worker_data(void) { return scr_dyn_new_null(); }
+ScrDyn *scr_worker_parent_port(void) { return scr_dyn_new_null(); }
+#endif

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

@@ -0,0 +1,118 @@
+#undef NDEBUG
+#include "scr_async.c"
+#include <assert.h>
+#include <sched.h>
+#include <stdatomic.h>
+
+enum { CONTEXTS = 4, REQUESTS = 64 };
+static atomic_uint started;
+static SCR_TL unsigned completed;
+static SCR_TL unsigned destroyed;
+static SCR_TL unsigned cleanup_order;
+static SCR_TL unsigned timer_calls;
+
+typedef struct Work {
+  uint64_t owner;
+  unsigned input;
+  unsigned result;
+  ScrStr *text;
+  bool deliver;
+} Work;
+
+static void run_work(void *data) {
+  Work *work = data;
+  work->result = work->input * 7 + 3;
+}
+
+static void deliver_work(void *data) {
+  Work *work = data;
+  assert(work->deliver);
+  assert(scr_context_thread_id() == work->owner);
+  assert(work->result == work->input * 7 + 3);
+  completed++;
+}
+
+static void destroy_work(void *data) {
+  Work *work = data;
+  assert(scr_context_thread_id() == work->owner);
+  scr_str_release(work->text);
+  destroyed++;
+  free(work);
+}
+
+static void submit_work(unsigned input, bool deliver) {
+  Work *work = malloc(sizeof(*work));
+  assert(work);
+  *work = (Work){scr_context_thread_id(), input, 0, scr_str_new("owned", 5), deliver};
+  scr_work_submit(work, run_work, deliver_work, destroy_work);
+}
+
+static void timer(ScrClosure *closure) {
+  (void)closure;
+  timer_calls++;
+}
+
+static void cleanup_first(void) {
+  assert(cleanup_order == 2);
+  cleanup_order = 3;
+}
+
+static void cleanup_inserted(void) {
+  assert(cleanup_order == 1);
+  cleanup_order = 2;
+}
+
+static void cleanup_second(void) {
+  assert(cleanup_order == 0);
+  cleanup_order = 1;
+  assert(scr_context_atexit(cleanup_inserted) == 0);
+}
+
+static void *run_context(void *data) {
+  uint64_t id = (uintptr_t)data;
+  scr_context_enter(id);
+  assert(!scr_context_is_main());
+  scr_init();
+  scr_lib_init(0, NULL);
+  assert(scr_context_atexit(cleanup_first) == 0);
+  assert(scr_context_atexit(cleanup_second) == 0);
+
+  /* Leave a distinct exception pending while every context is active. */
+  scr_throw_f64((double)id);
+  atomic_fetch_add_explicit(&started, 1, memory_order_release);
+  while (atomic_load_explicit(&started, memory_order_acquire) != CONTEXTS) sched_yield();
+  ScrCaught *caught = scr_exc_take();
+  assert(caught && caught->kind == SCR_EXC_F64 && caught->f64 == (double)id);
+  scr_caught_release(caught);
+
+  for (unsigned i = 0; i < REQUESTS; i++) submit_work(i, true);
+  ScrClosure *callback = scr_closure_new((void *)timer, 0);
+  scr_set_timeout(callback, 1);
+  assert(!scr_loop_run(NULL));
+  assert(!scr_exc_pending());
+  assert(completed == REQUESTS && destroyed == REQUESTS && timer_calls == 1);
+
+  /* Teardown must wait for borrowed native work, release it on its owner,
+   * and suppress its script callback. It must not stop another context. */
+  submit_work(REQUESTS, false);
+  scr_context_cleanup();
+  assert(destroyed == REQUESTS + 1 && completed == REQUESTS);
+  assert(cleanup_order == 3);
+  scr_context_cleanup();
+  assert(cleanup_order == 3);
+  return NULL;
+}
+
+int main(void) {
+  scr_init();
+  scr_lib_init(0, NULL);
+  pthread_t threads[CONTEXTS];
+  for (uintptr_t i = 0; i < CONTEXTS; i++)
+    assert(pthread_create(&threads[i], NULL, run_context, (void *)(i + 1)) == 0);
+  for (unsigned i = 0; i < CONTEXTS; i++) assert(pthread_join(threads[i], NULL) == 0);
+  assert(scr_context_is_main());
+  assert(!scr_exc_pending());
+  assert(completed == 0 && destroyed == 0 && timer_calls == 0);
+  scr_context_cleanup();
+  puts("runtime contexts keep completions, timers, exceptions and cleanup isolated");
+}

package/dist/lib/runtime-sources/src/scr_context.test.ts

@@ -0,0 +1,47 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { expect, test } from "vitest";
+import { EXECUTABLE_RUNTIME_SOURCES } from "../../compiler/src/backend/native-toolchain.js";
+
+const exec = promisify(execFile);
+
+test.skipIf(process.platform === "win32")(
+  "concurrent runtime contexts deliver native work and drain cleanup on their owner",
+  async () => {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-context-"));
+    try {
+      const bin = join(dir, "contexts");
+      await exec("clang", [
+        "-std=c11",
+        "-O1",
+        "-Wall",
+        "-Wextra",
+        "-Wno-deprecated-declarations",
+        "-pthread",
+        "-DSCR_WORKERS",
+        "-DSCR_RC_AUDIT",
+        "-fsanitize=address,undefined",
+        ...(process.platform === "linux" ? ["-D_GNU_SOURCE"] : []),
+        join(import.meta.dirname, "scr_context.test.c"),
+        ...EXECUTABLE_RUNTIME_SOURCES.filter((name) => name !== "scr_async.c").map((name) =>
+          join(import.meta.dirname, name),
+        ),
+        ...(process.platform === "linux" ? ["-lm"] : []),
+        "-o",
+        bin,
+      ]);
+      const result = await exec(bin, [], {
+        env: { ...process.env, UBSAN_OPTIONS: "halt_on_error=1" },
+      });
+      expect(result.stdout).toBe(
+        "runtime contexts keep completions, timers, exceptions and cleanup isolated\n",
+      );
+      expect(result.stderr).toBe("");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  },
+);

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

@@ -124,10 +124,21 @@ ScrArr *scr_arr_with_undefined(ScrArr *a, double index) {
 }
 
 ScrBytes *scr_bytes_to_reversed(const ScrBytes *b) {
+  SCR_SHARED_GUARD(b, NULL);
   ScrBytes *out = scr_bytes_new(b->elem, (double)b->len);
+  size_t width = scr_bytes_elem_size(b->elem);
+  /* Copy the stored representation without numeric conversion. Views may
+   * be unaligned, so fixed-width memcpy preserves both alignment safety
+   * and floating-point payload bits. The width is invariant for the loop. */
   for (size_t i = 0; i < b->len; i++) {
-    scr_bytes_set(out, (double)i,
-                  scr_bytes_get(b, (double)(b->len - i - 1)));
+    const uint8_t *source = b->data + (b->len - i - 1) * width;
+    uint8_t *target = out->data + i * width;
+    switch (width) {
+    case 1: *target = *source; break;
+    case 2: memcpy(target, source, 2); break;
+    case 4: memcpy(target, source, 4); break;
+    case 8: memcpy(target, source, 8); break;
+    }
   }
   return out;
 }

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

@@ -68,7 +68,13 @@
  *                  unlinked INTO a dead cycle grows no counter at all (it
  *                  was tallied when it was allocated) and is invisible to a
  *                  nursery pass, so without it a program that churns its
- *                  long-lived structures would never collect anything.
+ *                  long-lived structures would never collect anything. But
+ *                  a mature object is also buffered whenever a temporary
+ *                  reference to it is dropped, so merely READING a live
+ *                  structure (walking a tree, say) refills the buffer with
+ *                  objects that are not garbage. A full pass that frees
+ *                  almost nothing therefore doubles this fraction, and a
+ *                  productive one restores it.
  *   scheduled age  a mature candidate has waited through a nursery's worth
  *                  of event-loop checkpoints. Candidate COUNT cannot bound
  *                  the garbage behind one root, and an idle heap does not
@@ -101,10 +107,58 @@ static void scr_cyc_oom(void) {
   scr_trap("scriptc: out of memory\n");
 }
 
+typedef struct {
+  void *object;
+  void (*destroy)(void *);
+} ScrDestroyEntry;
+
+/* Keep shallow destruction synchronous without allocating. A chain may mix
+ * program layouts, unions and runtime containers, so one instance-local
+ * depth budget covers every participating destructor. Queued zero-count
+ * objects still own their children until their callback runs. */
+#define SCR_DESTROY_DEPTH 64
+static SCR_TL unsigned scr_destroy_depth;
+static SCR_TL ScrDestroyEntry *scr_destroy_pending;
+static SCR_TL size_t scr_destroy_count, scr_destroy_capacity;
+
+void scr_rc_destroy(void *obj, void (*destroy)(void *)) {
+  if (scr_destroy_depth == SCR_DESTROY_DEPTH) {
+    if (scr_destroy_count == scr_destroy_capacity) {
+      size_t capacity = scr_destroy_capacity ? scr_destroy_capacity * 2 : 64;
+      if (capacity < scr_destroy_capacity || capacity > SIZE_MAX / sizeof(ScrDestroyEntry))
+        scr_cyc_oom();
+      ScrDestroyEntry *entries = realloc(scr_destroy_pending, capacity * sizeof(*entries));
+      if (!entries) scr_cyc_oom();
+      scr_destroy_pending = entries;
+      scr_destroy_capacity = capacity;
+    }
+    scr_destroy_pending[scr_destroy_count++] = (ScrDestroyEntry){ obj, destroy };
+    return;
+  }
+  scr_destroy_depth++;
+  destroy(obj);
+  scr_destroy_depth--;
+  if (scr_destroy_depth) return;
+  while (scr_destroy_count) {
+    ScrDestroyEntry entry = scr_destroy_pending[--scr_destroy_count];
+    scr_destroy_depth = 1;
+    entry.destroy(entry.object);
+    scr_destroy_depth = 0;
+  }
+  /* Deep teardown is exceptional; don't retain its peak queue allocation
+   * throughout an otherwise idle executable or embedded runtime instance. */
+  if (scr_destroy_pending) {
+    free(scr_destroy_pending);
+    scr_destroy_pending = NULL;
+    scr_destroy_capacity = 0;
+  }
+}
+
 /* Live cycle-headered objects — what the full-pass trigger watches. */
 static SCR_TL size_t scr_cyc_live = 0;
 
 void *scr_cyc_alloc(size_t size, ScrTraceFn trace, ScrCycFreeFn free_fn) {
+  if (size > SIZE_MAX - sizeof(ScrCycHdr)) scr_cyc_oom();
   ScrCycHdr *h = calloc(1, sizeof(ScrCycHdr) + size);
   if (!h) scr_cyc_oom();
   h->trace = trace;
@@ -182,10 +236,15 @@ static size_t scr_cyc_pass(unsigned gen_limit);
 /* Live count as of the end of the last full pass. */
 static SCR_TL size_t scr_cyc_live_after_full = 0;
 
+/* Doublings of the mature-backlog threshold earned by consecutive full passes
+ * that found almost nothing to free (see scr_cyc_mature_threshold). */
+#define SCR_CYC_BACKLOG_MAX_SHIFT 8
+static SCR_TL unsigned scr_cyc_backlog_shift = 0;
+
 static size_t scr_cyc_nursery_threshold(void) {
   static SCR_TL size_t cached = 0;
   if (cached == 0) {
-    const char *env = getenv("SCR_CYCLE_THRESHOLD");
+    const char *env = scr_getenv("SCR_CYCLE_THRESHOLD");
     long v = env ? strtol(env, NULL, 10) : 0;
     cached = v > 0 ? (size_t)v : SCR_CYC_NURSERY_CANDIDATES;
   }
@@ -232,16 +291,41 @@ static bool scr_cyc_full_due(void) {
  * allocating would never collect anything. So the mature buffer's own size
  * is the second full-pass trigger, at a fraction of the live heap: that
  * bounds uncollected mature candidates proportionally and keeps the
- * amortized cost linear (one heap-sized walk per live/N candidates). */
+ * amortized cost linear (one heap-sized walk per live/N candidates).
+ *
+ * Re-buffered live objects cannot be told apart from new garbage until a
+ * pass walks them, and a program that keeps traversing one live structure
+ * buffers it again after every pass. Each full pass that frees almost none
+ * of its candidates doubles the threshold, so repeated unproductive walks
+ * thin out geometrically; once it exceeds the mature population this
+ * trigger rests, leaving heap growth, the scheduled age and exit to collect.
+ * That only delays garbage made from existing data: replacing it requires
+ * allocation, which grows the heap and trips the growth trigger. The first
+ * productive full pass restores the original fraction. */
 static size_t scr_cyc_mature_threshold(void) {
   size_t t = scr_cyc_live / SCR_CYC_FULL_GROWTH_DIV;
-  return t < SCR_CYC_NURSERY_CANDIDATES ? SCR_CYC_NURSERY_CANDIDATES : t;
+  if (t < SCR_CYC_NURSERY_CANDIDATES) t = SCR_CYC_NURSERY_CANDIDATES;
+  return t > (SIZE_MAX >> scr_cyc_backlog_shift) ? SIZE_MAX : t << scr_cyc_backlog_shift;
+}
+
+/* A scheduled full pass, adapting the backlog threshold to its yield. The
+ * explicit sweep (scr_collect_cycles) is not a scheduling decision and
+ * leaves the threshold alone. Productive means at least one object freed
+ * per FULL_GROWTH_DIV candidates; a pass with no candidates says nothing. */
+static void scr_cyc_full_pass(void) {
+  size_t freed = scr_cyc_pass(SCR_CYC_MATURE);
+  if (scr_cands.n == 0) return;
+  if (freed * SCR_CYC_FULL_GROWTH_DIV >= scr_cands.n)
+    scr_cyc_backlog_shift = 0;
+  else if (scr_cyc_backlog_shift < SCR_CYC_BACKLOG_MAX_SHIFT)
+    scr_cyc_backlog_shift++;
 }
 
 static void scr_cyc_collect_due(void) {
-  bool full = scr_cyc_full_due()
-              || scr_roots[SCR_CYC_MATURE].n >= scr_cyc_mature_threshold();
-  scr_cyc_pass(full ? SCR_CYC_MATURE : SCR_CYC_NURSERY);
+  if (scr_cyc_full_due() || scr_roots[SCR_CYC_MATURE].n >= scr_cyc_mature_threshold())
+    scr_cyc_full_pass();
+  else
+    scr_cyc_pass(SCR_CYC_NURSERY);
 }
 
 /* One scheduled pass, for callers that reach a natural collection point
@@ -258,7 +342,7 @@ void scr_cyc_collect_scheduled(void) {
     scr_cyc_scheduled_mature_age = 0;
   } else if (++scr_cyc_scheduled_mature_age
              >= scr_cyc_nursery_threshold()) {
-    scr_cyc_pass(SCR_CYC_MATURE);
+    scr_cyc_full_pass();
     return;
   }
   scr_cyc_collect_due();
@@ -428,8 +512,14 @@ static void scr_xg_child_visit(void *child, void *ctx) {
 }
 
 /* One genuine release, generically: the header carries everything needed. */
-static void scr_xg_release(void *obj) {
+static void scr_xg_destroy(void *obj) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
+  h->trace(obj, scr_xg_child_visit, NULL);
+  h->free_fn(obj);
+  scr_xg_freed++;
+}
+
+static void scr_xg_release(void *obj) {
   if (SCR_RC(obj) > 1) {
     SCR_RC(obj) -= 1;
     scr_cyc_on_release(obj); /* lost a reference: a possible cycle root */
@@ -437,9 +527,7 @@ static void scr_xg_release(void *obj) {
   }
   SCR_RC(obj) = 0;
   scr_cyc_on_dead(obj); /* out of its candidate buffer before the block goes */
-  h->trace(obj, scr_xg_child_visit, NULL); /* the traced children */
-  h->free_fn(obj); /* the untraced ones, then the block */
-  scr_xg_freed++;
+  scr_rc_destroy(obj, scr_xg_destroy);
 }
 
 /* One pass over every candidate at or below `gen_limit`; returns how many
@@ -587,3 +675,15 @@ void scr_collect_cycles(void) {
          && (scr_roots[SCR_CYC_NURSERY].n || scr_roots[SCR_CYC_MATURE].n)) {
   }
 }
+
+/* Worker TLS becomes unreachable when its OS thread returns. Release the
+ * reusable traversal buffers after all context-owned roots are retired. */
+void scr_cyc_context_cleanup(void) {
+  scr_collect_cycles();
+  ScrVec *vectors[] = {&scr_roots[SCR_CYC_NURSERY], &scr_roots[SCR_CYC_MATURE],
+    &scr_cands, &scr_promote, &scr_pending, &scr_restore_pending, &scr_white, &scr_xgen};
+  for (size_t i = 0; i < sizeof vectors / sizeof vectors[0]; i++) {
+    free(vectors[i]->v);
+    *vectors[i] = (ScrVec){0};
+  }
+}

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

@@ -42,9 +42,9 @@ typedef struct {
   size_t nbinds, binds_cap;
 } ScrDcChannel;
 
-static ScrDcChannel *dc_channels = NULL;
-static size_t dc_nchannels = 0, dc_cap = 0;
-static bool dc_teardown_registered = false;
+static SCR_TL ScrDcChannel *dc_channels = NULL;
+static SCR_TL size_t dc_nchannels = 0, dc_cap = 0;
+static SCR_TL bool dc_teardown_registered = false;
 
 static void scr_dc_teardown(void) {
   for (size_t i = 0; i < dc_nchannels; i++) {
@@ -75,7 +75,7 @@ static size_t dc_intern(ScrStr *name) {
   }
   if (!dc_teardown_registered) {
     dc_teardown_registered = true;
-    atexit(scr_dc_teardown);
+    scr_atexit(scr_dc_teardown);
   }
   ScrDcChannel *ch = &dc_channels[dc_nchannels];
   ch->name = scr_str_retain(name);
@@ -358,9 +358,9 @@ enum { DC_TC_START, DC_TC_END, DC_TC_ASYNC_START, DC_TC_ASYNC_END, DC_TC_ERROR }
 
 static const char *const dc_trace_events[5] = {"start", "end", "asyncStart", "asyncEnd", "error"};
 
-static ScrDcTracing *dc_tracings = NULL;
-static size_t dc_ntracings = 0, dc_tracings_cap = 0;
-static bool dc_tracings_teardown_registered = false;
+static SCR_TL ScrDcTracing *dc_tracings = NULL;
+static SCR_TL size_t dc_ntracings = 0, dc_tracings_cap = 0;
+static SCR_TL bool dc_tracings_teardown_registered = false;
 
 static void scr_dc_tracings_teardown(void) {
   free(dc_tracings);
@@ -379,7 +379,7 @@ static double dc_tracing_register(const size_t ch[5]) {
   }
   if (!dc_tracings_teardown_registered) {
     dc_tracings_teardown_registered = true;
-    atexit(scr_dc_tracings_teardown);
+    scr_atexit(scr_dc_tracings_teardown);
   }
   for (size_t i = 0; i < 5; i++) dc_tracings[dc_ntracings].ch[i] = ch[i];
   dc_ntracings++;

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

@@ -346,12 +346,12 @@ struct ScrDgramSocket {
 };
 
 #ifdef SCR_RC_AUDIT
-static long scr_dgram_live = 0;
+static SCR_TL long scr_dgram_live = 0;
 long scr_dgram_live_count(void) { return scr_dgram_live; }
 #endif
 
-static ScrDgramSocket *scr_dgram_socks = NULL; /* registry: +1 each, tail-appended */
-static ScrPoller *scr_dgram_poller = NULL;
+static SCR_TL ScrDgramSocket *scr_dgram_socks = NULL; /* registry: +1 each, tail-appended */
+static SCR_TL ScrPoller *scr_dgram_poller = NULL;
 
 /* Pending dns.lookup deliveries (already resolved — getaddrinfo ran at
  * the call; the sweep fires them FIFO). */
@@ -364,7 +364,7 @@ typedef struct ScrDnsPending {
   struct ScrDnsPending *next;
 } ScrDnsPending;
 
-static ScrDnsPending *scr_dns_pending = NULL;
+static SCR_TL ScrDnsPending *scr_dns_pending = NULL;
 
 /* ── RC ──────────────────────────────────────────────────────────────── */
 
@@ -645,6 +645,7 @@ void scr_dgram_send_str(ScrDgramSocket *s, ScrStr *data, double port, ScrStr *ho
 }
 
 void scr_dgram_send_bytes(ScrDgramSocket *s, ScrBytes *data, double port, ScrStr *host) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_dgram_send_raw(s, (const char *)data->data, data->len, port, host);
 }
 
@@ -1011,10 +1012,10 @@ static void scr_dgram_cleanup_atexit(void) {
 }
 
 void scr_dgram_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_dgram_cleanup_atexit);
+  scr_atexit(scr_dgram_cleanup_atexit);
   scr_loop_set_dgram(&scr_dgram_pending, &scr_dgram_dispatch, &scr_dgram_pollfd);
 }
 
@@ -1167,8 +1168,10 @@ void scr_dgram_send_chk(ScrDgramSocket *s, const ScrDyn *buffer, const ScrDyn *a
     scr_throw_lowering_fence(fence);
     return;
   }
+  const ScrBytes *byte_input = buffer->kind == SCR_DYN_BYTES ? buffer->v.bytes : NULL;
+  SCR_BYTES_SNAPSHOT(byte_input);
   const char *data = buffer->kind == SCR_DYN_STR ? buffer->v.str->data
-                                                 : (const char *)buffer->v.bytes->data;
+                                                 : (const char *)byte_input->data;
   size_t datalen = buffer->kind == SCR_DYN_STR ? buffer->v.str->len
                                                : (size_t)scr_bytes_byte_len(buffer->v.bytes);
   if (sliced) {