@scriptc/runtime 0.0.21 → 0.0.22

package/package.json

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

package/src/scr_assert.c

@@ -444,6 +444,8 @@ static bool scr_assert_dyn_same_value(const ScrDyn *a, const ScrDyn *b) {
        * === — 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);
+    case SCR_DYN_TYPED_REF:
+      return scr_dyn_strict_eq(a, b);
     default:
       return a == b; /* ARR/OBJ/BYTES: node identity */
   }
@@ -459,6 +461,18 @@ 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 == SCR_DYN_TYPED_REF || b->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *ma = a->kind == SCR_DYN_TYPED_REF
+                     ? scr_dyn_typed_ref_materialize(a)
+                     : scr_dyn_retain((ScrDyn *)a);
+    ScrDyn *mb = b->kind == SCR_DYN_TYPED_REF
+                     ? scr_dyn_typed_ref_materialize(b)
+                     : scr_dyn_retain((ScrDyn *)b);
+    bool same = scr_assert_dyn_deep_eq(ma, mb);
+    scr_dyn_release(ma);
+    scr_dyn_release(mb);
+    return same;
+  }
   if (a->kind != b->kind) {
     /* A MIXED comparison with an island side (wrapped engine object vs
      * dyn data): Node walks both structurally — a plain `false` would
@@ -524,6 +538,8 @@ static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
       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;
+    case SCR_DYN_TYPED_REF:
+      return false; /* both mixed and same-kind capsules returned above */
   }
   return false; /* unreachable */
 }
@@ -684,6 +700,12 @@ static void scr_assert_cf_value(ScrAssertBuf *b, const ScrDyn *d, size_t indent,
       ab_cstr(b, "[island value]");
       return;
     }
+    case SCR_DYN_TYPED_REF: {
+      ScrDyn *materialized = scr_dyn_typed_ref_materialize(d);
+      scr_assert_cf_value(b, materialized, indent, depth);
+      scr_dyn_release(materialized);
+      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). */
@@ -928,6 +950,7 @@ static bool scr_assert_print_myers(ScrAssertBuf *b, const ScrDiffOp *diff, size_
 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_TYPED_REF ||
          scr_dyn_isl_typeof_is(d, "object"); /* engine-held: the engine's typeof */
 }
 

package/src/scr_bytes.c

@@ -86,6 +86,13 @@ void scr_bytes_release_v(void *b) { scr_bytes_release((ScrBytes *)b); }
 
 double scr_bytes_len(const ScrBytes *b) { return (double)b->len; }
 
+void scr_bytes_copy_contents(ScrBytes *dst, const ScrBytes *src) {
+  if (dst->elem != src->elem || dst->len != src->len) {
+    scr_trap("scriptc: typed array snapshot shape changed\n");
+  }
+  memcpy(dst->data, src->data, dst->len * scr_bytes_elem_size(dst->elem));
+}
+
 double scr_bytes_byte_len(const ScrBytes *b) {
   return (double)(b->len * scr_bytes_elem_size(b->elem));
 }

package/src/scr_dyn_invoke.c

@@ -119,6 +119,12 @@ static void scr_dyn_display_buf(ScrJsonBuf *b, const ScrDyn *d) {
      * pending and appends nothing — the loud path). */
     scr_dyn_isl_tostr_buf(b, d);
     return;
+  case SCR_DYN_TYPED_REF: {
+    ScrDyn *materialized = scr_dyn_typed_ref_materialize(d);
+    scr_dyn_display_buf(b, materialized);
+    scr_dyn_release(materialized);
+    return;
+  }
   }
 }
 
@@ -306,6 +312,13 @@ static bool dyn_arr_proto_unimpl(const char *m) {
   for (size_t i = 0; names[i]; i++) if (dyn_name_is(m, names[i])) return true;
   return false;
 }
