@scriptc/runtime 0.0.4 → 0.0.6

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]);

package/src/scr_regex.c

@@ -37,8 +37,7 @@
 #include "libregexp.h"
 
 static void scr_regex_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── libregexp host hooks ─────────────────────────────────────────────
@@ -102,7 +101,7 @@ static void scr_note_compiled(ScrRegex *re) {
     scr_compiled = realloc(scr_compiled, scr_compiled_cap * sizeof *scr_compiled);
     if (!scr_compiled) scr_regex_oom();
   }
-  if (scr_compiled_len == 0) atexit(scr_regex_free_bytecodes);
+  if (scr_compiled_len == 0) scr_atexit(scr_regex_free_bytecodes);
   scr_compiled[scr_compiled_len++] = re;
 }
 
@@ -119,9 +118,8 @@ static int scr_lre_flags(const ScrStr *flags) {
       case 'u': mask |= LRE_FLAG_UNICODE; break;
       case 'y': mask |= LRE_FLAG_STICKY; break;
       default:
-        fprintf(stderr, "scriptc: internal error: unexpected regex flag '%c'\n",
-                flags->data[i]);
-        abort();
+        scr_trap_fmt("scriptc: internal error: unexpected regex flag '%c'\n",
+                     flags->data[i]);
     }
   }
   return mask;
@@ -197,9 +195,8 @@ static uint8_t *scr_regex_bc(ScrRegex *re) {
      * tsc's parser has already caught plain syntax errors, so this is
      * rare). */
     fflush(stdout);
-    fprintf(stderr, "scriptc: SyntaxError: Invalid regular expression: /%s/%s: %s\n",
-            re->source->data, re->flags->data, error_msg);
-    abort();
+    scr_trap_fmt("scriptc: SyntaxError: Invalid regular expression: /%s/%s: %s\n",
+                 re->source->data, re->flags->data, error_msg);
   }
   re->bc = bc;
   scr_note_compiled(re);
@@ -315,8 +312,7 @@ static int scr_exec(uint8_t **capture, const uint8_t *bc, const uint16_t *u,
   int rc = lre_exec(capture, bc, (const uint8_t *)u, index, len, 1, lre_opaque());
   if (rc < 0) {
     fflush(stdout);
-    fputs("scriptc: regular expression execution failed\n", stderr);
-    abort();
+    scr_trap("scriptc: regular expression execution failed\n");
   }
   return rc;
 }
@@ -351,11 +347,9 @@ bool scr_regex_test(ScrRegex *re, ScrStr *s) {
      * iteration this slice does not model (the frontend rejects the sites
      * it can see; values that flow through variables land here). */
     fflush(stdout);
-    fprintf(stderr,
-            "scriptc: test() on a regex with the 'g' or 'y' flag is not "
-            "supported (stateful lastIndex); drop the flag, or use "
-            "replace/replaceAll/split\n");
-    abort();
+    scr_trap("scriptc: test() on a regex with the 'g' or 'y' flag is not "
+             "supported (stateful lastIndex); drop the flag, or use "
+             "replace/replaceAll/split\n");
   }
   int len;
   uint16_t *u = scr_to_utf16(s, &len);
