@scriptc/runtime 0.0.9 → 0.0.11

package/package.json

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

package/src/scr_assert.c

@@ -439,6 +439,11 @@ static bool scr_assert_dyn_same_value(const ScrDyn *a, const ScrDyn *b) {
     case SCR_DYN_PROMISE:
       /* Identity is the PROMISE (the strict_eq stance). */
       return a->v.promise == b->v.promise;
+    case SCR_DYN_JSVAL:
+      /* Identity is the ENGINE VALUE (the strict_eq stance): the engine's
+       * === — exact for SameValue too, since wrap-time scalar
+       * normalization leaves only reference kinds behind. */
+      return a == b || scr_dyn_jsval_ops()->strict_eq(a->v.jsval.cell, b->v.jsval.cell);
     default:
       return a == b; /* ARR/OBJ/BYTES: node identity */
   }
@@ -454,7 +459,16 @@ static bool scr_assert_dyn_same_value(const ScrDyn *a, const ScrDyn *b) {
  * memo here where Node carries one (documented divergence). */
 static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
   if (a == b) return true;
-  if (a->kind != b->kind) return false;
+  if (a->kind != b->kind) {
+    /* A MIXED comparison with an island side (wrapped engine object vs
+     * DOM data): Node walks both structurally — a plain `false` would
+     * mint a fabricated AssertionError for values Node may call equal.
+     * Loud fence (the long-tail lane's structural walk). */
+    if (a->kind == SCR_DYN_JSVAL || b->kind == SCR_DYN_JSVAL) {
+      scr_dyn_isl_fence(a->kind == SCR_DYN_JSVAL ? a : b, "deepStrictEqual");
+    }
+    return false;
+  }
   switch (a->kind) {
     case SCR_DYN_UNDEF:
     case SCR_DYN_NULL:
@@ -493,6 +507,7 @@ static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
       return true;
     }
     case SCR_DYN_OBJ: {
+      if (a->null_proto != b->null_proto) return false; /* the prototype gate */
       if (a->v.obj.len != b->v.obj.len) return false;
       for (size_t i = 0; i < a->v.obj.len; i++) {
         const ScrDynEntry *ent = &a->v.obj.entries[i];
@@ -501,6 +516,14 @@ static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
       }
       return true;
     }
+    case SCR_DYN_JSVAL:
+      /* Node walks the engine objects structurally — a walk this runtime
+       * cannot run. Engine-identical answers true honestly; anything else
+       * throws the loud ladder (scr_assert_eq_dyn propagates the pending
+       * exception INSTEAD of minting an AssertionError). */
+      if (scr_dyn_jsval_ops()->strict_eq(a->v.jsval.cell, b->v.jsval.cell)) return true;
+      scr_dyn_isl_fence(a, "deepStrictEqual");
+      return false;
   }
   return false; /* unreachable */
 }
@@ -653,15 +676,26 @@ static void scr_assert_cf_value(ScrAssertBuf *b, const ScrDyn *d, size_t indent,
       ab_char(b, ']');
       return;
     }
