@scriptc/runtime 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.5",
+  "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_assert.c

@@ -150,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_inspect.c

@@ -245,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));
@@ -277,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];

package/src/scr_json.c

@@ -55,6 +55,9 @@ void scr_jb_init(ScrJsonBuf *b) {
   b->data = NULL;
   b->len = 0;
   b->cap = 0;
+  b->seen = NULL;
+  b->seen_len = 0;
+  b->seen_cap = 0;
 }
 
 static void scr_jb_grow(ScrJsonBuf *b, size_t need) {
@@ -76,6 +79,7 @@ static void scr_jb_grow(ScrJsonBuf *b, size_t need) {
 /* Abandon a buffer (parser error paths). */
 static void scr_jb_dispose(ScrJsonBuf *b) {
   if (b->data) scr_str_release(SCR_JB_STR(b));
+  free(b->seen);
   scr_jb_init(b);
 }
 
@@ -143,6 +147,10 @@ void scr_jb_put_json_str(ScrJsonBuf *b, const ScrStr *s) {
 }
 
 ScrStr *scr_jb_finish(ScrJsonBuf *b) {
+  free(b->seen);
+  b->seen = NULL;
+  b->seen_len = 0;
+  b->seen_cap = 0;
   if (!b->data) return scr_str_new("", 0);
   ScrStr *s = SCR_JB_STR(b);
   s->len = b->len;
@@ -154,6 +162,144 @@ ScrStr *scr_jb_finish(ScrJsonBuf *b) {
   return s;
 }
 
+/* ── circular-structure detection ──────────────────────────────────────
+ * RECURSIVE record types permit runtime reference cycles; JSON.stringify
+ * of a cyclic value throws V8's exact TypeError. The compiler-emitted
+ * walkers over cycle-CAPABLE containers (records whose shape carries a
+ * collector header, arrays of them, tuple shapes alike) bracket their
+ * bodies with enter/leave and stamp the current member edge before each
+ * cycle-capable member write; everything acyclic pays nothing. Detection
+ * is STACK membership (a DAG serializes the shared subtree twice, exactly
+ * like Node — only a path back to an ancestor is circular).
+ *
+ * The message mirrors V8's ConstructCircularStructureErrorMessage byte
+ * for byte: the starting object (where the repeat lands), one line per
+ * hop from it to the top of the stack ("property 'x' -> object with
+ * constructor 'Y'" / "index N -> ..."), the middle elided as "..." when
+ * there are more than three hops (first two + last one shown), and the
+ * closing edge. Constructor names are exactly 'Object'/'Array' — the only
+ * containers JSON-safe types admit. */
+typedef struct ScrJsonSeenEnt {
+  const void *ptr;
+  bool is_array;
+  const char *prop;       /* static property edge (emitted C literal) */
+  const ScrStr *prop_str; /* overflow-key edge (borrowed for the write) */
+  size_t index;           /* array/tuple index edge */
+} ScrJsonSeenEnt;
+
+static void scr_jb_put_edge(ScrJsonBuf *m, const ScrJsonSeenEnt *e) {
+  if (e->prop || e->prop_str) {
+    scr_jb_puts(m, "property '");
+    if (e->prop) scr_jb_puts(m, e->prop);
+    else scr_jb_write(m, e->prop_str->data, e->prop_str->len);
+    scr_jb_putc(m, '\'');
+    return;
+  }
+  scr_jb_puts(m, "index ");
+  scr_jb_put_f64(m, (double)e->index);
+}
+
+static void scr_jb_put_ctor(ScrJsonBuf *m, bool is_array) {
+  scr_jb_puts(m, is_array ? "object with constructor 'Array'" : "object with constructor 'Object'");
+}
+
+bool scr_jb_enter(ScrJsonBuf *b, const void *v, bool is_array) {
+  for (size_t i = 0; i < b->seen_len; i++) {
+    if (b->seen[i].ptr != v) continue;
+    ScrJsonBuf m;
+    scr_jb_init(&m);
+    scr_jb_puts(&m, "Converting circular structure to JSON\n    --> starting at ");
+    scr_jb_put_ctor(&m, b->seen[i].is_array);
+    const size_t n = b->seen_len;
+    const size_t hops = n - 1 - i; /* intermediate lines (j = i+1 .. n-1) */
+    for (size_t j = i + 1; j < n; j++) {
+      if (hops > 3 && j - (i + 1) == 2) {
+        scr_jb_puts(&m, "\n    |     ...");
+        j = n - 2; /* the loop increment lands on the LAST hop */
+        continue;
+      }
+      scr_jb_puts(&m, "\n    |     ");
+      scr_jb_put_edge(&m, &b->seen[j - 1]);
+      scr_jb_puts(&m, " -> ");
+      scr_jb_put_ctor(&m, b->seen[j].is_array);
+    }
+    scr_jb_puts(&m, "\n    --- ");
+    scr_jb_put_edge(&m, &b->seen[n - 1]);
+    scr_jb_puts(&m, " closes the circle");
+    scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&m));
+    return false;
+  }
+  if (b->seen_len == b->seen_cap) {
+    size_t cap = b->seen_cap ? b->seen_cap * 2 : 8;
+    ScrJsonSeenEnt *grown = realloc(b->seen, cap * sizeof *grown);
+    if (!grown) scr_json_oom();
+    b->seen = grown;
+    b->seen_cap = cap;
+  }
+  ScrJsonSeenEnt *e = &b->seen[b->seen_len++];
+  e->ptr = v;
+  e->is_array = is_array;
+  e->prop = NULL;
+  e->prop_str = NULL;
+  e->index = 0;
+  return true;
+}
+
+void scr_jb_leave(ScrJsonBuf *b) {
+  if (b->seen_len > 0) b->seen_len--;
+}
+
+void scr_jb_edge_prop(ScrJsonBuf *b, const char *name) {
+  ScrJsonSeenEnt *e = &b->seen[b->seen_len - 1];
+  e->prop = name;
+  e->prop_str = NULL;
+}
+
+void scr_jb_edge_key(ScrJsonBuf *b, const ScrStr *key) {
+  ScrJsonSeenEnt *e = &b->seen[b->seen_len - 1];
+  e->prop = NULL;
+  e->prop_str = key;
+}
+
+void scr_jb_edge_idx(ScrJsonBuf *b, size_t i) {
+  ScrJsonSeenEnt *e = &b->seen[b->seen_len - 1];
+  e->prop = NULL;
+  e->prop_str = NULL;
+  e->index = i;
+}
+
+/* ── circular guard for the typed→dyn converters (sc_td_*) ────────────
+ * A recursive-typed value crossing into a checked-dynamic slot DEEP-
+ * COPIES into the DOM; a cyclic value has no finite copy. Node never
+ * copies (an unknown-typed binding shares the reference), so there is no
+ * Node-exact error to throw — the conversion TRAPS loudly instead
+ * (SEMANTICS.md documents the divergence). The emitted converters over
+ * cycle-capable containers bracket their walks with enter/leave; the
+ * stack is global (conversions never interleave). */
+static const void **g_td_seen;
+static size_t g_td_nseen;
+static size_t g_td_cap;
+
+void scr_dyn_from_enter(const void *v) {
+  for (size_t i = 0; i < g_td_nseen; i++) {
+    if (g_td_seen[i] == v) {
+      scr_trap("scriptc: cannot convert a circular structure into a checked-dynamic value "
+               "(unknown-typed slots deep-copy; break the cycle first)\n");
+    }
+  }
+  if (g_td_nseen == g_td_cap) {
+    g_td_cap = g_td_cap ? g_td_cap * 2 : 8;
+    const void **grown = realloc(g_td_seen, g_td_cap * sizeof *grown);
+    if (!grown) scr_json_oom();
+    g_td_seen = grown;
+  }
+  g_td_seen[g_td_nseen++] = v;
+}
+
+void scr_dyn_from_leave(void) {
+  if (g_td_nseen > 0) g_td_nseen--;
+}
+
 /* ── DOM lifecycle ─────────────────────────────────────────────────────
  * Parse/release churn (a JSON round-trip loop allocates and frees every
  * node each iteration) runs on freelists instead of calloc/free: one list

package/src/scr_runtime.h

@@ -2917,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
@@ -4095,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,
@@ -5039,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);