@scriptc/runtime 0.0.3 → 0.0.5

package/src/scr_lib.c

@@ -126,11 +126,25 @@ static void scr_lib_cleanup(void) {
   scr_versions_openssl_str = NULL;
 }
 
+#ifndef SCR_LIB
+/* Executable lane only: a library artifact has no argv and registers no
+ * atexit handlers (the emitted library init never calls this; keeping it out
+ * the archive's objects free of any atexit reference — the K8 ambient
+ * audit's bar). */
 void scr_lib_init(int argc, char **argv) {
   scr_lib_argc = argc;
   scr_lib_argv = argv;
   atexit(scr_lib_cleanup);
 }
+#endif /* !SCR_LIB */
+
+#ifdef SCR_LIB
+/* Library builds never call scr_lib_init (a library artifact has no argv and registers no
+ * atexit handlers); the interned process values above still intern lazily
+ * on first read, so the library reset seam releases them here instead —
+ * scr_library_reset (scr_library.c) calls this every session reset. */
+void scr_lib_session_cleanup(void) { scr_lib_cleanup(); }
+#endif
 
 /* Raw argv accessors for the island's process shim (scr_island.c): the
  * island's process.argv must match the static world's ["scriptc",
@@ -261,8 +275,7 @@ ScrStr *scr_env_get(const ScrStr *name) {
   if (need == 0) return NULL; /* absent (an empty value still needs its NUL) */
   char *buf = malloc(need);
   if (!buf) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   DWORD got = GetEnvironmentVariableA(name->data, buf, need);
   ScrStr *s = scr_str_new(buf, got);
