@scriptc/runtime 0.0.8 → 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_handle.c

@@ -1,77 +1,19 @@
 /* The checked-dynamic HANDLE support unit — everything the handle
  * dispatchers (scr_http.c / scr_net.c) and the emitter unit's dyn
- * registrations share BEYOND the DOM core: errors.js's
- * determineSpecificType renderer and the ERR_INVALID_ARG_TYPE throwers
- * (the listener gate), and the runtime-built listener adapter closures
- * whose fire thunks box event tuples back into the DOM. Split out of
- * scr_json.c so handle-free binaries keep their exact size class:
- * cc.ts compiles this unit exactly when a user of it links (the net or
- * emitter gate — http implies net).
+ * registrations share BEYOND the DOM core: the listener gate over the
+ * ERR_INVALID_ARG_TYPE throwers (the throwers themselves live in
+ * scr_json.c beside the DOM core — the always-linked bytes/fs argument
+ * validators call them too), and the runtime-built listener adapter
+ * closures whose fire thunks box event tuples back into the DOM. Split
+ * out of scr_json.c so handle-free binaries keep their exact size
+ * class: cc.ts compiles this unit exactly when a user of it links (the
+ * net or emitter gate — http implies net).
  */
 #include "scr_runtime.h"
 
 #include <stdio.h>
 #include <string.h>
 
-/* errors.js's determineSpecificType over a DOM value — the "Received
- * ..." tail of Node's ERR_INVALID_ARG_TYPE messages. Renders into buf
- * when the shape needs a payload; returns the text either way. */
-const char *scr_dyn_specific_type(const ScrDyn *cb, char *detail, size_t cap) {
-  const char *d = detail;
-  switch (cb->kind) {
-  case SCR_DYN_NULL: d = "null"; break;
-  case SCR_DYN_UNDEF: d = "undefined"; break;
-  case SCR_DYN_OBJ: d = "an instance of Object"; break;
-  case SCR_DYN_ARR: d = "an instance of Array"; break;
-  case SCR_DYN_BYTES: d = "an instance of Uint8Array"; break;
-  case SCR_DYN_FUNC: d = "function"; break; /* callers usually return before this */
-  case SCR_DYN_HANDLE:
-    snprintf(detail, cap, "an instance of %s", scr_dyn_handle_cls(cb));
-    break;
-  case SCR_DYN_PROMISE: d = "an instance of Promise"; break;
-  case SCR_DYN_BOOL:
-    snprintf(detail, cap, "type boolean (%s)", cb->v.b ? "true" : "false");
-    break;
-  case SCR_DYN_NUM: {
-    char num[32];
-    size_t n = scr_f64_to_str(cb->v.num, num);
-    snprintf(detail, cap, "type number (%.*s)", (int)n, num);
-    break;
-  }
-  case SCR_DYN_STR: {
-    const ScrStr *sv = cb->v.str;
-    char insp[32];
-    size_t n = 0;
-    insp[n++] = '\'';
-    for (size_t i = 0; i < sv->len && n < 28; i++) insp[n++] = sv->data[i];
-    if (sv->len + 2 > 28) {
-      n = 25;
-      memcpy(insp + n, "...", 3);
-      n += 3;
-    } else {
-      insp[n++] = '\'';
-    }
-    snprintf(detail, cap, "type string (%.*s)", (int)n, insp);
-    break;
-  }
-  default: d = "an instance of Object"; break;
-  }
-  return d;
-}
-
-/* Node's ERR_INVALID_ARG_TYPE thrower ("The \"chunk\" argument must be
- * of type string or an instance of Buffer or Uint8Array. Received type
- * number (5)") — the handle dispatchers' per-arg gates. `expected` is
- * the full "of type ..."/"an instance of ..." clause. */
-void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrDyn *got) {
-  char detail[64];
-  const char *d = scr_dyn_specific_type(got, detail, sizeof detail);
-  char msg[224];
-  int len = snprintf(msg, sizeof msg,
-                     "The \"%s\" argument must be %s. Received %s", argname, expected, d);
-  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_TYPE");
-}
-
 /* Node's ERR_INVALID_ARG_TYPE listener gate (errors.js's
  * determineSpecificType shapes — the scr_emitter_check_listener wording,
  * shared here so the gated units need not link the emitter unit). */

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_error.c

