@scriptc/runtime 0.0.9 → 0.0.11

package/src/scr_dyn_invoke.c

@@ -114,6 +114,11 @@ static void scr_dyn_display_buf(ScrJsonBuf *b, const ScrDyn *d) {
      * for a bare promise is "[object Promise]". */
     scr_jb_puts(b, "[object Promise]");
     return;
+  case SCR_DYN_JSVAL:
+    /* The engine's own ToString (a bridged failure leaves the exception
+     * pending and appends nothing — the loud path). */
+    scr_dyn_isl_tostr_buf(b, d);
+    return;
   }
 }
 
@@ -186,6 +191,12 @@ static ScrDyn *dyn_call_cb(ScrDyn *cb, ScrDyn *item, size_t i, ScrDyn *recv) {
 static bool dyn_cb_check(ScrDyn *const *args, size_t argc) {
   ScrDyn *cb = argc > 0 ? args[0] : scr_dyn_undefined();
   if (cb->kind == SCR_DYN_FUNC) return true;
+  /* An ENGINE function is callable — scr_dyn_call's JSVAL arm routes it
+   * (the loops below call through scr_dyn_call, which converts the DOM
+   * element arguments per the uniform crossing). A wrapped NON-function
+   * falls through to the display path: String(cb) renders through the
+   * engine, exactly Node's message. */
+  if (cb->kind == SCR_DYN_JSVAL && scr_dyn_isl_typeof_is(cb, "function")) return true;
   ScrJsonBuf b;
   scr_jb_init(&b);
   scr_dyn_display_buf(&b, cb);
@@ -289,7 +300,7 @@ static bool dyn_arr_sort(ScrDyn *recv, ScrDyn *cmp) {
 /* Names each prototype declares BEYOND what's implemented here — these
  * fence loudly instead of mis-answering "is not a function". */
 static bool dyn_arr_proto_unimpl(const char *m) {
-  static const char *names[] = { "splice", "reduce", "reduceRight", "flat", "flatMap",
+  static const char *names[] = { "splice", "reduce", "reduceRight", "flat",
     "fill", "copyWithin", "keys", "values", "entries", "toReversed", "toSorted", "toSpliced",
     "with", "toString", "toLocaleString", NULL };
   for (size_t i = 0; names[i]; i++) if (dyn_name_is(m, names[i])) return true;
@@ -325,11 +336,25 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
     return scr_dynh_dispatch(recv, method, args, argc, what);
   }
 
+  /* Island-held receivers: the ENGINE runs its own prototypes (JS-exact
+   * flatMap/map/forEach/filter — Array.prototype is the engine's) through
+   * scr_jsval_call_method; arguments cross per the uniform conversion
+   * (wrapped cells by reference, DOM data deep-copied, FUNC boxes through
+   * the host shim), a missing member throws the engine's own TypeError,
+   * and the result wraps back scalar-normalized. `what` is unused — the
+   * engine's message names the failure. */
+  if (recv->kind == SCR_DYN_JSVAL) {
+    return scr_dyn_jsval_ops()->invoke(recv->v.jsval.cell, method, args, argc, what);
+  }
+
   /* 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) {
     ScrDyn *m = scr_dyn_obj_get(recv, method, strlen(method));
-    if (m && m->kind == SCR_DYN_FUNC) {
+    if (m && (m->kind == SCR_DYN_FUNC ||
+              /* a WRAPPED engine function stored as a DOM member: the
+               * routed call (scr_dyn_call's JSVAL arm) runs it. */
+              (m->kind == SCR_DYN_JSVAL && scr_dyn_isl_typeof_is(m, "function")))) {
       /* JS binds the receiver for the call (`obj.method()` — this === obj):
        * the ambient-receiver window (scr_runtime.h). */
       scr_dyn_this_push_dyn(recv);
@@ -374,6 +399,23 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
       dyn_throw_unsupported("Function", method);
       return NULL;
     }
+    /* An OWN property on the FUNC box (defineProperties writes — the
+     * mustCall-wrapper expando family): a callable member runs with the
+     * box bound (JS's o.m() receiver), everything else keeps Node's
+     * is-not-a-function. */
+    {
+      ScrDyn *own = scr_dyn_fn_get(recv, method, strlen(method));
+      if (own) {
+        if (own->kind == SCR_DYN_FUNC || own->kind == SCR_DYN_JSVAL) {
+          scr_dyn_this_push_dyn(recv);
+          ScrDyn *r = scr_dyn_call(own, args, argc, what);
+          scr_dyn_this_pop();
+          scr_dyn_release(own);
+          return r;
+        }
+        scr_dyn_release(own);
+      }
+    }
     dyn_throw_not_fn(what);
     return NULL;
   }
@@ -541,6 +583,53 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
       if (dyn_name_is(method, "findIndex")) return scr_dyn_new_num(-1);
       return scr_dyn_retain(scr_dyn_undefined()); /* forEach */
     }
