@scriptc/runtime 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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 ─────────────── */
@@ -151,6 +150,37 @@ void scr_assert_ok(bool pass, ScrStr *message) {
 
 /* SameValue over doubles — Object.is, the comparison of strictEqual AND
  * deepStrictEqual for numbers (NaN equals NaN; +0 and -0 differ). */
+/* ── deepStrictEqual over cyclic values ────────────────────────────────
+ * RECURSIVE record types permit reference cycles; Node's deep equality
+ * memoizes (value1, value2) pairs so equal cyclic structures compare
+ * true instead of recursing forever. The compiler-emitted per-type
+ * helpers over cycle-capable types wrap their walks in enter/leave: a
+ * PAIR already being compared answers equal (the coinductive step —
+ * Node's memo behavior exactly). The stack is global (comparisons never
+ * interleave; the emitted walks cannot throw mid-compare). */
+static struct { const void *a, *b; } *g_deq_stack;
+static size_t g_deq_len;
+static size_t g_deq_cap;
+
+bool scr_assert_deq_enter(const void *a, const void *b) {
+  for (size_t i = 0; i < g_deq_len; i++) {
+    if (g_deq_stack[i].a == a && g_deq_stack[i].b == b) return true;
+  }
+  if (g_deq_len == g_deq_cap) {
+    g_deq_cap = g_deq_cap ? g_deq_cap * 2 : 8;
+    g_deq_stack = realloc(g_deq_stack, g_deq_cap * sizeof *g_deq_stack);
+    if (!g_deq_stack) scr_assert_oom();
+  }
+  g_deq_stack[g_deq_len].a = a;
+  g_deq_stack[g_deq_len].b = b;
+  g_deq_len++;
+  return false;
+}
+
+void scr_assert_deq_leave(void) {
+  if (g_deq_len > 0) g_deq_len--;
+}
+
 bool scr_assert_same_value_f64(double a, double b) {
   if (a == b) return a != 0.0 || signbit(a) == signbit(b);
   return isnan(a) && isnan(b);

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 ──────────────────────────────────── */
@@ -246,10 +245,13 @@ static double g_cur_depth;    /* ctx.currentDepth (last-entered composite) */
 
 static InspFrame *insp_top(void) { return &g_frames[g_nframes - 1]; }
 
+static void insp_circ_reset(void); /* circular-reference state, below */
+
 /* Begin a non-empty composite: formatRaw's `recurseTimes += 1;
  * ctx.currentDepth = recurseTimes` plus the uniform +2 the children
  * format under. `recurse` is the CHILDREN's recursion depth. */
 void scr_insp_begin(double recurse) {
+  if (recurse == 1) insp_circ_reset(); /* a fresh top-level value: Node's per-inspect ctx */
   if (g_nframes == g_frames_cap) {
     g_frames_cap = g_frames_cap ? g_frames_cap * 2 : 8;
     g_frames = realloc(g_frames, g_frames_cap * sizeof(InspFrame));
@@ -278,6 +280,85 @@ void scr_insp_entry(ScrStr *s, bool is_num) {
   if (!is_num) f->all_num = false;
 }
 
+/* ── circular references (Node's <ref *N> / [Circular *N]) ────────────
+ * Recursive record/class types permit runtime reference cycles, and Node
+ * renders them with formatValue's seen/circular machinery: a value
+ * already ON the current traversal stack renders as `[Circular *N]` (N
+ * assigned at first detection, in discovery order), and every rendering
+ * of a so-numbered value gets the `<ref *N> ` prefix at its close. The
+ * compiler-emitted helpers over CYCLE-CAPABLE composites drive exactly
+ * that protocol: circ_check first (before the empty-literal and depth
+ * answers — Node's order: a circular value beyond the depth budget still
+ * says Circular), seen_push after begin, ref_wrap around end's result.
+ * The circular MAP persists for one whole top-level inspect — begin(1)
+ * is the per-value reset (a root composite's first frame). */
+typedef struct {
+  const void *ptr;
+  int id; /* circular id (0 while only on the stack) */
+} InspSeenEnt;
+
+static InspSeenEnt *g_seen;
+static size_t g_nseen;
+static size_t g_seen_cap;
+/* Detection-numbered circular targets (persist across the call). */
+static const void *g_circ[64];
+static int g_ncirc;
+
+static void insp_circ_reset(void) {
+  g_nseen = 0;
+  g_ncirc = 0;
+}
+
+static int insp_circ_id(const void *v) {
+  for (int i = 0; i < g_ncirc; i++) {
+    if (g_circ[i] == v) return i + 1;
+  }
+  return 0;
+}
+
+double scr_insp_circ_check(const void *v) {
+  for (size_t i = 0; i < g_nseen; i++) {
+    if (g_seen[i].ptr != v) continue;
+    int id = insp_circ_id(v);
+    if (id == 0 && g_ncirc < (int)(sizeof g_circ / sizeof *g_circ)) {
+      g_circ[g_ncirc++] = v;
+      id = g_ncirc;
+    }
+    return (double)id;
+  }
+  return 0;
+}
+
+void scr_insp_seen_push(const void *v) {
+  if (g_nseen == g_seen_cap) {
+    g_seen_cap = g_seen_cap ? g_seen_cap * 2 : 8;
+    g_seen = realloc(g_seen, g_seen_cap * sizeof(InspSeenEnt));
+    if (!g_seen) insp_oom();
+  }
+  g_seen[g_nseen].ptr = v;
+  g_seen[g_nseen].id = 0;
+  g_nseen++;
+}
+
+ScrStr *scr_insp_circular(double id) {
+  char buf[32];
+  int n = snprintf(buf, sizeof buf, "[Circular *%.0f]", id);
+  return scr_str_new(buf, (size_t)n);
+}
+
+ScrStr *scr_insp_ref_wrap(const void *v, ScrStr *s) {
+  if (g_nseen > 0) g_nseen--;
+  int id = insp_circ_id(v);
+  if (id == 0) return scr_str_retain(s);
+  char buf[32];
+  int n = snprintf(buf, sizeof buf, "<ref *%d> ", id);
+  ScrStr *out = scr_str_alloc_raw(s->len + (size_t)n, s->len + (size_t)n);
+  memcpy(out->data, buf, (size_t)n);
+  memcpy(out->data + n, s->data, s->len);
+  out->data[out->len] = '\0';
+  return out;
+}
+
 /* remainingText: the "... N more items" tail entry. */
 ScrStr *scr_insp_more_items(double remaining) {
   char buf[64];