@scriptc/runtime 0.0.4 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "scriptc native runtime — C sources, compiled into every scriptc binary",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/src/scr_array.c

@@ -13,8 +13,7 @@ long scr_arr_live_count(void) { return scr_live_arrays; }
 #endif
 
 static void scr_arr_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* JS would return undefined for an OOB read and create holes for a far OOB
@@ -23,10 +22,8 @@ static void scr_arr_oom(void) {
 static void scr_arr_trap_oob(double i, size_t len) {
   char buf[32];
   scr_f64_to_str(i, buf);
-  fprintf(stderr,
-          "scriptc: RangeError: array index %s out of bounds (length %zu)\n",
-          buf, len);
-  abort();
+  scr_trap_fmt("scriptc: RangeError: array index %s out of bounds (length %zu)\n",
+               buf, len);
 }
 
 /* Validate i as an element index. limit is a->len for reads, a->len + 1 for
@@ -264,8 +261,7 @@ double scr_arr_push_ref(ScrArr *a, void *v) {
 
 static uint64_t scr_arr_pop_slot(ScrArr *a) {
   if (a->len == 0) {
-    fputs("scriptc: RangeError: pop() on an empty array\n", stderr);
-    abort();
+    scr_trap("scriptc: RangeError: pop() on an empty array\n");
   }
   return a->data[--a->len];
 }
@@ -283,8 +279,7 @@ void *scr_arr_pop_ref(ScrArr *a) { return scr_slot_to_ptr(scr_arr_pop_slot(a));
  * ownership moves out to the caller (no retain). */
 static uint64_t scr_arr_shift_slot(ScrArr *a) {
   if (a->len == 0) {
-    fputs("scriptc: internal error: shift() on an empty array\n", stderr);
-    abort();
+    scr_trap("scriptc: internal error: shift() on an empty array\n");
   }
   uint64_t s = a->data[0];
   a->len--;
@@ -456,8 +451,7 @@ ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
       case SCR_ELEM_BYTES:
       case SCR_ELEM_REF:
         /* The compiler rejects join on ref-element arrays (SC1090). */
-        fputs("scriptc: internal error: join on a ref-element array\n", stderr);
-        abort();
+        scr_trap("scriptc: internal error: join on a ref-element array\n");
     }
   }
   ScrStr *out = scr_str_new(buf, len);

package/src/scr_assert.c

@@ -32,8 +32,7 @@
 #include <string.h>
 
 static void scr_assert_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── a tiny append-only byte buffer for message assembly ─────────────── */

package/src/scr_bytes.c

