@scriptc/runtime 0.0.9 → 0.0.10

package/src/scr_dgram.c

@@ -64,6 +64,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -466,7 +467,18 @@ ScrDgramSocket *scr_dgram_create(bool reuse_addr) {
 }
 
 static void scr_dgram_throw(const char *msg) {
-  scr_throw_error_msg(0 /* Error */, msg, strlen(msg));
+  /* Node's state errors carry their ERR_SOCKET_* codes; the message IS
+   * the discriminant (each arm throws exactly one text). */
+  const char *code =
+      strcmp(msg, "Already connected") == 0 ? "ERR_SOCKET_DGRAM_IS_CONNECTED"
+      : strcmp(msg, "Not running") == 0 ? "ERR_SOCKET_DGRAM_NOT_RUNNING"
+      : strcmp(msg, "Socket is already bound") == 0 ? "ERR_SOCKET_ALREADY_BOUND"
+      : NULL;
+  if (code != NULL) {
+    scr_throw_error_msg_code(0 /* Error */, msg, strlen(msg), code);
+  } else {
+    scr_throw_error_msg(0 /* Error */, msg, strlen(msg));
+  }
 }
 
 /* Resolve a numeric host into a sockaddr_in; "" means any (bind's
@@ -1005,3 +1017,166 @@ void scr_dgram_install(void) {
   atexit(scr_dgram_cleanup_atexit);
   scr_loop_set_dgram(&scr_dgram_pending, &scr_dgram_dispatch, &scr_dgram_pollfd);
 }
+
+/* ── the send argument-validation ladder (checked-dynamic lane) ─────────
+ * Node's Socket.prototype.send signature shuffle and validation order
+ * over DOM arguments, byte-for-byte: the connected/unconnected split
+ * decides whether (a1, a2) are an offset/length slice or the port/address
+ * pair; sliceBuffer validates the buffer's type and bounds
+ * (ERR_BUFFER_OUT_OF_BOUNDS); list payloads validate per element with the
+ * LIST as the Received tail; unconnected sends validate the port
+ * (ERR_SOCKET_BAD_PORT, > 0 and < 65536 with the specific-type tail and
+ * Node's trailing period) and the address's string contract; a send with
+ * a port or address on a connected socket answers ERR_SOCKET_DGRAM_IS_
+ * CONNECTED. A fully-validated unconnected single-payload send RUNS —
+ * the callback form and the connected sends keep the compiler-rendered
+ * fence. All dyn arguments borrowed. */
+
+static bool scr_dgram_dyn_truthy(const ScrDyn *v) {
+  switch (v->kind) {
+  case SCR_DYN_UNDEF:
+  case SCR_DYN_NULL: return false;
+  case SCR_DYN_BOOL: return v->v.b;
+  case SCR_DYN_NUM: return v->v.num == v->v.num && v->v.num != 0;
+  case SCR_DYN_STR: return v->v.str->len > 0;
+  default: return true;
+  }
+}
+
+static uint32_t scr_dgram_to_u32(const ScrDyn *v) {
+  if (v->kind != SCR_DYN_NUM) return 0; /* >>> 0 over the ladder's shapes */
+  double t = v->v.num;
+  if (t != t || isinf(t)) return 0;
+  t = trunc(t);
+  t = fmod(t, 4294967296.0);
+  if (t < 0) t += 4294967296.0;
+  return (uint32_t)t;
+}
+
+static const char SCR_DGRAM_BUF_EXPECTED[] =
+    "of type string or an instance of Buffer, TypedArray, or DataView";
+
+void scr_dgram_send_chk(ScrDgramSocket *s, const ScrDyn *buffer, const ScrDyn *a1,
+                        const ScrDyn *a2, const ScrDyn *a3, const ScrDyn *a4,
+                        const ScrStr *fence) {
+  const ScrDyn *offset = a1, *length = a2, *port = a3, *address = a4;
+  const ScrDyn *callback = scr_dyn_undefined();
+  bool connected = s->connected;
+  bool sliced = false;
+  if (!connected) {
+    if (scr_dgram_dyn_truthy(address) ||
+        (scr_dgram_dyn_truthy(port) && port->kind != SCR_DYN_FUNC)) {
+      sliced = true;
+    } else {
+      callback = port;
+      port = offset;
+      address = length;
+    }
+  } else {
+    if (length->kind == SCR_DYN_NUM) {
+      sliced = true;
+      if (port->kind == SCR_DYN_FUNC) callback = port;
+    } else {
+      callback = offset;
+      port = a3;
+      address = a4;
+    }
+  }
+  size_t slice_off = 0, slice_len = 0;
+  if (sliced) {
+    double bytelen;
+    if (buffer->kind == SCR_DYN_STR) bytelen = (double)buffer->v.str->len;
+    else if (buffer->kind == SCR_DYN_BYTES) bytelen = scr_bytes_byte_len(buffer->v.bytes);
+    else {
+      scr_dyn_arg_type_fail("buffer", SCR_DGRAM_BUF_EXPECTED, buffer);
+      return;
+    }
+    uint32_t off = scr_dgram_to_u32(offset);
+    uint32_t len = scr_dgram_to_u32(length);
+    if ((double)off > bytelen) {
+      static const char msg[] = "\"offset\" is outside of buffer bounds";
+      scr_throw_error_msg_code(SCR_ERR_RANGE, msg, sizeof msg - 1, "ERR_BUFFER_OUT_OF_BOUNDS");
+      return;
+    }
+    if ((double)off + (double)len > bytelen) {
+      static const char msg[] = "\"length\" is outside of buffer bounds";
+      scr_throw_error_msg_code(SCR_ERR_RANGE, msg, sizeof msg - 1, "ERR_BUFFER_OUT_OF_BOUNDS");
+      return;
+    }
+    slice_off = off;
+    slice_len = len;
+  } else if (buffer->kind == SCR_DYN_ARR) {
+    for (size_t i = 0; i < buffer->v.arr.len; i++) {
+      const ScrDyn *e = buffer->v.arr.items[i];
+      if (e->kind != SCR_DYN_STR && e->kind != SCR_DYN_BYTES) {
+        scr_dyn_arg_type_fail("buffer list arguments", SCR_DGRAM_BUF_EXPECTED, buffer);
+        return;
+      }
+    }
+  } else if (buffer->kind != SCR_DYN_STR && buffer->kind != SCR_DYN_BYTES) {
+    scr_dyn_arg_type_fail("buffer", SCR_DGRAM_BUF_EXPECTED, buffer);
+    return;
+  }
+  if (connected) {
+    if (scr_dgram_dyn_truthy(port) || scr_dgram_dyn_truthy(address)) {
+      scr_dgram_throw("Already connected");
+      return;
+    }
+    scr_throw_lowering_fence(fence); /* connected sends have no lowering yet */
+    return;
+  }
+  /* validatePort(port, 'Port', false): integers (or numeric strings)
+   * strictly between 0 and 65536; everything else renders the specific
+   * type with Node's trailing period. */
+  double portnum = -1;
+  {
+    bool ok = false;
+    if (port->kind == SCR_DYN_NUM && trunc(port->v.num) == port->v.num &&
+        port->v.num > 0 && port->v.num < 65536) {
+      ok = true;
+      portnum = port->v.num;
+    } else if (port->kind == SCR_DYN_STR && port->v.str->len > 0) {
+      ScrStr *ps = scr_str_retain(port->v.str);
+      double n = scr_string_to_number(ps);
+      scr_str_release(ps);
+      if (n == n && trunc(n) == n && n > 0 && n < 65536) {
+        ok = true;
+        portnum = n;
+      }
+    }
+    if (!ok) {
+      char detail[64], msg[160];
+      const char *d = scr_dyn_specific_type(port, detail, sizeof detail);
+      int len = snprintf(msg, sizeof msg, "Port should be > 0 and < 65536. Received %s.", d);
+      scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_SOCKET_BAD_PORT");
+      return;
+    }
+  }
+  if (address->kind == SCR_DYN_FUNC) {
+    callback = address;
+    address = scr_dyn_undefined();
+  } else if (address->kind != SCR_DYN_UNDEF && address->kind != SCR_DYN_NULL &&
+             address->kind != SCR_DYN_STR) {
+    /* Node's gate is null/undefined-only: a falsy 0 still throws. */
+    scr_dyn_arg_type_fail("address", "of type string", address);
+    return;
+  }
+  if (callback->kind == SCR_DYN_FUNC || buffer->kind == SCR_DYN_ARR) {
+    /* completion callbacks and list concatenation have no lowering yet —
+     * refuse loudly after the full validation ladder, never drop */
+    scr_throw_lowering_fence(fence);
+    return;
+  }
+  const char *data = buffer->kind == SCR_DYN_STR ? buffer->v.str->data
+                                                 : (const char *)buffer->v.bytes->data;
+  size_t datalen = buffer->kind == SCR_DYN_STR ? buffer->v.str->len
+                                               : (size_t)scr_bytes_byte_len(buffer->v.bytes);
+  if (sliced) {
+    data += slice_off;
+    datalen = slice_len;
+  }
+  ScrStr *host = address->kind == SCR_DYN_STR ? scr_str_retain(address->v.str)
+                                              : scr_str_new("127.0.0.1", 9);
+  scr_dgram_send_raw(s, data, datalen, portnum, host);
+  scr_str_release(host);
+}

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_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