@scriptc/runtime 0.0.8 → 0.0.10

package/package.json

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

@@ -312,6 +312,49 @@ double scr_dataview_get(const ScrBytes *b, double byte_off, ScrDataViewGet kind,
   return 0; /* unreachable */
 }
 
+void scr_dataview_set(ScrBytes *b, double byte_off, double value, ScrDataViewGet kind, bool le) {
+  size_t width = scr_dataview_get_size(kind);
+  /* ToIndex + the view-relative bounds check — the getters' ONE message. */
+  double off = (byte_off != byte_off) ? 0 : trunc(byte_off);
+  if (!(off >= 0) || off > 9007199254740991.0 || off + (double)width > (double)b->len) {
+    static const char msg[] = "Offset is outside the bounds of the DataView";
+    scr_throw_error_msg(SCR_ERR_RANGE, msg, sizeof msg - 1);
+    return;
+  }
+  /* Coerce to the stored bit pattern. The integer kinds share ToUint32's
+   * 2^32 residue (signed/unsigned store the same bits; narrower widths
+   * take the low bytes — 2^width divides 2^32, so the residues agree);
+   * F32 rounds double→float to nearest even, exactly the spec. */
+  uint64_t u = 0;
+  switch (kind) {
+    case SCR_DV_U8:
+    case SCR_DV_I8:
+    case SCR_DV_U16:
+    case SCR_DV_I16:
+    case SCR_DV_U32:
+    case SCR_DV_I32:
+      u = (uint64_t)scr_bytes_to_u32(value);
+      break;
+    case SCR_DV_F32: {
+      float f = (float)value;
+      uint32_t bits;
+      memcpy(&bits, &f, 4);
+      u = bits;
+      break;
+    }
+    case SCR_DV_F64:
+      memcpy(&u, &value, 8);
+      break;
+    default:
+      return; /* BIG kinds never lower (bigint arguments) */
+  }
+  /* Scatter host-independently; le false is the JS big-endian default. */
+  uint8_t *p = b->data + (size_t)off;
+  for (size_t i = 0; i < width; i++) {
+    p[le ? i : width - 1 - i] = (uint8_t)(u >> (8 * i));
+  }
+}
+
 /* ── encodings (u8 only — the compiler routes only u8 receivers here) ──── */
 
 static const char scr_hex_digits[] = "0123456789abcdef";
@@ -884,18 +927,21 @@ 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', the rest
- * '>= 0 && <= max' (Node spells '&&' here, unlike the read/write
- * families' 'and'). max < 0 means copy's no-upper-bound '>= 0' render. */
-static bool scr_bytes_validate_off(const char *name, double value, double max) {
-  if (floor(value) == value && value >= 0 && (max < 0 || value <= max)) return true;
+/* validateOffset(name, 0, max): non-integers are 'an integer' (Number.
+ * isInteger — ±Infinity render 'an integer' too), the rest '>= 0 && <=
+ * max' (Node spells '&&' here, unlike the read/write families' 'and').
+ * max < 0 means copy's no-upper-bound '>= 0' render. Exported: the
+ * checked-dynamic compare/equals validators (scr_bytes_io.c) run the
+ * same ladder after their own type gate. */
+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) {
+  if (floor(value) != value || !isfinite(value)) {
     mlen = snprintf(msg, sizeof msg,
                     "The value of \"%s\" is out of range. It must be an integer. Received %s",
                     name, recv);
@@ -909,7 +955,7 @@ static bool scr_bytes_validate_off(const char *name, double value, double max) {
                     "The value of \"%s\" is out of range. It must be >= 0 && <= %s. Received %s",
                     name, maxb, recv);
   }
-  scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+  scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
   return false;
 }
 
@@ -994,7 +1040,7 @@ static ScrBytes *scr_bytes_fill_core(ScrBytes *b, const uint8_t *pat, size_t pat
                                      bool zero_ok, double nargs, double offset, double end) {
   if (patn == 0 && !zero_ok) {
     static const char msg[] = "The argument 'value' is invalid. Received <Buffer >";
-    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, sizeof msg - 1, "ERR_INVALID_ARG_VALUE");
     return NULL;
   }
   size_t n = (size_t)nargs;
@@ -1065,7 +1111,7 @@ ScrBytes *scr_bytes_swap(ScrBytes *b, double width) {
   if (b->len % w != 0) {
     char msg[64];
     int mlen = snprintf(msg, sizeof msg, "Buffer size must be a multiple of %zu-bits", w * 8);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_INVALID_BUFFER_SIZE");
     return NULL;
   }
   for (size_t g = 0; g < b->len; g += w) {
@@ -1204,8 +1250,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)) {
@@ -1235,7 +1282,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) {
@@ -1244,7 +1291,7 @@ static void scr_bytes_bounds_error(double value, double length, const char *type
                     type ? type : "offset", recv);
   } else if (length < 0) {
     static const char oob[] = "Attempt to access memory outside buffer bounds";
-    scr_throw_error_msg(SCR_ERR_RANGE, oob, sizeof oob - 1);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, oob, sizeof oob - 1, "ERR_BUFFER_OUT_OF_BOUNDS");
     return;
   } else {
     char lenbuf[32];
@@ -1253,7 +1300,7 @@ static void scr_bytes_bounds_error(double value, double length, const char *type
                     "The value of \"%s\" is out of range. It must be >= %d and <= %s. Received %s",
                     type ? type : "offset", type ? 1 : 0, lenbuf, recv);
   }
-  scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+  scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
 }
 
 /* The shared offset gate: width bytes at offset must lie inside b. */
@@ -1276,7 +1323,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) {
@@ -1297,7 +1344,7 @@ static bool scr_bytes_check_int(const ScrBytes *b, double value, double offset,
                       "The value of \"value\" is out of range. It must be >= %s and <= %s. Received %s",
                       minb, maxb, recv);
     }
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return false;
   }
   return scr_bytes_rw_check(b, offset, width);