@@ -553,8 +566,7 @@ bool scr_process_kill_named(double pid, const ScrStr *signal) {
     size_t cap = 16 + signal->len + 1;
     char *msg = malloc(cap);
     if (!msg) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     int len = snprintf(msg, cap, "Unknown signal: %s", signal->data);
     scr_throw_error_msg(SCR_ERR_TYPE, msg, (size_t)len);
@@ -567,8 +579,7 @@ bool scr_process_kill_named(double pid, const ScrStr *signal) {
 ScrStr *scr_process_cwd(void) {
   char buf[4096];
   if (!getcwd(buf, sizeof buf)) {
-    fputs("scriptc: process.cwd() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: process.cwd() failed\n");
   }
   return scr_str_new(buf, strlen(buf));
 }
@@ -612,16 +623,14 @@ bool scr_proc_stream_write(double fd, const ScrStr *data) {
 ScrStr *scr_os_homedir(void) {
   const char *home = getenv("USERPROFILE");
   if (home && home[0] != '\0') return scr_str_new(home, strlen(home));
-  fputs("scriptc: os.homedir() failed\n", stderr);
-  abort();
+  scr_trap("scriptc: os.homedir() failed\n");
 }
 
 ScrStr *scr_os_user_name(void) {
   char buf[UNLEN + 1];
   DWORD n = sizeof buf;
   if (!GetUserNameA(buf, &n) || n == 0) {
-    fputs("scriptc: os.userInfo() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.userInfo() failed\n");
   }
   return scr_str_new(buf, n - 1); /* n counts the NUL */
 }
@@ -648,8 +657,7 @@ ScrStr *scr_os_release(void) {
   RtlGetVersionFn fn =
       ntdll ? (RtlGetVersionFn)(void *)GetProcAddress(ntdll, "RtlGetVersion") : NULL;
   if (fn == NULL || fn(&info) != 0) {
-    fputs("scriptc: os.release() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.release() failed\n");
   }
   char buf[64];
   int len = snprintf(buf, sizeof buf, "%lu.%lu.%lu", (unsigned long)info.dwMajorVersion,
@@ -676,8 +684,7 @@ ScrStr *scr_os_tmpdir(void) {
   char buf[MAX_PATH + 2];
   DWORD n = GetTempPathA(sizeof buf, buf);
   if (n == 0 || n >= sizeof buf) {
-    fputs("scriptc: os.tmpdir() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.tmpdir() failed\n");
   }
   size_t len = n;
   if (len > 1 && (buf[len - 1] == '\\' || buf[len - 1] == '/')) len--;
@@ -693,8 +700,7 @@ ScrStr *scr_os_homedir(void) {
   struct passwd *result = NULL;
   char buf[8192];
   if (getpwuid_r(getuid(), &pw, buf, sizeof buf, &result) != 0 || !result || !result->pw_dir) {
-    fputs("scriptc: os.homedir() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.homedir() failed\n");
   }
   return scr_str_new(result->pw_dir, strlen(result->pw_dir));
 }
@@ -706,8 +712,7 @@ ScrStr *scr_os_homedir(void) {
 static const struct passwd *scr_os_passwd(char *buf, size_t cap, struct passwd *pw) {
   struct passwd *result = NULL;
   if (getpwuid_r(getuid(), pw, buf, cap, &result) != 0 || !result) {
-    fputs("scriptc: os.userInfo() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.userInfo() failed\n");
   }
   return result;
 }
@@ -740,8 +745,7 @@ ScrStr *scr_os_release(void) {
   /* uname(2)'s release field — Node's uv_os_uname()-backed answer. */
   struct utsname u;
   if (uname(&u) != 0) {
-    fputs("scriptc: os.release() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.release() failed\n");
   }
   return scr_str_new(u.release, strlen(u.release));
 }
@@ -750,8 +754,7 @@ ScrStr *scr_os_type(void) {
   /* uname(2)'s sysname field ("Darwin", "Linux") — Node's os.type(). */
   struct utsname u;
   if (uname(&u) != 0) {
-    fputs("scriptc: os.type() failed\n", stderr);
-    abort();
+    scr_trap("scriptc: os.type() failed\n");
   }
   return scr_str_new(u.sysname, strlen(u.sysname));
 }
@@ -824,20 +827,20 @@ struct ScrIfaddrs {
  * stance. */
 ScrIfaddrs *scr_os_ifaddrs(void) {
   ScrIfaddrs *s = calloc(1, sizeof *s);
-  if (!s) abort();
+  if (!s) scr_trap("scriptc: out of memory\n");
   ULONG flags = GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
                 GAA_FLAG_SKIP_DNS_SERVER;
   ULONG size = 16 * 1024;
   IP_ADAPTER_ADDRESSES *adapters = NULL;
   for (int tries = 0; tries < 4; tries++) {
     adapters = realloc(adapters, size);
-    if (!adapters) abort();
+    if (!adapters) scr_trap("scriptc: out of memory\n");
     ULONG rc = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, adapters, &size);
     if (rc == ERROR_SUCCESS) break;
     if (rc != ERROR_BUFFER_OVERFLOW) {
       free(adapters);
       s->rows = calloc(1, sizeof *s->rows);
-      if (!s->rows) abort();
+      if (!s->rows) scr_trap("scriptc: out of memory\n");
       return s; /* empty snapshot */
     }
   }
@@ -850,7 +853,7 @@ ScrIfaddrs *scr_os_ifaddrs(void) {
     }
   }
   s->rows = calloc(count ? count : 1, sizeof *s->rows);
-  if (!s->rows) abort();
+  if (!s->rows) scr_trap("scriptc: out of memory\n");
   for (IP_ADAPTER_ADDRESSES *a = adapters; a != NULL; a = a->Next) {
     if (a->OperStatus != IfOperStatusUp || a->FirstUnicastAddress == NULL) continue;
     char name[64] = "";
@@ -934,7 +937,7 @@ static int scr_netmask_prefix(const unsigned char *bytes, size_t len) {
 
 ScrIfaddrs *scr_os_ifaddrs(void) {
   ScrIfaddrs *s = calloc(1, sizeof *s);
-  if (!s) abort();
+  if (!s) scr_trap("scriptc: out of memory\n");
   struct ifaddrs *addrs = NULL;
   if (getifaddrs(&addrs) != 0) return s;
   size_t count = 0;
@@ -942,7 +945,7 @@ ScrIfaddrs *scr_os_ifaddrs(void) {
     if (scr_ifaddr_row_ok(ent)) count++;
   }
   s->rows = calloc(count ? count : 1, sizeof *s->rows);
-  if (!s->rows) abort();
+  if (!s->rows) scr_trap("scriptc: out of memory\n");
   for (struct ifaddrs *ent = addrs; ent != NULL; ent = ent->ifa_next) {
     if (!scr_ifaddr_row_ok(ent)) continue;
     ScrIfaddrRow *row = &s->rows[s->n++];
@@ -1093,6 +1096,16 @@ double scr_process_uptime(void) {
   return (scr_uptime_now_ms() - scr_uptime_t0_ms) / 1000.0;
 }
 
+/* perf_hooks performance.now(): milliseconds since the process's own
+ * start (Node's timeOrigin anchor), fractional — the same monotonic
+ * clock and anchor as uptime, in Node's performance.now units. */
+double scr_perf_now(void) {
+#ifdef _WIN32
+  if (scr_uptime_t0_ms == 0) scr_uptime_anchor_init();
+#endif
+  return scr_uptime_now_ms() - scr_uptime_t0_ms;
+}
+
 #ifdef _WIN32
 /* GetProcessTimes/GetThreadTimes answer 100ns units; Node reports µs. */
 static double scr_filetime_us(FILETIME ft) {
@@ -1409,8 +1422,7 @@ void scr_fs_throw(int e, const char *op, const ScrStr *path) {
   size_t cap = strlen(name) + strlen(text) + strlen(op) + strlen(shown) + 8;
   char *msg = malloc(cap);
   if (!msg) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   int len = snprintf(msg, cap, "%s: %s, %s '%s'", name, text, op, shown);
   /* A real Error instance (name "Error", message = Node's text) — what a
@@ -1433,16 +1445,14 @@ ScrStr *scr_fs_read_file(ScrStr *path) {
   size_t cap = 4096, len = 0;
   char *buf = malloc(cap);
   if (!buf) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   for (;;) {
     if (cap - len < 2048) {
       cap *= 2;
       char *grown = realloc(buf, cap);
       if (!grown) {
-        fputs("scriptc: out of memory\n", stderr);
-        abort();
+        scr_trap("scriptc: out of memory\n");
       }
       buf = grown;
     }
@@ -1688,8 +1698,7 @@ static void scr_fs_throw2(int e, const char *op, const ScrStr *src, const ScrStr
   size_t cap = strlen(name) + strlen(text) + strlen(op) + strlen(shown_src) + strlen(shown_dest) + 16;
   char *msg = malloc(cap);
   if (!msg) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   int len = snprintf(msg, cap, "%s: %s, %s '%s' -> '%s'", name, text, op, shown_src, shown_dest);
   scr_throw_error_msg_code(SCR_ERR_ERROR, msg, (size_t)len, name);
@@ -1846,8 +1855,7 @@ static void scr_mkdir_rec(char *path, size_t len, mode_t mode) {
 void scr_fs_mkdir_recursive(ScrStr *path) {
   char *buf = malloc(path->len + 1);
   if (!buf) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   memcpy(buf, path->data, path->len + 1); /* ScrStr data is NUL-terminated */
   scr_mkdir_rec(buf, path->len, 0777);
@@ -1859,8 +1867,7 @@ void scr_fs_mkdir_recursive(ScrStr *path) {
 void scr_fs_mkdir_recursive_mode(ScrStr *path, double mode) {
   char *buf = malloc(path->len + 1);
   if (!buf) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   memcpy(buf, path->data, path->len + 1);
   scr_mkdir_rec(buf, path->len, (mode_t)mode);
@@ -1907,8 +1914,7 @@ static void scr_rm_tree_e(const char *path, size_t len, ScrRmFail *f) {
     size_t namelen = strlen(ent->d_name);
     char *child = malloc(len + 1 + namelen + 1);
     if (!child) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     memcpy(child, path, len);
     child[len] = '/';
@@ -2011,8 +2017,7 @@ static char *scr_win_mkdtemp(char *tmpl) {
 ScrStr *scr_fs_mkdtemp(ScrStr *prefix) {
   char *tmpl = malloc(prefix->len + 7);
   if (!tmpl) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   memcpy(tmpl, prefix->data, prefix->len);
   memcpy(tmpl + prefix->len, "XXXXXX", 7);
@@ -2059,16 +2064,14 @@ static char *scr_read_fd_all(double fd, size_t *out_len) {
   size_t cap = 4096, len = 0;
   char *buf = malloc(cap);
   if (!buf) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   for (;;) {
     if (cap - len < 2048) {
       cap *= 2;
       char *grown = realloc(buf, cap);
       if (!grown) {
-        fputs("scriptc: out of memory\n", stderr);
-        abort();
+        scr_trap("scriptc: out of memory\n");
       }
       buf = grown;
     }
@@ -2276,8 +2279,7 @@ double scr_stats_mtime_ms(ScrStats *s) { return s->mtime_ms; }
 static ScrStats *scr_stats_of(const struct stat *st) {
   ScrStats *s = malloc(sizeof(ScrStats));
   if (!s) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   s->rc = 1;
   s->is_file = S_ISREG(st->st_mode);
@@ -2374,16 +2376,14 @@ ScrScandir *scr_fs_scandir(ScrStr *path) {
   }
   ScrScandir *s = malloc(sizeof *s);
   if (!s) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   s->len = 0;
   s->cap = 8;
   s->names = malloc(s->cap * sizeof *s->names);
   s->kinds = malloc(s->cap);
   if (!s->names || !s->kinds) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   const struct dirent *ent;
   while ((ent = readdir(d)) != NULL) {
@@ -2424,8 +2424,7 @@ ScrScandir *scr_fs_scandir(ScrStr *path) {
       s->names = realloc(s->names, s->cap * sizeof *s->names);
       s->kinds = realloc(s->kinds, s->cap);
       if (!s->names || !s->kinds) {
-        fputs("scriptc: out of memory\n", stderr);
-        abort();
+        scr_trap("scriptc: out of memory\n");
       }
     }
     s->names[s->len] = scr_str_new(ent->d_name, strlen(ent->d_name));
@@ -2535,8 +2534,7 @@ ScrStr *scr_crypto_random_string(double n, ScrStr *enc) {
   size_t size = (size_t)n;
   unsigned char *bytes = malloc(size ? size : 1);
   if (!bytes) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   arc4random_buf(bytes, size);
   ScrStr *out;
@@ -2544,8 +2542,7 @@ ScrStr *scr_crypto_random_string(double n, ScrStr *enc) {
     static const char hex[] = "0123456789abcdef";
     char *buf = malloc(size * 2 + 1);
     if (!buf) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     for (size_t i = 0; i < size; i++) {
       buf[i * 2] = hex[bytes[i] >> 4];
@@ -2559,8 +2556,7 @@ ScrStr *scr_crypto_random_string(double n, ScrStr *enc) {
     size_t outlen = (size + 2) / 3 * 4;
     char *buf = malloc(outlen + 1);
     if (!buf) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     size_t o = 0;
     for (size_t i = 0; i < size; i += 3) {
@@ -2899,8 +2895,7 @@ static bool scr_x509_der(const uint8_t *in, size_t n, const uint8_t **der, size_
     }
     uint8_t *out = malloc(((size_t)(stop - b) / 4 + 1) * 3 + 3);
     if (!out) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     size_t o = 0;
     unsigned acc = 0;
@@ -3116,8 +3111,7 @@ static uint32_t scr_to_uint32(double d);
 static ScrStr *scr_str_from_units(size_t n, uint32_t (*unit)(void *, size_t), void *src) {
   char *out = malloc(n * 3 + 1); /* worst case: 3 bytes per UTF-16 unit */
   if (!out) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   size_t o = 0;
   for (size_t i = 0; i < n; i++) {

package/src/scr_library.c

@@ -0,0 +1,222 @@
+/* Library mode support: the panic sink, the poisoned-library flag, the
+ * outbound-result arena, the reset registry, and the sink-routing trap
+ * funnel. Linked ONLY into library artifacts (every TU of a library archive
+ * compiles with -DSCR_LIB); executable builds never contain this file —
+ * their funnel expansion lives in scr_console.c and their session teardown
+ * stays atexit-driven.
+ *
+ * The profile-NAMED symbols (init, sink registration, reset, collect) are
+ * emitted in the program TU and delegate here, so this file stays
+ * profile-agnostic and the program TU carries every profile-named symbol —
+ * one place for the conformance symbol audit to look.
+ *
+ * State after a sink call: none is legal. The trap fired mid-operation with
+ * no unwinding — heap, arena, and collector state are unspecified; the library
+ * is POISONED. Every runtime-touching entry prologue aborts on the flag
+ * (deterministic, never heap corruption); recovery is process restart. */
+#include "scr_runtime.h"
+
+#ifdef SCR_LIB
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* ── sink registration + poison ───────────────────────────────────────── */
+
+static ScrLibSinkFn scr_library_sink = NULL;
+static void *scr_library_sink_ctx = NULL;
+static bool scr_library_poisoned = false;
+
+void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
+  /* Latest registration wins; re-registration is permitted before a trap.
+   * Deliberately NOT poison-guarded: a pure store, touching no runtime
+   * state — but a poisoned library's entries abort regardless of the sink. */
+  scr_library_sink = fn;
+  scr_library_sink_ctx = ctx;
+}
+
+/* ── the trap funnel, library expansion ───────────────────────────────────
+ * Poison first (the sink may longjmp to a host frame below the entry — the
+ * conforming survival pattern), then deliver exactly once, then abort:
+ * before registration, or if the sink returns (the ruled host-contract
+ * violation). The address is the funnel frame's return address — the trap
+ * site — 0 where the toolchain cannot supply one. */
+
+#if defined(__GNUC__) || defined(__clang__)
+#define SCR_TRAP_ADDR() ((uint64_t)(uintptr_t)__builtin_return_address(0))
+#else
+#define SCR_TRAP_ADDR() ((uint64_t)0)
+#endif
+
+static _Noreturn void scr_library_trap_deliver(const char *msg, size_t len, uint64_t addr) {
+  scr_library_poisoned = true;
+  if (scr_library_sink != NULL) {
+    scr_library_sink(scr_library_sink_ctx, (const uint8_t *)msg, len, addr);
+  }
+  abort();
+}
+
+__attribute__((noinline)) _Noreturn void scr_trap(const char *msg) {
+  scr_library_trap_deliver(msg, strlen(msg), SCR_TRAP_ADDR());
+}
+
+__attribute__((noinline)) _Noreturn void scr_trap_fmt(const char *fmt, ...) {
+  static char buf[512]; /* no malloc on the invariant-failure path */
+  va_list ap;
+  va_start(ap, fmt);
+  int n = vsnprintf(buf, sizeof buf, fmt, ap);
+  va_end(ap);
+  size_t len = n < 0 ? 0 : (size_t)n >= sizeof buf ? sizeof buf - 1 : (size_t)n;
+  scr_library_trap_deliver(buf, len, SCR_TRAP_ADDR());
+}
+
+/* ── entry prologues ──────────────────────────────────────────────────── */
+
+void scr_library_entry(bool reset_arena) {
+  /* A poisoned library's entries abort deterministically — never through the
+   * sink again (it received its exactly-once message when the trap fired),
+   * never into a heap whose invariants already failed. */
+  if (scr_library_poisoned) abort();
+  if (reset_arena) scr_library_arena_reset();
+}
+
+/* ── the outbound-result arena ────────────────────────────────────────────
+ * Buffer-class results (string/bytes) MOVE in here; the host reads through
+ * borrowed pointers until the arena resets (per-entry under the auto
+ * posture, host-cycled when the profile declares a reset symbol; init and
+ * collect always reset). */
+
+typedef struct {
+  void *v;
+  bool is_str; /* ScrStr vs ScrBytes — picks the release */
+} ScrCoreArenaEnt;
+
+static ScrCoreArenaEnt *scr_library_arena = NULL;
+static size_t scr_library_arena_n = 0, scr_library_arena_cap = 0;
+
+static void scr_library_arena_keep(void *v, bool is_str) {
+  if (scr_library_arena_n == scr_library_arena_cap) {
+    scr_library_arena_cap = scr_library_arena_cap ? scr_library_arena_cap * 2 : 16;
+    scr_library_arena = realloc(scr_library_arena, scr_library_arena_cap * sizeof *scr_library_arena);
+    if (!scr_library_arena) scr_trap("scriptc: out of memory\n");
+  }
+  scr_library_arena[scr_library_arena_n].v = v;
+  scr_library_arena[scr_library_arena_n].is_str = is_str;
+  scr_library_arena_n++;
+}
+
+void scr_library_arena_reset(void) {
+  for (size_t i = 0; i < scr_library_arena_n; i++) {
+    if (scr_library_arena[i].is_str) scr_str_release((ScrStr *)scr_library_arena[i].v);
+    else scr_bytes_release((ScrBytes *)scr_library_arena[i].v);
+  }
+  scr_library_arena_n = 0;
+}
+
+void scr_library_collect(void) {
+  scr_library_arena_reset();
+  scr_collect_cycles();
+}
+
+/* ── marshalling helpers (both emissions call exactly these) ──────────── */
+
+ScrStr *scr_library_str_in(const uint8_t *p, size_t len) {
+  /* ptr may be NULL when len is 0 (the contract's empty-buffer form). */
+  return scr_str_new(len == 0 ? "" : (const char *)p, len);
+}
+
+ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len) {
+  ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)len);
+  if (b == NULL) {
+    /* scr_bytes_new throws only for lengths past 2^53-1 — an impossible
+     * host buffer; funnel the contract violation instead of a NULL deref. */
+    scr_exc_clear();
+    scr_trap("scriptc: library inbound bytes length out of range\n");
+  }
+  if (len > 0 && p != NULL) memcpy(b->data, p, len);
+  return b;
+}
+
+void scr_library_str_out(ScrStr *s, const uint8_t **out, size_t *out_len) {
+  scr_library_arena_keep(s, true);
+  *out = (const uint8_t *)s->data; /* NUL-terminated after len (ScrStr layout) */
+  *out_len = s->len;
+}
+
+void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len) {
+  scr_library_arena_keep(b, false);
+  *out = b->data; /* elem is always u8 at the boundary (v1 bytes class) */
+  *out_len = b->len;
+}
+
+/* ── the reset registry + session reset ─────────────────────────────────
+ * Where an executable's always-linked units atexit() their lazy teardowns,
+ * library builds register here (scr_atexit in scr_runtime.h): registered
+ * once, drained on EVERY reset — re-registration guards in the units stay
+ * satisfied because the entry persists. */
+
+#define SCR_LIB_MAX_RESETS 32
+static void (*scr_library_resets[SCR_LIB_MAX_RESETS])(void);
+static size_t scr_library_nresets = 0;
+
+void scr_library_register_reset(void (*fn)(void)) {
+  for (size_t i = 0; i < scr_library_nresets; i++) {
+    if (scr_library_resets[i] == fn) return;
+  }
+  if (scr_library_nresets == SCR_LIB_MAX_RESETS) {
+    scr_trap("scriptc: internal error: library reset registry overflow\n");
+  }
+  scr_library_resets[scr_library_nresets++] = fn;
+}
+
+#ifdef SCR_RC_AUDIT
+extern long scr_str_live_count(void);     /* scr_string.c */
+extern long scr_arr_live_count(void);     /* scr_array.c */
+extern long scr_map_live_count(void);     /* scr_map.c */
+extern long scr_box_live_count(void);     /* scr_closure.c */
+extern long scr_closure_live_count(void); /* scr_closure.c */
+extern long scr_obj_live_count(void);     /* scr_object.c */
+extern long scr_union_live_count(void);   /* scr_union.c */
+extern long scr_dyn_live_count(void);     /* scr_json.c */
+extern long scr_bytes_live_count(void);   /* scr_bytes.c */
+
+/* The per-session heap-emptiness assertion (the audit flavor's determinism
+ * seam): after a full reset the live counters must all read zero, or the
+ * previous session leaked. A failure is a TRAP through the sink — the
+ * executable audit's _Exit(99) stays exe-lane-only. */
+static void scr_library_audit_zero(void) {
+  long strings = scr_str_live_count(), arrays = scr_arr_live_count(),
+       maps = scr_map_live_count(), boxes = scr_box_live_count(),
+       closures = scr_closure_live_count(), objects = scr_obj_live_count(),
+       unions = scr_union_live_count(), dyns = scr_dyn_live_count(),
+       bytes = scr_bytes_live_count();
+  if (strings != 0 || arrays != 0 || maps != 0 || boxes != 0 || closures != 0 ||
+      objects != 0 || unions != 0 || dyns != 0 || bytes != 0) {
+    scr_trap_fmt(
+        "scriptc LIBRARY RC AUDIT FAILED: %ld heap string(s), %ld array(s), "
+        "%ld map(s), %ld box(es), %ld closure(s), %ld object(s), "
+        "%ld union(s), %ld dyn value(s), %ld bytes value(s) live across re-init\n",
+        strings, arrays, maps, boxes, closures, objects, unions, dyns, bytes);
+  }
+}
+#endif /* SCR_RC_AUDIT */
+
+extern void scr_lib_session_cleanup(void); /* scr_lib.c: the interned process values */
+
+void scr_library_reset(void) {
+  /* Called by the generated init entry AFTER the program TU released and
+   * zeroed its globals (run-once guards included) — the same order the
+   * executable exit path runs: library cleanup → cycle collection → RC
+   * audit. Everything here is re-runnable; the first call is a cheap
+   * no-op pass. */
+  scr_exc_clear();
+  scr_library_arena_reset();
+  for (size_t i = 0; i < scr_library_nresets; i++) scr_library_resets[i]();
+  scr_lib_session_cleanup();
+  scr_collect_cycles();
+#ifdef SCR_RC_AUDIT
+  scr_library_audit_zero();
+#endif
+}
+
+#endif /* SCR_LIB */

package/src/scr_map.c

@@ -31,8 +31,7 @@ long scr_map_live_count(void) { return scr_live_maps; }
 #define SCR_MAP_EMPTY SIZE_MAX
 
 static void scr_map_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── key normalization + hashing (SameValueZero) ───────────────────────
@@ -462,8 +461,7 @@ bool scr_map_iter_live(const ScrMap *m, double i) {
 
 static const ScrMapEntry *scr_map_iter_at(const ScrMap *m, double i) {
   if (!(i >= 0) || i >= (double)m->nentries || !m->entries[(size_t)i].live) {
-    fputs("scriptc: internal error: map iteration index out of range\n", stderr);
-    abort();
+    scr_trap("scriptc: internal error: map iteration index out of range\n");
   }
   return &m->entries[(size_t)i];
 }

package/src/scr_path.c

@@ -37,8 +37,7 @@ static void pb_init(PathBuf *b) {
   b->len = 0;
   b->data = malloc(b->cap);
   if (!b->data) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
 }
 
@@ -47,8 +46,7 @@ static void pb_reserve(PathBuf *b, size_t extra) {
   while (b->len + extra > b->cap) b->cap *= 2;
   char *grown = realloc(b->data, b->cap);
   if (!grown) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   b->data = grown;
 }
@@ -226,8 +224,7 @@ ScrStr *scr_path_join(ScrArr *parts) {
 static void scr_path_cwd(PathBuf *out) {
   char buf[4096];
   if (!getcwd(buf, sizeof buf)) {
-    fputs("scriptc: path.resolve: getcwd failed\n", stderr);
-    abort();
+    scr_trap("scriptc: path.resolve: getcwd failed\n");
   }
   pb_append(out, buf, strlen(buf));
 }
@@ -984,8 +981,7 @@ ScrStr *scr_path_win32_relative(ScrStr *from, ScrStr *to) {
   char *flow = malloc(rfrom->len ? rfrom->len : 1);
   char *tlow = malloc(rto->len ? rto->len : 1);
   if (!flow || !tlow) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   for (size_t k = 0; k < rfrom->len; k++) flow[k] = scr_path_w32_lower(rfrom->data[k]);
   for (size_t k = 0; k < rto->len; k++) tlow[k] = scr_path_w32_lower(rto->data[k]);