+    case SCR_DYN_JSVAL: {
+      /* The depth-elided placeholder (the handle stance): Node renders
+       * the engine object's property dump — internals this walker does
+       * not model; the text only appears inside FAILURE reports, which
+       * already diverge in format. */
+      ab_cstr(b, "[island value]");
+      return;
+    }
     case SCR_DYN_OBJ: {
+      /* The null-proto dictionary renders with Node's prefix in the
+       * failure diff too (assertion_error.js inspects both sides). */
       if (d->v.obj.len == 0) {
-        ab_cstr(b, "{}");
+        ab_cstr(b, d->null_proto ? "[Object: null prototype] {}" : "{}");
         return;
       }
       if (depth == 0) {
-        ab_cstr(b, "[Object]");
+        ab_cstr(b, d->null_proto ? "[Object: null prototype]" : "[Object]");
         return;
       }
+      if (d->null_proto) ab_cstr(b, "[Object: null prototype] ");
       /* Render every entry, then sort the RENDERED texts (Node's
        * sorted:true sorts formatted entries, quotes included). */
       ScrCfEntry *ents = malloc(d->v.obj.len * sizeof *ents);
@@ -893,7 +927,8 @@ static bool scr_assert_print_myers(ScrAssertBuf *b, const ScrDiffOp *diff, size_
 /* Is this DOM kind `typeof == "object" && != null` to assertion_error.js? */
 static bool scr_assert_dyn_is_object(const ScrDyn *d) {
   return d->kind == SCR_DYN_ARR || d->kind == SCR_DYN_OBJ || d->kind == SCR_DYN_BYTES ||
-         d->kind == SCR_DYN_HANDLE || d->kind == SCR_DYN_PROMISE;
+         d->kind == SCR_DYN_HANDLE || d->kind == SCR_DYN_PROMISE ||
+         scr_dyn_isl_typeof_is(d, "object"); /* engine-held: the engine's typeof */
 }
 
 /* The failing EQUAL operators over dyn operands — createErrDiff. */
@@ -1065,6 +1100,10 @@ static void scr_assert_dyn_neq_fail(ScrDyn *a, bool deep, ScrStr *msg, bool has_
 void scr_assert_eq_dyn(ScrDyn *a, ScrDyn *b, bool negated, bool deep,
                        ScrStr *msg, bool has_msg) {
   bool same = deep ? scr_assert_dyn_deep_eq(a, b) : scr_assert_dyn_same_value(a, b);
+  /* The deep walk's JSVAL arm fences loudly (an island value it cannot
+   * compare structurally): propagate THAT, never a fabricated
+   * AssertionError over a comparison that did not run. */
+  if (scr_exc_pending()) return;
   if ((negated && !same) || (!negated && same)) return;
   if (negated) {
     scr_assert_dyn_neq_fail(a, deep, msg, has_msg);

package/src/scr_async.c

@@ -591,7 +591,8 @@ ScrArr *scr_active_resources(void) {
  * left queued on the uncaught paths) never run — the teardown releases
  * them, like Node dropping the queue at exit. */
 typedef struct ScrNtick {
-  ScrClosure *cb; /* owned */
+  ScrClosure *cb;    /* owned; NULL for a raw C-hook entry */
+  void (*raw)(void); /* the hook when cb == NULL (stream tick markers) */
   struct ScrNtick *next;
 } ScrNtick;
 
@@ -612,11 +613,25 @@ void scr_next_tick(ScrClosure *cb /*moves*/) {
   scr_nt_tail = t;
 }
 
+/* A RAW C-hook tick: the stream unit enqueues one marker per deferred
+ * stream emission so those emissions interleave with user nextTicks in
+ * true FIFO order — in Node they ARE nextTicks (resume_, emitReadable_,
+ * endReadableNT, ...). The hook dispatches exactly one stream tick;
+ * teardown just drops markers (the stream queue owns its entries). */
+void scr_next_tick_raw(void (*fn)(void)) {
+  ScrNtick *t = calloc(1, sizeof *t);
+  if (!t) scr_oom();
+  t->raw = fn;
+  if (scr_nt_tail) scr_nt_tail->next = t;
+  else scr_nt_head = t;
+  scr_nt_tail = t;
+}
+
 void scr_nticks_teardown(void) {
   while (scr_nt_head != NULL) {
     ScrNtick *t = scr_nt_head;
     scr_nt_head = t->next;
-    scr_closure_release(t->cb);
+    if (t->cb) scr_closure_release(t->cb);
     free(t);
   }
   scr_nt_tail = NULL;
@@ -1677,9 +1692,14 @@ void scr_loop_run(void) {
         scr_nt_head = t->next;
         if (scr_nt_head == NULL) scr_nt_tail = NULL;
         ScrClosure *cb = t->cb;
+        void (*raw)(void) = t->raw;
         free(t);
-        ((void (*)(ScrClosure *))cb->fn)(cb);
-        scr_closure_release(cb);
+        if (cb) {
+          ((void (*)(ScrClosure *))cb->fn)(cb);
+          scr_closure_release(cb);
+        } else {
+          raw(); /* one stream tick, FIFO with the user ticks around it */
+        }
         if (scr_exc_pending()) return;
       }
     }

package/src/scr_bytes.c

@@ -1,6 +1,8 @@
 /* Typed arrays / Buffer: ONE runtime representation (ScrBytes — see the
- * header contract). Element buffers own their storage outright: no views,
- * no byteOffset, slice/subarray both copy. Coercions are JS-exact
+ * header contract). An ScrBytes either OWNS its storage or is a VIEW into
+ * an owner's (backing set, chain depth exactly 1): DataView, subarray(),
+ * and Buffer's slice() all alias JS-exactly; only the plain typed arrays'
+ * slice() copies. Coercions are JS-exact
  * (ToUint8/ToUint32 modular truncation, double→float rounding); the
  * encoding conversions (utf8 with WHATWG replacement, hex, base64) match
  * Node byte-for-byte — the differential corpus holds them to it. */
@@ -164,7 +166,7 @@ void scr_bytes_set(ScrBytes *b, double i, double v) {
   }
 }
 
-/* ── slice / subarray (both COPY) ──────────────────────────────────────── */
+/* ── slice (copy) / subarray (view) ────────────────────────────────────── */
 
 /* Relative index: ToIntegerOrInfinity, negatives from the end, clamped. */
 static size_t scr_bytes_rel_index(double i, size_t len) {
@@ -186,6 +188,41 @@ ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end) {
   return out;
 }
 
+/* TypedArray.prototype.fill on non-u8 receivers: per-ELEMENT fill with
+ * the element write's JS-exact coercion (ToUint32/ToInt32 wrap, f32
+ * rounding), slice-clamped relative indices; answers the receiver +1
+ * (chaining). Never throws — Buffer's throwing fill family is separate. */
+ScrBytes *scr_bytes_fill_elem(ScrBytes *b, double v, double start, double end) {
+  size_t s = scr_bytes_rel_index(start, b->len);
+  size_t e = scr_bytes_rel_index(end, b->len);
+  for (size_t i = s; i < e; i++) scr_bytes_set(b, (double)i, v);
+  return scr_bytes_retain(b);
+}
+
+/* subarray(start, end): a same-elem VIEW over the receiver's storage —
+ * TypedArray.prototype.subarray and Buffer's slice()/subarray() all alias
+ * in JS (mutations are visible both ways; buffer-swap through a slice is
+ * the canonical Node use). Chain depth stays exactly 1: a subarray of a
+ * view retains the OWNER, offsets composed here (the DataView rule).
+ * Relative indices clamp like slice; never throws. */
+ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end) {
+  size_t s = scr_bytes_rel_index(start, b->len);
+  size_t e = scr_bytes_rel_index(end, b->len);
+  size_t count = e > s ? e - s : 0;
+  ScrBytes *owner = b->backing ? b->backing : b;
+  ScrBytes *v = malloc(sizeof(ScrBytes));
+  if (!v) scr_bytes_oom();
+  v->rc = 1;
+  v->len = count;
+  v->elem = b->elem;
+  v->data = b->data + s * scr_bytes_elem_size(b->elem);
+  v->backing = scr_bytes_retain(owner);
+#ifdef SCR_RC_AUDIT
+  scr_live_bytes++;
+#endif
+  return v;
+}
+
 void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset) {
   double t = (offset != offset) ? 0 : trunc(offset);
   if (!(t >= 0) || (double)src->len + t > (double)dst->len) {
@@ -927,7 +964,7 @@ ScrBytes *scr_bytes_from_arr(ScrBytesElem elem, const ScrArr *arr) {
  * the '>= 0 && <= max' render, ERR_OUT_OF_RANGE's Received rules — and
  * copy's C++-side ladder; pinned by corpus 1663) ─────────────────────── */
 
-static size_t scr_bytes_received(double v, char out[48]); /* the numeric section below */
+size_t scr_num_received(double v, char out[48]); /* the numeric section below */
 
 /* validateOffset(name, 0, max): non-integers are 'an integer' (Number.
  * isInteger — ±Infinity render 'an integer' too), the rest '>= 0 && <=
@@ -938,7 +975,7 @@ static size_t scr_bytes_received(double v, char out[48]); /* the numeric section
 bool scr_bytes_validate_off(const char *name, double value, double max) {
   if (isfinite(value) && floor(value) == value && value >= 0 && (max < 0 || value <= max)) return true;
   char recv[48];
-  scr_bytes_received(value, recv);
+  scr_num_received(value, recv);
   char msg[160];
   int mlen;
   if (floor(value) != value || !isfinite(value)) {
@@ -1250,8 +1287,9 @@ ScrBytes *scr_bytes_concat(const ScrArr *list) {
 /* ERR_OUT_OF_RANGE's "Received" rendering: integers with |v| > 2^32 get
  * Node's addNumericalSeparator underscores applied to the plain String()
  * form — INCLUDING its quirks on exponent renderings ("1e_+21",
- * "1e+_300"); everything else is the shortest-roundtrip number. */
-static size_t scr_bytes_received(double v, char out[48]) {
+ * "1e+_300"); everything else is the shortest-roundtrip number. Shared
+ * with the fs/net option-ladder validators (scr_num_received). */
+size_t scr_num_received(double v, char out[48]) {
   char plain[32];
   size_t n = scr_f64_to_str(v, plain);
   if (!(isfinite(v) && trunc(v) == v && fabs(v) > 4294967296.0)) {
@@ -1281,7 +1319,7 @@ static size_t scr_bytes_received(double v, char out[48]) {
  * "byteLength" renders min 1. All catchable RangeErrors. */
 static void scr_bytes_bounds_error(double value, double length, const char *type) {
   char recv[48];
-  scr_bytes_received(value, recv);
+  scr_num_received(value, recv);
   char msg[160];
   int mlen;
   if (floor(value) != value) {
@@ -1322,7 +1360,7 @@ static bool scr_bytes_check_int(const ScrBytes *b, double value, double offset,
   double min = sign ? -exp2((double)(8 * width - 1)) : 0;
   if (value > max || value < min) {
     char recv[48];
-    scr_bytes_received(value, recv);
+    scr_num_received(value, recv);
     char msg[160];
     int mlen;
     if (width > 4) {