@@ -237,6 +237,21 @@ void scr_throw_error_msg_code(int kind, const char *message, size_t len,
                  scr_error_traced ? &scr_error_trace : NULL);
 }
 
+/* A compiler-resolved Node-parity throw (the always-throwing lowered
+ * arms: ERR_INVALID_THIS receivers, ERR_MISSING_ARGS ladders, the
+ * symbol-to-string TypeError): builds the builtin error of `kind` with
+ * `code` stamped when non-empty. Borrows both strings; always throws
+ * (catchably — call sites are compiler-emitted pending checks). */
+void scr_throw_node_coded(double kind, const ScrStr *code, const ScrStr *msg) {
+  ScrError *e = scr_error_new((int)kind, (ScrStr *)msg); /* borrowed in */
+  if (code->len > 0) {
+    scr_str_release(e->code); /* NULL-safe */
+    e->code = scr_str_retain((ScrStr *)code);
+  }
+  scr_throw_obj(e, &scr_error_retain_v, &scr_error_release_v,
+                 scr_error_traced ? &scr_error_trace : NULL);
+}
+
 /* A read of a `declare`d const nothing defines (the bundler-define
  * pattern — __VERSION__): Node running the source throws ReferenceError
  * "<name> is not defined" at the access. Borrows `name`; always throws

package/src/scr_events_emitter.c

@@ -662,6 +662,18 @@ ScrArr *scr_emitter_listeners(ScrEmitter *em, ScrStr *name) {
 
 /* ── max listeners ────────────────────────────────────────────────────── */
 
+/* The checked-dynamic setMaxListeners ladder: non-numbers throw Node's
+ * ERR_INVALID_ARG_TYPE ("The \"setMaxListeners\" argument must be of
+ * type number. Received ..."), numbers run the range gate below.
+ * Borrowed dyn; +1 receiver either way (the pending check unwinds). */
+ScrEmitter *scr_emitter_set_max_chk(ScrEmitter *em, const ScrDyn *n) {
+  if (n->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail("setMaxListeners", "of type number", n);
+    return scr_emitter_retain(em);
+  }
+  return scr_emitter_set_max(em, n->v.num);
+}
+
 ScrEmitter *scr_emitter_set_max(ScrEmitter *em, double n) {
   if (!(n >= 0)) { /* negatives and NaN — Node's validateNumber */
     char num[32];
@@ -682,6 +694,28 @@ double scr_emitter_get_max(ScrEmitter *em) {
   return scr_emitter_default_max;
 }
 
+/* The checked-dynamic defaultMaxListeners ladder — `name` picks the
+ * message's slot ("setMaxListeners" for the static call,
+ * "defaultMaxListeners" for the module-property assignment, Node's own
+ * split). Borrowed. */
+void scr_emitter_set_default_max_chk(const ScrDyn *n, const ScrStr *name) {
+  if (n->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail(name->data, "of type number", n);
+    return;
+  }
+  if (!(n->v.num >= 0)) {
+    char num[32];
+    size_t nlen = scr_f64_to_str(n->v.num, num);
+    char msg[128];
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be >= 0. Received %.*s",
+                       name->data, (int)nlen, num);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return;
+  }
+  scr_emitter_set_default_max(n->v.num);
+}
+
 void scr_emitter_set_default_max(double n) {
   if (!(n >= 0)) { /* negatives and NaN — Node's validateNumber(n, "setMaxListeners", 0) */
     char num[32];

package/src/scr_exception.c

@@ -181,7 +181,10 @@ ScrStr *scr_caught_to_string(const ScrCaught *c) {
  * contract-shaped failure exactly like a trap. Render the same "Uncaught
  * ..." first line the executable epilogue prints (scr_exc_print_uncaught's
  * arms, buffer-writing), release the payload, and route the text through
- * the trap funnel — one failure channel at the boundary. */
+ * the trap funnel — one failure channel at the boundary. The funnel
+ * (scr_library.c) assembles the rendered line into the structured
+ * trap-teaching form (code SC4013, the trapping entry's symbol) before
+ * delivery; only the 0x01-led verbatim path below bypasses assembly. */
 void scr_library_check_exc(void) {
   if (!scr_exc_pending()) return;
   static char buf[1024]; /* the message is copied out before the payload dies */

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