+static bool dyn_arr_proto_mutates(const char *m) {
+  static const char *names[] = {
+    "push", "pop", "shift", "unshift", "reverse", "sort", NULL
+  };
+  for (size_t i = 0; names[i]; i++) if (dyn_name_is(m, names[i])) return true;
+  return false;
+}
 static bool dyn_bytes_proto_real(const char *m) {
   static const char *names[] = { "slice", "at", "indexOf", "lastIndexOf", "includes", "join",
     "forEach", "map", "filter", "some", "every", "find", "findIndex", "reverse", "fill", "set",
@@ -315,7 +328,19 @@ static bool dyn_bytes_proto_real(const char *m) {
   return false;
 }
 
-ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, size_t argc, const char *what) {
+static ScrDyn *scr_dyn_invoke_impl(
+    ScrDyn *recv, const char *method, ScrDyn *const *args, size_t argc,
+    const char *what, ScrDyn *callback_recv);
+
+ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method,
+                       ScrDyn *const *args, size_t argc,
+                       const char *what) {
+  return scr_dyn_invoke_impl(recv, method, args, argc, what, NULL);
+}
+
+static ScrDyn *scr_dyn_invoke_impl(
+    ScrDyn *recv, const char *method, ScrDyn *const *args, size_t argc,
+    const char *what, ScrDyn *callback_recv) {
   if (recv->kind == SCR_DYN_UNDEF || recv->kind == SCR_DYN_NULL) {
     ScrJsonBuf b;
     scr_jb_init(&b);
@@ -347,6 +372,26 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
     return scr_dyn_jsval_ops()->invoke(recv->v.jsval.cell, method, args, argc, what);
   }
 
+  /* Live Web-boundary capsules expose the prototype of their materialized
+   * value. Run the ordinary dispatch against the stable snapshot, then
+   * commit successful mutations back into the original static value.
+   * Mutators such as reverse/sort return their receiver, so translate that
+   * snapshot identity back to the externally visible capsule. */
+  if (recv->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *materialized = scr_dyn_typed_ref_materialize(recv);
+    bool mutates = materialized->kind == SCR_DYN_ARR &&
+                   dyn_arr_proto_mutates(method);
+    ScrDyn *result = scr_dyn_invoke_impl(
+        materialized, method, args, argc, what, recv);
+    if (mutates && !scr_exc_pending()) scr_dyn_typed_ref_commit(recv);
+    if (result == materialized) {
+      scr_dyn_release(result);
+      result = scr_dyn_retain(recv);
+    }
+    scr_dyn_release(materialized);
+    return result;
+  }
+
   /* OBJ: the own member calls (own properties shadow prototypes in JS
    * too); anything else is Node's is-not-a-function. */
   if (recv->kind == SCR_DYN_OBJ) {
@@ -556,11 +601,17 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
       if (!dyn_cb_check(args, argc)) return NULL;
       ScrDyn *cb = args[0];
       ScrDyn *out = (dyn_name_is(method, "map") || dyn_name_is(method, "filter")) ? scr_dyn_new_arr() : NULL;
-      /* JS iterates the LIVE array (a push mid-loop is visited); reading
-       * len fresh each step matches that. */
-      for (size_t i = 0; i < recv->v.arr.len; i++) {
+      /* Array iteration methods snapshot length before the first callback.
+       * A shrinking callback can remove a later dense entry; an expanding
+       * callback must not make the new tail observable to this pass. Live
+       * Web-boundary capsules are the externally visible receiver, so pass
+       * that capsule as callback arg 3: mutations through the callback's
+       * array argument then commit directly to the original static array. */
+      size_t n = len;
+      ScrDyn *visible_recv = callback_recv ? callback_recv : recv;
+      for (size_t i = 0; i < n && i < recv->v.arr.len; i++) {
         ScrDyn *item = scr_dyn_retain(recv->v.arr.items[i]);
-        ScrDyn *r = dyn_call_cb(cb, item, i, recv);
+        ScrDyn *r = dyn_call_cb(cb, item, i, visible_recv);
         if (!r) { scr_dyn_release(item); scr_dyn_release(out); return NULL; }
         if (dyn_name_is(method, "map")) {
           scr_dyn_arr_push(out, r); /* ownership moves in */
@@ -597,7 +648,8 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
       size_t n = recv->v.arr.len;
       for (size_t i = 0; i < n && i < recv->v.arr.len; i++) {
         ScrDyn *item = scr_dyn_retain(recv->v.arr.items[i]);
-        ScrDyn *r = dyn_call_cb(cb, item, i, recv);
+        ScrDyn *r = dyn_call_cb(
+            cb, item, i, callback_recv ? callback_recv : recv);
         scr_dyn_release(item);
         if (!r) { scr_dyn_release(out); return NULL; }
         if (r->kind == SCR_DYN_ARR) {