+    if (dyn_name_is(method, "flatMap")) {
+      /* JS Array.prototype.flatMap over a DOM array: map + a depth-1
+       * flatten. Native DOM-array results flatten element-by-element; a
+       * WRAPPED engine array flattens through the routed keyed reads
+       * (elements wrap back scalar-normalized); everything else pushes
+       * as a single element (JS keeps non-array callback results whole).
+       * JS's spec snapshots the length up front (elements appended by
+       * the callback are not visited). */
+      if (!dyn_cb_check(args, argc)) return NULL;
+      ScrDyn *cb = args[0];
+      ScrDyn *out = scr_dyn_new_arr();
+      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);
+        scr_dyn_release(item);
+        if (!r) { scr_dyn_release(out); return NULL; }
+        if (r->kind == SCR_DYN_ARR) {
+          for (size_t j = 0; j < r->v.arr.len; j++) {
+            scr_dyn_arr_push(out, scr_dyn_retain(r->v.arr.items[j]));
+          }
+          scr_dyn_release(r);
+        } else if (scr_dyn_isl_is_array(r)) {
+          /* An engine-array result: length + element reads through the
+           * routed engine ops (a bridged surprise unwinds). */
+          ScrStr *lk = scr_str_new("length", 6);
+          ScrDyn *lenv = scr_dyn_isl_key_get(r, lk);
+          scr_str_release(lk);
+          if (!lenv) { scr_dyn_release(r); scr_dyn_release(out); return NULL; }
+          size_t rn = lenv->kind == SCR_DYN_NUM ? (size_t)lenv->v.num : 0;
+          scr_dyn_release(lenv);
+          for (size_t j = 0; j < rn; j++) {
+            char idx[24];
+            int ilen = snprintf(idx, sizeof idx, "%zu", j);
+            ScrStr *jk = scr_str_new(idx, (size_t)ilen);
+            ScrDyn *el = scr_dyn_isl_key_get(r, jk);
+            scr_str_release(jk);
+            if (!el) { scr_dyn_release(r); scr_dyn_release(out); return NULL; }
+            scr_dyn_arr_push(out, el); /* ownership moves in */
+          }
+          scr_dyn_release(r);
+        } else {
+          scr_dyn_arr_push(out, r); /* ownership moves in */
+        }
+      }
+      return out;
+    }
     if (dyn_name_is(method, "sort")) {
       ScrDyn *cmp = argc > 0 ? args[0] : scr_dyn_undefined();
       if (cmp->kind != SCR_DYN_UNDEF && cmp->kind != SCR_DYN_FUNC) {
@@ -598,6 +687,11 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
  * (DOM properties are plain data properties — SEMANTICS.md); get/set
  * throw the loud unsupported Error, never a silent drop. */
 ScrDyn *scr_dyn_define_props(ScrDyn *target, ScrDyn *descs) {
+  /* Island-held operands ARE objects to Node — the non-object TypeError
+   * below would be a wrong claim. Loud fence (lane dyn-routing-ops). */
+  scr_dyn_isl_fence(target, "Object.defineProperties");
+  if (!scr_exc_pending()) scr_dyn_isl_fence(descs, "Object.defineProperties");
+  if (scr_exc_pending()) return NULL;
   if (target->kind != SCR_DYN_OBJ && target->kind != SCR_DYN_FUNC) {
     scr_throw_error_msg(SCR_ERR_TYPE, "Object.defineProperties called on non-object",
                         strlen("Object.defineProperties called on non-object"));

package/src/scr_events_emitter.c

@@ -85,6 +85,12 @@ typedef struct ScrEeBucket {
 struct ScrEeReg {
   ScrEeBucket *head; /* singly linked, first-registration order */
   double max;        /* -1 = unset (follows the default), 0 = unlimited */
+  /* Node's kShapeMode: set when names were PRE-CREATED (the stream
+   * constructors). In shape mode removeListener KEEPS an emptied name's
+   * rank (Node writes events[type] = undefined instead of deleting) —
+   * only removeAllListeners deletes: the named form drops the one key,
+   * the no-argument wipe resets everything and leaves shape mode. */
+  bool shape;
 };
 
 /* The vtable of BARE `new EventEmitter()` instances; the emitted main()
@@ -145,6 +151,21 @@ static ScrEeBucket *scr_ee_bucket_ensure(ScrEeReg *reg, ScrStr *name) {
   return b;
 }
 
+/* Reserve a name's first-registration RANK without any listener: Node's
+ * stream classes pre-create their known _events keys (a V8 shape
+ * optimization eventNames() order observes — 'error'/'data'/... list
+ * before user events added earlier). An empty bucket is ABSENT for every
+ * read (n == 0 everywhere); the first add fills it in place, and a bucket
+ * emptied by removal still drops — Node deleting the key. */
+void scr_emitter_reserve(ScrEmitter *em, const char *name) {
+  ScrEeReg *reg = scr_ee_reg_ensure(em);
+  reg->shape = true;
+  if (scr_ee_bucket_find(reg, name, strlen(name))) return;
+  ScrStr *n = scr_str_new(name, strlen(name));
+  scr_ee_bucket_ensure(reg, n);
+  scr_str_release(n);
+}
+
 /* Drops an emptied bucket from the list (Node deletes the _events key; a
  * later add re-appends at the end). */
 static void scr_ee_bucket_drop(ScrEeReg *reg, ScrEeBucket *b) {
@@ -402,13 +423,14 @@ void scr_ee_inv_fixed4(ScrClosure *cb, va_list ap) {
 
 /* Removes one entry (by index) from a bucket's live list and fires the
  * 'removeListener' meta event AFTER the removal, Node's order. Drops the
- * bucket when emptied. */
+ * bucket when emptied — except in shape mode, where the emptied name
+ * keeps its rank (Node's events[type] = undefined). */
 static void scr_ee_remove_at(ScrEmitter *em, ScrEeBucket *b, size_t i) {
   ScrEeEntry *e = b->ls[i];
   memmove(b->ls + i, b->ls + i + 1, (b->n - i - 1) * sizeof *b->ls);
   b->n--;
   ScrStr *name = scr_str_retain(b->name);
-  if (b->n == 0) scr_ee_bucket_drop(em->reg, b);
+  if (b->n == 0 && !em->reg->shape) scr_ee_bucket_drop(em->reg, b);
   scr_ee_entry_unref(e);
   scr_ee_emit_meta(em, "removeListener", name);
   scr_str_release(name);
@@ -456,6 +478,13 @@ void scr_emitter_check_listener(const ScrDyn *cb) {
  * firing the meta event — and the whole-emitter form does every other
  * event first (bucket order), 'removeListener' itself LAST. Returns em +1. */
 static void scr_ee_remove_all_named(ScrEmitter *em, ScrEeBucket *b, bool meta) {
+  if (b->n == 0) {
+    /* An empty rank-holding bucket reaches here only from the WIPE scan
+     * (the named form skips undefined keys — Node no-ops and the rank
+     * stays): drop it, the wipe resets _events wholesale. */
+    scr_ee_bucket_drop(em->reg, b);
+    return;
+  }
   if (!meta) {
     for (size_t i = 0; i < b->n; i++) scr_ee_entry_unref(b->ls[i]);
     b->n = 0;
@@ -497,7 +526,26 @@ ScrEmitter *scr_emitter_remove_all(ScrEmitter *em, ScrStr *name, bool all) {
   bool meta = scr_ee_has(reg, "removeListener");
   if (!all) {
     ScrEeBucket *b = scr_ee_bucket_find(reg, name->data, name->len);
-    if (b) scr_ee_remove_all_named(em, b, meta);
+    /* A rank-holding empty bucket is Node's `events[type] === undefined`:
+     * the named form no-ops there (the rank survives). A POPULATED name
+     * deletes its key even in shape mode — but through the meta path each
+     * listener leaves via removeListener, whose shape rule KEEPS the
+     * emptied rank (Node's exact split). */
+    if (b && b->n > 0) {
+      scr_ee_remove_all_named(em, b, meta);
+      if (!meta) {
+        /* Node's non-meta named branch: the count hitting zero replaces
+         * _events wholesale — every rank (pre-created included) goes,
+         * though kShapeMode itself stays set (Node's exact quirk). */
+        bool any_live = false;
+        for (ScrEeBucket *w = reg->head; w; w = w->next) {
+          if (w->n > 0) { any_live = true; break; }
+        }
+        if (!any_live) {
+          while (reg->head) scr_ee_bucket_drop(reg, reg->head);
+        }
+      }
+    }
     return scr_emitter_retain(em);
   }
   /* Every event except 'removeListener' first, in bucket order; then
@@ -515,6 +563,10 @@ ScrEmitter *scr_emitter_remove_all(ScrEmitter *em, ScrStr *name, bool all) {
   }
   ScrEeBucket *rl = scr_ee_bucket_find(reg, "removeListener", 14);
   if (rl) scr_ee_remove_all_named(em, rl, meta);
+  /* The wipe replaces _events wholesale in Node — pre-created ranks are
+   * gone and the emitter leaves shape mode. */
+  while (reg->head) scr_ee_bucket_drop(reg, reg->head);
+  reg->shape = false;
   return scr_emitter_retain(em);
 }
 
@@ -633,12 +685,13 @@ double scr_emitter_listener_count_fn(ScrEmitter *em, ScrStr *name, ScrClosure *f
 }
 
 /* eventNames(): +1 string[] of the bucket names in first-registration
- * order (exactly Node's _events key order). */
+ * order (exactly Node's _events key order). Reserved-but-empty buckets
+ * (the stream pre-created keys) are invisible until a listener lands. */
 ScrArr *scr_emitter_event_names(ScrEmitter *em) {
   ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
   if (em->reg) {
     for (ScrEeBucket *b = em->reg->head; b; b = b->next) {
-      scr_arr_push_ref(out, scr_str_retain(b->name));
+      if (b->n > 0) scr_arr_push_ref(out, scr_str_retain(b->name));
     }
   }
   return out;

package/src/scr_inspect.c

@@ -775,8 +775,18 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) {
       return out;
     }
     case SCR_DYN_OBJ: {
-      if (d->v.obj.len == 0) return scr_str_new("{}", 2);
-      if (recurse > depth) return scr_str_new("[Object]", 8);
+      /* Object.create(null)'s dictionary: Node prefixes the rendering
+       * with "[Object: null prototype]" (formatValue's constructor-less
+       * base), the empty form included, and the beyond-depth answer IS
+       * the bare marker (where a plain object says [Object]). */
+      if (d->v.obj.len == 0) {
+        return d->null_proto ? scr_str_new("[Object: null prototype] {}", 27)
+                             : scr_str_new("{}", 2);
+      }
+      if (recurse > depth) {
+        return d->null_proto ? scr_str_new("[Object: null prototype]", 24)
+                             : scr_str_new("[Object]", 8);
+      }
       scr_insp_begin(recurse + 1);
       for (size_t i = 0; i < d->v.obj.len; i++) {
         ScrDynEntry *ent = &d->v.obj.entries[i];
@@ -790,7 +800,8 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) {
         scr_insp_entry(entry, false);
         scr_str_release(entry);
       }
-      ScrStr *base = scr_str_new("", 0);
+      ScrStr *base = d->null_proto ? scr_str_new("[Object: null prototype]", 24)
+                                   : scr_str_new("", 0);
       ScrStr *b0 = scr_str_new("{", 1);
       ScrStr *b1 = scr_str_new("}", 1);
       ScrStr *out = scr_insp_end(base, b0, b1, recurse + 1, false, false);
@@ -825,6 +836,19 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) {
       scr_throw_error(SCR_ERR_ERROR, ib_take(&out));
       return scr_str_new("", 0);
     }
+    case SCR_DYN_JSVAL: {
+      /* An island value inside the DOM: Node prints the engine object's
+       * property dump — fence loudly, naming the engine typeof (the
+       * scr_insp_jsval wording for bare 'any' composites). */
+      ScrStr *t = scr_dyn_typeof(d); /* routes to the engine; +1 */
+      InspBuf out = {0};
+      ib_cstr(&out, "util.inspect of a composite 'any' value (typeof '");
+      ib_bytes(&out, t->data, t->len);
+      ib_cstr(&out, "') is not supported yet");
+      scr_str_release(t);
+      scr_throw_error(SCR_ERR_ERROR, ib_take(&out));
+      return scr_str_new("", 0);
+    }
     case SCR_DYN_PROMISE: {
       /* Node renders Promise { <pending> } / Promise { value } — the
        * settled-value rendering pulls in the whole inspector; fence