@@ -17,8 +17,7 @@ long scr_bytes_live_count(void) { return scr_live_bytes; }
 #endif
 
 static void scr_bytes_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 size_t scr_bytes_elem_size(ScrBytesElem elem) {
@@ -98,10 +97,8 @@ static size_t scr_bytes_check_index(const ScrBytes *b, double i) {
   if (!(i >= 0) || i != trunc(i) || i >= (double)b->len) {
     char buf[32];
     scr_f64_to_str(i, buf);
-    fprintf(stderr,
-            "scriptc: RangeError: typed array index %s out of bounds (length %zu)\n",
-            buf, b->len);
-    abort();
+    scr_trap_fmt("scriptc: RangeError: typed array index %s out of bounds (length %zu)\n",
+                 buf, b->len);
   }
   return (size_t)i;
 }

package/src/scr_bytes_io.c

@@ -12,8 +12,7 @@
 #include <string.h>
 
 static void scr_bytes_io_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── fs (the Buffer forms of scr_lib.c's utf8 pair) ────────────────────── */

package/src/scr_closure.c

@@ -146,8 +146,7 @@ void *scr_box_get_ref(ScrBox *b) {
   case SCR_BOX_OBJ:
     return b->obj_retain(p);
   default:
-    fputs("scriptc: internal error: box_get_ref on a scalar box\n", stderr);
-    abort();
+    scr_trap("scriptc: internal error: box_get_ref on a scalar box\n");
   }
 }
 

package/src/scr_console.c

@@ -14,6 +14,7 @@
 static long scr_abandoned_fibers = 0;
 void scr_note_abandoned_fibers(long n) { scr_abandoned_fibers = n; }
 
+#ifndef SCR_LIB
 #ifdef SCR_RC_AUDIT
 extern long scr_str_live_count(void);     /* scr_string.c */
 extern long scr_arr_live_count(void);     /* scr_array.c */
@@ -96,6 +97,10 @@ void scr_init(void) {
 #endif
   atexit(scr_collect_cycles_at_exit);
 }
+#endif /* !SCR_LIB — a library artifact never touches host stdio modes/buffering and
+        * registers no atexit handlers: scr_init and its exit hooks (the
+        * audit's _Exit(99) included) are executable-lane machinery; the
+        * library session reset lives in scr_library.c. */
 
 /* ONE formatter for both console streams — console.error/warn print
  * byte-identically to console.log in Node (same inspect rendering), only

package/src/scr_cycle.c

@@ -39,8 +39,7 @@
 #define SCR_RC(obj) (*(size_t *)(obj))
 
 static void scr_cyc_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 void *scr_cyc_alloc(size_t size, ScrTraceFn trace, ScrCycFreeFn free_fn) {

package/src/scr_error.c

@@ -14,8 +14,7 @@
 #include <stdlib.h>
 
 static void scr_error_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 static bool scr_error_traced = false;
@@ -247,8 +246,7 @@ void scr_undef_global_read(ScrStr *name) {
   size_t len = name->len + sizeof suffix - 1;
   char *msg = malloc(len + 1);
   if (!msg) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   memcpy(msg, name->data, name->len);
   memcpy(msg + name->len, suffix, sizeof suffix);

package/src/scr_events_emitter.c

@@ -54,8 +54,7 @@
 #endif
 
 static void scr_ee_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* One registered listener. Shared between the live list and emit

package/src/scr_exception.c

@@ -13,6 +13,28 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#ifndef SCR_LIB
+/* The trap funnel's EXECUTABLE expansion: exactly the historical
+ * fputs/vfprintf-to-stderr + abort every trap site used to open-code — the
+ * default lane's bytes and behavior are unchanged by construction. Library
+ * builds (-DSCR_LIB) get the sink-routing definitions from scr_library.c
+ * instead; this pair compiles out there. Lives HERE (the failure-channel
+ * unit, present in every link including the runtime's own unit-test
+ * subsets) rather than in the console unit. */
+_Noreturn void scr_trap(const char *msg) {
+  fputs(msg, stderr);
+  abort();
+}
+
+_Noreturn void scr_trap_fmt(const char *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  va_end(ap);
+  abort();
+}
+#endif /* !SCR_LIB */
+
 static ScrExcCell scr_main_exc; /* fiber zero (the main stack) */
 static ScrExcCell *scr_cur = &scr_main_exc;
 
@@ -60,8 +82,7 @@ void scr_exc_clear(void) { scr_exc_reset(); }
 ScrCaught *scr_exc_take(void) {
   ScrCaught *c = calloc(1, sizeof *c);
   if (!c) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   c->rc = 1;
   c->kind = scr_exc_kind;
@@ -154,6 +175,70 @@ ScrStr *scr_caught_to_string(const ScrCaught *c) {
   return scr_str_new("", 0);
 }
 
+#ifdef SCR_LIB
+/* An exception that escaped user code into a generated entry wrapper: the
+ * host contract is that declared entries do not throw, so an escape is a
+ * contract-shaped failure exactly like a trap. Render the same "Uncaught
+ * ..." first line the executable epilogue prints (scr_exc_print_uncaught's
+ * arms, buffer-writing), release the payload, and route the text through
+ * the trap funnel — one failure channel at the boundary. */
+void scr_library_check_exc(void) {
+  if (!scr_exc_pending()) return;
+  static char buf[1024]; /* the message is copied out before the payload dies */
+  size_t n = 0;
+  const char prefix[] = "Uncaught ";
+  memcpy(buf, prefix, sizeof prefix - 1);
+  n = sizeof prefix - 1;
+  const size_t cap = sizeof buf - 2; /* room for '\n' + NUL */
+  switch (scr_exc_kind) {
+  case SCR_EXC_F64:
+    n += scr_f64_to_str(scr_exc_f64, buf + n);
+    break;
+  case SCR_EXC_BOOL: {
+    const char *b = scr_exc_bool ? "true" : "false";
+    size_t bl = strlen(b);
+    memcpy(buf + n, b, bl);
+    n += bl;
+    break;
+  }
+  case SCR_EXC_STR: {
+    const ScrStr *s = (const ScrStr *)scr_exc_payload;
+    size_t take = s->len > cap - n ? cap - n : s->len;
+    memcpy(buf + n, s->data, take);
+    n += take;
+    break;
+  }
+  case SCR_EXC_OBJ:
+    if (scr_error_is(scr_exc_payload)) {
+      ScrStr *s = scr_error_to_string((ScrError *)scr_exc_payload);
+      size_t take = s->len > cap - n ? cap - n : s->len;
+      memcpy(buf + n, s->data, take);
+      n += take;
+      scr_str_release(s);
+      break;
+    }
+    /* fall through: non-Error hierarchy objects render like other refs */
+  case SCR_EXC_REF: {
+    const char obj[] = "[object]";
+    memcpy(buf + n, obj, sizeof obj - 1);
+    n += sizeof obj - 1;
+    break;
+  }
+  case SCR_EXC_NONE:
+  case SCR_EXC_GENRET: { /* unreachable through the pending() gate */
+    const char none[] = "(no exception)";
+    memcpy(buf + n, none, sizeof none - 1);
+    n += sizeof none - 1;
+    break;
+  }
+  }
+  buf[n++] = '\n';
+  buf[n] = '\0';
+  scr_exc_reset(); /* the payload is released before the funnel poisons */
+  scr_trap(buf);
+}
+#endif /* SCR_LIB */
+
 void scr_throw_f64(double v) {
   scr_exc_reset();
   scr_exc_kind = SCR_EXC_F64;

package/src/scr_inspect.c

@@ -31,8 +31,7 @@
 #include <string.h>
 
 static void insp_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── a tiny append-only byte buffer ──────────────────────────────────── */

package/src/scr_json.c

@@ -36,8 +36,7 @@ long scr_dyn_live_count(void) { return scr_live_dyns; }
 #endif
 
 static void scr_json_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── output buffer ─────────────────────────────────────────────────────
@@ -421,8 +420,7 @@ void scr_dyn_handle_install(ScrDynHandleTag tag, const ScrDynHandleOps *ops) {
 static const ScrDynHandleOps *scr_dyn_handle_ops(ScrDynHandleTag tag) {
   const ScrDynHandleOps *ops = scr_dynh_ops[tag];
   if (!ops) {
-    fputs("scriptc: internal error: dyn handle ops not installed\n", stderr);
-    abort();
+    scr_trap("scriptc: internal error: dyn handle ops not installed\n");
   }
   return ops;
 }
@@ -501,8 +499,7 @@ static ScrDynThisEnt *scr_dyn_this_grow(void) {
     size_t cap = scr_dyn_this_cap ? scr_dyn_this_cap * 2 : 8;
     ScrDynThisEnt *s = realloc(scr_dyn_this_stack, cap * sizeof *s);
     if (!s) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     scr_dyn_this_stack = s;
     scr_dyn_this_cap = cap;
@@ -526,8 +523,7 @@ void scr_dyn_this_push_dyn(const ScrDyn *v) {
 
 void scr_dyn_this_pop(void) {
   if (scr_dyn_this_n == 0) {
-    fputs("scriptc: internal error: receiver stack underflow\n", stderr);
-    abort();
+    scr_trap("scriptc: internal error: receiver stack underflow\n");
   }
   ScrDynThisEnt *e = &scr_dyn_this_stack[--scr_dyn_this_n];
   if (e->dv) scr_dyn_release(e->dv);
@@ -763,13 +759,12 @@ ScrDyn *scr_dyn_from_error(const ScrError *e) {
     scr_errdyn_cap = scr_errdyn_cap ? scr_errdyn_cap * 2 : 8;
     scr_errdyn_cache = realloc(scr_errdyn_cache, scr_errdyn_cap * sizeof *scr_errdyn_cache);
     if (!scr_errdyn_cache) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
   }
   if (!scr_errdyn_teardown_registered) {
     scr_errdyn_teardown_registered = true;
-    atexit(scr_errdyn_teardown);
+    scr_atexit(scr_errdyn_teardown);
   }
   scr_errdyn_cache[scr_errdyn_n].err = scr_error_retain((ScrError *)e);
   scr_errdyn_cache[scr_errdyn_n].dyn = scr_dyn_retain(d);
@@ -824,13 +819,12 @@ void scr_errdyn_put(ScrError *e, ScrDyn *d) {
     scr_errdyn_cap = scr_errdyn_cap ? scr_errdyn_cap * 2 : 8;
     scr_errdyn_cache = realloc(scr_errdyn_cache, scr_errdyn_cap * sizeof *scr_errdyn_cache);
     if (!scr_errdyn_cache) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
   }
   if (!scr_errdyn_teardown_registered) {
     scr_errdyn_teardown_registered = true;
-    atexit(scr_errdyn_teardown);
+    scr_atexit(scr_errdyn_teardown);
   }
   scr_errdyn_cache[scr_errdyn_n].err = scr_error_retain(e);
   scr_errdyn_cache[scr_errdyn_n].dyn = scr_dyn_retain(d);
@@ -1035,8 +1029,7 @@ void scr_jb_put_dyn(ScrJsonBuf *b, const ScrDyn *d) {
     return;
   }
   }
-  fputs("scriptc: internal error: invalid dyn kind\n", stderr);
-  abort();
+  scr_trap("scriptc: internal error: invalid dyn kind\n");
 }
 
 /* ── dynCheck failure path ─────────────────────────────────────────────── */
@@ -1750,8 +1743,7 @@ static ScrDyn *scr_sc_clone(const ScrDyn *v, const ScrScParent *up) {
     size_t len = what->len + sizeof suffix - 1;
     char *msg = malloc(len + 1);
     if (!msg) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     memcpy(msg, what->data, what->len);
     memcpy(msg + what->len, suffix, sizeof suffix);
@@ -1860,8 +1852,7 @@ static ScrDyn *scr_dyn_objwalk(const ScrDyn *v, ScrObjWalk mode) {
     bool *is_index = malloc(n ? n * sizeof *is_index : 1);
     double *idx = malloc(n ? n * sizeof *idx : 1);
     if (!is_index || !idx) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     size_t index_count = 0;
     for (size_t i = 0; i < n; i++) {