@@ -379,11 +373,9 @@ ScrArr *scr_regex_match(ScrStr *s, ScrRegex *re) {
   uint8_t *bc = scr_regex_bc(re);
   if (lre_get_flags(bc) & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) {
     fflush(stdout);
-    fprintf(stderr,
-            "scriptc: match() on a regex with the 'g' or 'y' flag is not "
-            "supported (an every-match array is a different shape); drop the "
-            "flag, or use replace/replaceAll/split\n");
-    abort();
+    scr_trap("scriptc: match() on a regex with the 'g' or 'y' flag is not "
+             "supported (an every-match array is a different shape); drop the "
+             "flag, or use replace/replaceAll/split\n");
   }
   int len;
   uint16_t *u = scr_to_utf16(s, &len);
@@ -803,7 +795,7 @@ static bool scr_assert_regex_hits(ScrRegex *re, ScrStr *s) {
 static ScrStr *scr_assert_regex_render(ScrRegex *re) {
   size_t cap = re->source->len + re->flags->len + 2;
   char *buf = malloc(cap);
-  if (!buf) abort();
+  if (!buf) scr_trap("scriptc: out of memory\n");
   size_t n = 0;
   buf[n++] = '/';
   memcpy(buf + n, re->source->data, re->source->len);
@@ -831,7 +823,7 @@ static void scr_assert_regex_input_fail(bool negated, ScrRegex *re, ScrStr *inpu
   const char *mid = ". Input:\n\n";
   size_t cap = strlen(head) + rre->len + strlen(mid) + insp->len + 1;
   char *buf = malloc(cap);
-  if (!buf) abort();
+  if (!buf) scr_trap("scriptc: out of memory\n");
   size_t n = 0;
   memcpy(buf + n, head, strlen(head));
   n += strlen(head);
@@ -924,8 +916,7 @@ ScrRegex *scr_regex_new(ScrStr *pattern, ScrStr *flags) {
   }
   ScrRegex *re = calloc(1, sizeof *re);
   if (!re) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   re->rc = 1;
   re->source = pattern->len > 0 ? scr_str_retain(pattern) : scr_str_new("(?:)", 4);

package/src/scr_runtime.h

@@ -39,6 +39,81 @@ char *strcasestr(const char *hay, const char *needle);
  * flush-at-exit, RC audit registration (when built with -DSCR_RC_AUDIT). */
 void scr_init(void);
 
+/* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ──────
+ * Every unrecoverable runtime trap — OOM, semantic range traps, internal-
+ * invariant failures — funnels through this pair instead of open-coded
+ * fputs/fprintf + abort. Executable builds expand to exactly the historical
+ * behavior (the message's bytes on stderr, then abort — the default lane
+ * must not change by a byte). Library builds (-DSCR_LIB) route the message to
+ * the host-registered panic sink and abort only as the last resort: before
+ * registration, or if the sink returns (the ruled host-contract violation —
+ * a conforming sink longjmps to a host frame BELOW the entry, never back
+ * into library frames). Messages keep their trailing newline in both lanes so
+ * the funnel is a pure indirection over identical bytes. */
+_Noreturn void scr_trap(const char *msg);
+_Noreturn void scr_trap_fmt(const char *fmt, ...);
+
+/* ── library mode (scr_library.c, linked only into library artifacts) ─────
+ * A library artifact has no main, no event loop, no signal handlers, no
+ * atexit registrations, and never touches host stdio modes or buffering:
+ * initialization runs inside the profile-named init entry (re-runnable
+ * deterministically), traps route to the sink above, and buffer-class
+ * results live in a library-owned result arena. Everything here compiles only
+ * under -DSCR_LIB; executable builds never contain it. */
+#ifdef SCR_LIB
+typedef struct ScrStr ScrStr;     /* full definitions below (C11 repeat) */
+typedef struct ScrBytes ScrBytes;
+/* The host's panic sink: msg is UTF-8, valid only for the duration of the
+ * call; address is the trap site's return address (0 when the toolchain
+ * cannot supply one); ctx is the registration's opaque pointer. The sink
+ * must not call back into any library entry and must not unwind or longjmp
+ * back into library frames. */
+typedef void (*ScrLibSinkFn)(void *ctx, const uint8_t *msg, size_t msg_len,
+                              uint64_t address);
+void scr_library_set_sink(ScrLibSinkFn fn, void *ctx); /* latest wins */
+
+/* Entry prologue: aborts deterministically when the library is poisoned (a
+ * trap already fired — no profile entry may run again; recovery is process
+ * restart). reset_arena additionally drops the result arena (the
+ * auto-reset posture, and the reset/collect entries' shared body). */
+void scr_library_entry(bool reset_arena);
+void scr_library_arena_reset(void);
+/* The mode-provided collect entry's body: arena reset + a full cycle
+ * collection (snapshot-invariant by construction — collection frees only
+ * unreachable cycles). */
+void scr_library_collect(void);
+
+/* Full session reset, called by the generated init entry AFTER the program
+ * TU released and zeroed its globals: pending-exception clear, arena
+ * reset, the reset registry's drains (the units' repointed atexit halves),
+ * the library's interned process values, a cycle collection, and — under
+ * SCR_RC_AUDIT — the zero-live-heap assertion (a failure is a trap through
+ * the sink, never _Exit). */
+void scr_library_reset(void);
+/* Where a unit would atexit() a lazy teardown, library builds register it
+ * here instead (called on every scr_library_reset, registered once). */
+void scr_library_register_reset(void (*fn)(void));
+/* An escaped exception at an entry boundary: renders the same "Uncaught
+ * ..." text the executable epilogue prints, releases the payload, and
+ * routes the text through the trap funnel. No-op when nothing is pending.
+ * Defined in scr_exception.c (it owns the cell). */
+void scr_library_check_exc(void);
+
+/* Marshalling helpers the generated wrappers call (both emissions share
+ * these bodies, which is how the two lanes stay identical by
+ * construction). Inbound is borrowed-and-copied; outbound values MOVE into
+ * the result arena and stay valid until the next arena reset. String
+ * results are NUL-terminated after *out_len bytes (ScrStr's layout). */
+ScrStr *scr_library_str_in(const uint8_t *p, size_t len);   /* +1 */
+ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len); /* +1, u8 */
+void scr_library_str_out(ScrStr *s, const uint8_t **out, size_t *out_len);
+void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len);
+
+#define scr_atexit(fn) scr_library_register_reset(fn)
+#else
+#define scr_atexit(fn) atexit(fn)
+#endif /* SCR_LIB */
+
 /* ── cycle collection (scr_cycle.c) ───────────────────────────────────
  * Reference counting alone cannot free cycles, so every object that can
  * participate in one — capture boxes, heap closures, unions, promises, and
@@ -2842,14 +2917,48 @@ extern void scr_dyn_listener_fire_err(ScrClosure *cb, ScrStr *msg);
 
 /* Output buffer for the compiler-emitted type-directed JSON serializers.
  * Value-typed and stack-allocated by the emitted code; _finish hands the
- * bytes over as a +1 ScrStr and frees the buffer storage. */
+ * bytes over as a +1 ScrStr and frees the buffer storage (including the
+ * circular-detection stack below). */
+struct ScrJsonSeenEnt;
 typedef struct {
   char *data;
   size_t len;
   size_t cap;
+  /* Circular-structure detection for RECURSIVE record types (cyclic
+   * values must throw Node's exact TypeError, never recurse forever):
+   * the stack of container values currently being serialized, each with
+   * its outgoing edge label (the member being written). Only walkers over
+   * cycle-CAPABLE types (the collector-fixpoint set) maintain it; acyclic
+   * types keep the zero-cost path. */
+  struct ScrJsonSeenEnt *seen;
+  size_t seen_len;
+  size_t seen_cap;
 } ScrJsonBuf;
 
 void scr_jb_init(ScrJsonBuf *b);
+/* Push a container onto the circular-detection stack before serializing
+ * its members. If `v` is already ON the stack, throws V8's exact
+ * "Converting circular structure to JSON" TypeError (the --> starting at /
+ * |property/index hops/--- closes the circle rendering, ellipsis rules
+ * included) and returns false — the caller returns immediately; the
+ * emitted stringify site runs the pending check. `is_array` picks the
+ * constructor name in the message ('Array' for arrays AND tuple shapes —
+ * their JS values are arrays — 'Object' for records). */
+bool scr_jb_enter(ScrJsonBuf *b, const void *v, bool is_array);
+void scr_jb_leave(ScrJsonBuf *b);
+/* Record the edge currently being serialized on the stack top: a static
+ * property name (emitted C literal), an overflow key (borrowed for the
+ * duration of the member write), or an array/tuple index. */
+void scr_jb_edge_prop(ScrJsonBuf *b, const char *name);
+void scr_jb_edge_key(ScrJsonBuf *b, const ScrStr *key);
+void scr_jb_edge_idx(ScrJsonBuf *b, size_t i);
+
+/* Circular guard for the compiler-emitted typed→dyn converters (sc_td_*
+ * over cycle-capable containers): enter TRAPS on a value already being
+ * converted (a cyclic value has no finite DOM copy — Node shares the
+ * reference instead; SEMANTICS.md), else pushes. */
+void scr_dyn_from_enter(const void *v);
+void scr_dyn_from_leave(void);
 void scr_jb_putc(ScrJsonBuf *b, char c);
 void scr_jb_puts(ScrJsonBuf *b, const char *s);
 /* JS JSON.stringify number rules: NaN/±Infinity → null, -0 → 0, else
@@ -4020,6 +4129,18 @@ ScrStr *scr_insp_jsval(ScrJsval *v, double recurse, double depth);
 #endif
 void scr_insp_begin(double recurse);
 void scr_insp_entry(ScrStr *s, bool is_num);
+/* Circular references, Node-exact (<ref *N> / [Circular *N]): the
+ * compiler-emitted helpers over CYCLE-CAPABLE composites call circ_check
+ * FIRST (a value already on the traversal stack answers its circular id,
+ * assigned in discovery order — the caller renders scr_insp_circular and
+ * descends no further), seen_push after begin, and ref_wrap around end's
+ * result (pops the stack; values in the circular map gain the "<ref *N> "
+ * prefix). State resets at each top-level value's first frame
+ * (scr_insp_begin(1)). ref_wrap BORROWS s and returns +1. */
+double scr_insp_circ_check(const void *v);
+void scr_insp_seen_push(const void *v);
+ScrStr *scr_insp_circular(double id);
+ScrStr *scr_insp_ref_wrap(const void *v, ScrStr *s);
 ScrStr *scr_insp_more_items(double remaining); /* "... N more items" */
 ScrStr *scr_insp_key(ScrStr *k); /* bare-or-quoted property-name ladder; +1 */
 ScrStr *scr_insp_end(ScrStr *base, ScrStr *b0, ScrStr *b1, double recurse,
@@ -4964,6 +5085,11 @@ void scr_assert_fail_msg(ScrStr *message); /* takes ownership; always throws */
 ScrStr *scr_assert_inspect_str(const ScrStr *s); /* util.inspect quoting; +1 */
 void scr_assert_ok(bool pass, ScrStr *message);
 bool scr_assert_same_value_f64(double a, double b); /* Object.is */
+/* deepStrictEqual over cyclic values: pair memo (enter answers true for
+ * a pair already being compared — Node's coinductive memo; leave pops).
+ * The compiler-emitted helpers over cycle-capable types wrap with these. */
+bool scr_assert_deq_enter(const void *a, const void *b);
+void scr_assert_deq_leave(void);
 void scr_assert_eq_f64(double a, double b, bool negated, bool deep, ScrStr *msg, bool has_msg);
 void scr_assert_eq_str(ScrStr *a, ScrStr *b, bool negated, bool deep, ScrStr *msg, bool has_msg);
 void scr_assert_eq_bool(bool a, bool b, bool negated, bool deep, ScrStr *msg, bool has_msg);

package/src/scr_string.c

@@ -15,8 +15,7 @@ long scr_str_live_count(void) { return scr_live_strings; }
 #endif
 
 static void scr_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── UTF-16 index cache ───────────────────────────────────────────────
@@ -519,8 +518,7 @@ ScrStr *scr_str_slice(ScrStr *s, double start, double end) {
 ScrStr *scr_str_repeat(ScrStr *s, double count) {
   double n = scr_to_integer_or_infinity(count);
   if (n < 0 || (isinf(n) && n > 0)) {
-    fputs("scriptc: RangeError: Invalid count value\n", stderr);
-    abort();
+    scr_trap("scriptc: RangeError: Invalid count value\n");
   }
   if (n == 0 || s->len == 0) return scr_str_empty();
   /* n is a finite non-negative integer here. Reject sizes malloc could not

package/src/scr_symbol.c

@@ -44,8 +44,7 @@ void scr_sym_release_v(void *p) { scr_sym_release(p); }
 ScrSym *scr_sym_new(ScrStr *desc) {
   ScrSym *s = malloc(sizeof(ScrSym));
   if (!s) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   s->rc = 1;
   s->desc = desc ? scr_str_retain(desc) : NULL;
@@ -75,7 +74,7 @@ ScrSym *scr_sym_for(ScrStr *key) {
   /* First request for this key: a fresh symbol whose description IS the
    * key (the spec's Symbol.for behavior), chained into the registry with
    * the registry's own reference. */
-  if (!g_sym_registry) atexit(scr_sym_registry_cleanup);
+  if (!g_sym_registry) scr_atexit(scr_sym_registry_cleanup);
   ScrSym *s = scr_sym_new(key);
   s->reg_key = scr_str_retain(key);
   s->reg_next = g_sym_registry;