@scriptc/runtime 0.0.9 → 0.0.10

package/src/scr_lib.c

@@ -1347,7 +1347,27 @@ static double scr_net_autosel_timeout_ms = 250;
 
 double scr_net_get_autosel_timeout(void) { return scr_net_autosel_timeout_ms; }
 
-void scr_net_set_autosel_timeout(double ms) { scr_net_autosel_timeout_ms = ms; }
+/* Node's setDefaultAutoSelectFamilyAttemptTimeout: validateInt32(value,
+ * 'value', 1), then the sub-10ms floor (Node clamps small budgets to
+ * 10ms). Throws ERR_OUT_OF_RANGE catchably. */
+void scr_net_set_autosel_timeout(double ms) {
+  char recv[48], msg[160];
+  if (!(isfinite(ms) && trunc(ms) == ms)) {
+    scr_num_received(ms, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"value\" is out of range. It must be an integer. Received %s", recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return;
+  }
+  if (ms < 1 || ms > 2147483647.0) {
+    scr_num_received(ms, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"value\" is out of range. It must be >= 1 && <= 2147483647. Received %s", recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return;
+  }
+  scr_net_autosel_timeout_ms = ms < 10 ? 10 : ms;
+}
 
 /* ── fs error formatting ─────────────────────────────────────────────
  * Node's fs errors read "<ERRNO>: <text>, <syscall> '<path>'"

package/src/scr_net.c

@@ -92,6 +92,7 @@
 #include "scr_runtime.h"
 
 #include <errno.h>
+#include <math.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -1601,6 +1602,117 @@ ScrNetSocket *scr_net_connect(double port, ScrStr *host /*borrowed, nullable*/,
   return s;
 }
 
+/* ── the connect option-bag validation ladders (checked-dynamic lane) ──
+ * Node-order validation over DOM option values with Node's exact typed
+ * errors; the honest tail (connect for the validated forms, the
+ * compiler-rendered fence for bags with unmodeled keys) runs only after
+ * every validation passes. */
+
+static bool scr_net_attempt_timeout_chk(const ScrDyn *t, const char *name) {
+  if (t->kind != SCR_DYN_NUM) {
+    scr_dyn_prop_type_fail(name, "of type number", t);
+    return false;
+  }
+  char recv[48], msg[192];
+  if (!(isfinite(t->v.num) && trunc(t->v.num) == t->v.num)) {
+    scr_num_received(t->v.num, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be an integer. Received %s",
+                       name, recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  if (t->v.num < 1 || t->v.num > 2147483647.0) {
+    scr_num_received(t->v.num, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be >= 1 && <= 2147483647. Received %s",
+                       name, recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  return true;
+}
+
+/* connect({ ..., autoSelectFamilyAttemptTimeout }): the budget validates
+ * (validateInt32 from 1, Node's exact texts) and is then inert — this
+ * slice's single dial has nothing to time, the same simplification the
+ * autoSelectFamily flag already takes. NULL with the throw pending. */
+ScrNetSocket *scr_net_connect_attempt(double port, ScrStr *host, const ScrDyn *t) {
+  if (!scr_net_attempt_timeout_chk(t, "options.autoSelectFamilyAttemptTimeout")) return NULL;
+  return scr_net_connect(port, host, NULL);
+}
+
+static bool scr_net_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;
+  }
+}
+
+/* net.connect/createConnection over a RUNTIME option bag (computed keys
+ * — the invalid-input probes): Node's Socket-constructor order — the
+ * objectMode trio throws ERR_INVALID_ARG_VALUE first, then the port
+ * (validatePort), the host's string contract, autoSelectFamily's boolean
+ * contract, and the attempt budget. A bag that survives everything meets
+ * the compiler-rendered fence: an unmodeled key must refuse loudly, never
+ * silently drop. Always leaves an exception pending. */
+void scr_net_connect_opts_chk(const ScrDyn *opts, const ScrStr *fence) {
+  if (opts == NULL || opts->kind != SCR_DYN_OBJ) {
+    scr_dyn_arg_type_fail("options", "of type object",
+                          opts ? opts : scr_dyn_undefined());
+    return;
+  }
+  static const char *const om[] = { "objectMode", "readableObjectMode", "writableObjectMode" };
+  for (size_t i = 0; i < 3; i++) {
+    const ScrDyn *v = scr_dyn_obj_get(opts, om[i], strlen(om[i]));
+    if (v != NULL && scr_net_dyn_truthy(v)) {
+      char name[48];
+      snprintf(name, sizeof name, "options.%s", om[i]);
+      scr_dyn_arg_value_fail(name, "is not supported", v);
+      return;
+    }
+  }
+  const ScrDyn *port = scr_dyn_obj_get(opts, "port", 4);
+  if (port != NULL && port->kind != SCR_DYN_UNDEF) {
+    bool ok = port->kind == SCR_DYN_NUM && trunc(port->v.num) == port->v.num &&
+              port->v.num >= 0 && port->v.num < 65536;
+    if (!ok && port->kind == SCR_DYN_STR) {
+      ScrStr *ps = scr_str_retain(port->v.str);
+      double n = scr_string_to_number(ps);
+      scr_str_release(ps);
+      ok = n == n && trunc(n) == n && n >= 0 && n < 65536 && port->v.str->len > 0;
+    }
+    if (!ok) {
+      char detail[64], msg[160];
+      const char *d = scr_dyn_specific_type(port, detail, sizeof detail);
+      int len = snprintf(msg, sizeof msg,
+                         "options.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;
+    }
+  }
+  const ScrDyn *host = scr_dyn_obj_get(opts, "host", 4);
+  if (host != NULL && host->kind != SCR_DYN_UNDEF && host->kind != SCR_DYN_STR) {
+    scr_dyn_prop_type_fail("options.host", "of type string", host);
+    return;
+  }
+  const ScrDyn *asf = scr_dyn_obj_get(opts, "autoSelectFamily", 16);
+  if (asf != NULL && asf->kind != SCR_DYN_UNDEF && asf->kind != SCR_DYN_BOOL) {
+    scr_dyn_prop_type_fail("options.autoSelectFamily", "of type boolean", asf);
+    return;
+  }
+  const ScrDyn *att = scr_dyn_obj_get(opts, "autoSelectFamilyAttemptTimeout", 30);
+  if (att != NULL && att->kind != SCR_DYN_UNDEF &&
+      !scr_net_attempt_timeout_chk(att, "options.autoSelectFamilyAttemptTimeout")) {
+    return;
+  }
+  scr_throw_lowering_fence(fence);
+}
+
 /* ── the caller-lookup dial (net.connect with a lookup option) ─────────
  *
  * portless's createLoopbackConnection: connect({ host, port,

package/src/scr_runtime.h

@@ -2617,6 +2617,28 @@ typedef enum {
    * (the dyn→closure stance): a cycle THROUGH a dyn-boxed promise is
    * merely never collected. */
   SCR_DYN_PROMISE,
+  /* An ISLAND (engine-held) value — the jsval→DOM crossing. Never
+   * produced by the parser — it enters the DOM through the gated
+   * constructor scr_dyn_from_jsval (scr_island.c): an 'any'-typed value
+   * flowing into an 'unknown'/'object'/JS-residue slot. Boxes by
+   * REFERENCE (a retained ScrJsval cell). The constructor SCALAR-
+   * NORMALIZES: engine numbers/strings/booleans/null/undefined convert
+   * to the native DOM kinds at wrap time, so JSVAL nodes only ever hold
+   * engine objects, arrays, and functions (plus the symbol/bigint edge —
+   * kinds the DOM cannot represent at all). Identity is the CELL's
+   * engine value: strict equality routes to the engine's === (two wraps
+   * of one engine value compare equal), and scr_jsval_from_dyn unwraps
+   * the SAME cell back (+1) — the boundary is identity-preserving for
+   * engine-born values. typeof/truthiness/String() route to the engine
+   * per use (scr_dyn_jsval_ops); every DOM walk without an armed route
+   * (JSON, structuredClone, deepStrictEqual, inspect, keyed access,
+   * calls, iteration) throws the LOUD "not supported yet" ladder — never
+   * a silent wrong answer. The dyn→cell edge is NOT visible to the cycle
+   * collector (the dyn→closure stance): a cycle DOM → cell → engine
+   * object → host closure → DOM is merely never collected (the
+   * documented cross-boundary-cycle divergence). Enum position: LAST —
+   * the LLVM backend hardcodes the preceding kind numbers. */
+  SCR_DYN_JSVAL,
 } ScrDynKind;
 
 /* The handle-type tags the DOM can carry. The set is deliberately the
@@ -2636,6 +2658,10 @@ typedef enum {
 typedef struct ScrDyn ScrDyn;
 typedef struct ScrBytes ScrBytes; /* full definition below (C11 repeat) */
 typedef struct ScrClosure ScrClosure; /* full definition below (C11 repeat) */
+typedef struct ScrJsval ScrJsval; /* opaque island cell (C11 repeat; the
+                                   * always-linked DOM core never touches
+                                   * its engine value — only the gated ops
+                                   * installed by scr_dyn_from_jsval do) */
 
 /* The compiler-emitted call glue carried by a SCR_DYN_FUNC box: checks the
  * dyn arguments against the boxed closure's declared parameter types (a
@@ -2661,6 +2687,16 @@ struct ScrDyn {
    * coercion and toString() decode utf8, where a plain Uint8Array joins
    * its elements ("1,2,3"). Everything else ignores it. */
   bool buffer;
+  /* SCR_DYN_OBJ flavor: true for Object.create(null)'s dictionary — an
+   * object with NO prototype. Method dispatch needs nothing (the DOM's
+   * OBJ dispatch is already own-member-only, which IS Node's null-proto
+   * answer); util.inspect prefixes "[Object: null prototype]", and
+   * deepStrictEqual separates it from plain objects (Node compares
+   * prototypes — the bytes `buffer` gate's stance). Keyed reads/writes,
+   * Object.keys/entries/assign, JSON, and typeof are flag-blind, and
+   * fresh copies (structuredClone) DROP the flag — Node's serialization
+   * answers a plain object too. */
+  bool null_proto;
   union {
     bool b;
     double num;
@@ -2688,6 +2724,11 @@ struct ScrDyn {
      * emitted converters guarantee it (direct box for promise<dyn>,
      * adapter promise otherwise). */
     ScrPromise *promise;
+    /* SCR_DYN_JSVAL: the retained island cell (engine objects/arrays/
+     * functions only — the constructor scalar-normalizes; see the kind's
+     * comment). Released through the installed ops so this always-linked
+     * core never references the gated island unit. */
+    struct { ScrJsval *cell; } jsval;
   } v;
 };
 
@@ -2716,8 +2757,24 @@ ScrDyn *scr_dyn_obj_keys(const ScrDyn *v);
  * TypeError; every other kind answers false. */
 bool scr_dyn_has_own(const ScrDyn *v, const ScrStr *key);
 /* Object.assign over DOM values (+1 target back; ToObject TypeError on a
- * nullish target). */
+ * nullish target). Sources copy their own enumerable keys exactly as
+ * Object.keys lists them: OBJ members, ARR/STR/BYTES index keys; nullish
+ * and scalar/function/handle sources copy nothing. */
 ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src);
+/* Variadic Object.assign (the spread-source form): the compiler packs
+ * every source into one fresh DOM array — pack_push retains a plain
+ * source in (BORROWED), pack_push_spread flattens a spread source through
+ * the spread-call walk (V8's exact TypeError texts, `what` spelling the
+ * spread expression; MAY THROW pending) — then assign_all copies each
+ * pack element's own members onto the target left to right and answers
+ * the target retained (+1; ToObject TypeError on a nullish target). */
+void scr_dyn_pack_push(ScrDyn *pack, ScrDyn *v);
+void scr_dyn_pack_push_spread(ScrDyn *pack, const ScrDyn *src, const ScrStr *what);
+/* The iterated-path twin — a spread that is NOT the single last argument
+ * takes V8's iterator-protocol failure texts, which describe the VALUE
+ * ("object null", "number 5", ...) instead of spelling the expression. */
+void scr_dyn_pack_push_spread_iter(ScrDyn *pack, const ScrDyn *src);
+ScrDyn *scr_dyn_assign_all(ScrDyn *target, const ScrDyn *sources);
 ScrDyn *scr_dyn_obj_values(const ScrDyn *v);
 ScrDyn *scr_dyn_obj_entries(const ScrDyn *v);
 
@@ -2735,6 +2792,9 @@ ScrDyn *scr_dyn_new_num(double n);
 ScrDyn *scr_dyn_new_str(ScrStr *s);
 ScrDyn *scr_dyn_new_arr(void);
 ScrDyn *scr_dyn_new_obj(void);
+/* Object.create(null): the fresh null-prototype dictionary (see the
+ * null_proto flavor flag above). */
+ScrDyn *scr_dyn_new_obj_null_proto(void);
 /* Wraps a fresh COPY of the u8 payload (the static→dyn boundary copies —
  * DataView-backed sources copy their aliased window). Borrows b. */
 ScrDyn *scr_dyn_new_bytes_copy(const ScrBytes *b);
@@ -2753,6 +2813,12 @@ void scr_dyn_arr_push(ScrDyn *arr, ScrDyn *item);
  * nullish sources spell the spread expression (`what`), everything else is
  * the generic "Spread syntax requires ..." text. Borrows src. */
 void scr_dyn_arr_push_spread(ScrDyn *arr, const ScrDyn *src, const char *what);
+/* Destructuring pack over a DOM source: iterable kinds (arrays, strings by
+ * code point, bytes) collect into a fresh array (+1); every other kind
+ * throws V8's destructuring TypeError — `msg` verbatim when non-empty (the
+ * compile-time source spelling), else the runtime kind wording. Borrows
+ * both; NULL with the exception pending on the throw. */
+ScrDyn *scr_dyn_iter_pack(const ScrDyn *src, const ScrStr *msg);
 void scr_dyn_obj_set(ScrDyn *obj, const char *key, size_t key_len, ScrDyn *value);
 /* The checked-dynamic keyed WRITE (`h.k = v` on a dyn receiver): OBJ sets
  * the member (JS: later writes win, insertion order); undefined/null and
@@ -2766,6 +2832,10 @@ ScrStr *scr_dyn_typeof(const ScrDyn *d);
  * enc — utf8 default; strings/numbers/booleans/arrays/objects answer
  * JS-exactly; undefined/null throw the catchable TypeError). Borrows; +1. */
 ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc);
+/* The method-call spelling `d.toString(enc?)`: identical, except a
+ * null-prototype dictionary throws "<what> is not a function" — its
+ * prototype chain has no toString (Node's answer). */
+ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what);
 /* JS String() over the DOM kind (units render "null"/"undefined" where
  * scr_dyn_to_string throws) — the web globals' WebIDL ToString. +1. */
 ScrStr *scr_dyn_string_coerce(const ScrDyn *d);
@@ -2943,6 +3013,87 @@ ScrDyn *scr_dyn_new_promise_adapting(ScrPromise *src,
 /* BORROWED peek at the boxed promise; NULL when d is not a promise box. */
 ScrPromise *scr_dyn_promise_of(const ScrDyn *d);
 
+/* ── island values in the DOM (SCR_DYN_JSVAL) ─────────────────────────
+ * Engine routing ops for JSVAL nodes, installed by the gated constructor
+ * (scr_dyn_from_jsval, scr_island.c — the scr_dyn_alloc_promise hook
+ * story: JSVAL nodes exist only after the constructor ran, so the ops
+ * are always installed when a dispatch arm meets the kind, and a
+ * dynamic-free link never references engine symbols). Contracts mirror
+ * the scr_jsval_* entries they route to. */
+typedef struct ScrDynJsvalOps {
+  void (*release)(ScrJsval *cell);
+  ScrStr *(*type_of)(ScrJsval *cell); /* engine typeof; +1, never throws */
+  bool (*truthy)(ScrJsval *cell);     /* engine ToBoolean; never throws */
+  /* String(v) in the engine (the full ToString protocol — user toString
+   * runs, its throw bridges): +1, or NULL with the exception pending. */
+  ScrStr *(*to_str)(ScrJsval *cell);
+  bool (*strict_eq)(ScrJsval *a, ScrJsval *b); /* engine ===; never throws */
+  bool (*is_array)(ScrJsval *cell);   /* Array.isArray, engine-side */
+  bool (*is_error)(ScrJsval *cell);   /* native Error instance, engine-side */
+  /* ── the routed operation set (lane dyn-routing-ops) ────────────────
+   * Each routes to the engine at the moment of use and converts at the
+   * boundary: dyn ARGUMENTS cross through scr_jsval_from_dyn (wrapped
+   * cells unwrap by reference, DOM data deep-copies, DOM FUNC boxes
+   * cross through the generic host-function shim), engine RESULTS come
+   * back through scr_dyn_from_jsval (scalar-normalizing). Fallible ops
+   * bridge the ENGINE's exception catchably and answer NULL/false/-1. */
+  ScrDyn *(*key_get)(ScrJsval *cell, const ScrStr *k); /* o[k]; +1 or NULL pending */
+  bool (*key_set)(ScrJsval *cell, const ScrStr *k, const ScrDyn *v); /* false = pending */
+  ScrDyn *(*call)(ScrJsval *cell, ScrDyn *const *args, size_t argc); /* f(...); +1 or NULL pending */
+  /* o.m(...) — the ENGINE's own prototypes run (JS-exact flatMap/map/
+   * forEach/...). A missing or non-callable member throws Node's
+   * "<what> is not a function" (the call site's spelling — V8's text,
+   * front-run before the engine's terser claim). */
+  ScrDyn *(*invoke)(ScrJsval *cell, const char *method, ScrDyn *const *args, size_t argc, const char *what);
+  bool (*is_nullish)(ScrJsval *cell); /* engine undefined/null; never throws
+                                       * (always false today — the wrap
+                                       * constructor scalar-normalizes) */
+  /* Object.keys/values/entries (mode 0/1/2) as a NATIVE DOM array (+1):
+   * keys are DOM strings, values wrap per element, entries are native
+   * DOM pairs. NULL with the engine's exception pending on refusal. */
+  ScrDyn *(*obj_walk)(ScrJsval *cell, int mode);
+  int (*has_own)(ScrJsval *cell, const ScrStr *k); /* 0/1; -1 = pending */
+  /* Object.assign(target, src) with the ENGINE target: src converts per
+   * member semantics (a wrapped src spreads by reference; DOM data
+   * enters as the usual deep copy). false = pending. */
+  bool (*assign)(ScrJsval *cell, const ScrDyn *src);
+  /* JSON.stringify text of the engine value (+1) — the engine's own
+   * stringify (toJSON protocols, cycle TypeErrors). NULL + pending when
+   * not JSON-representable. */
+  ScrStr *(*to_json)(ScrJsval *cell);
+} ScrDynJsvalOps;
+
+/* The allocator view the gated constructor uses (installs the ops);
+ * ownership of `cell` MOVES in (the caller retains first). */
+ScrDyn *scr_dyn_alloc_jsval(ScrJsval *cell, const ScrDynJsvalOps *ops);
+/* The installed ops (traps on a missing install — impossible unless a
+ * JSVAL node was forged without the constructor). */
+const ScrDynJsvalOps *scr_dyn_jsval_ops(void);
+/* dynTest arms that need the ENGINE's answer on a JSVAL node. Each
+ * answers false for every other kind (callers test unconditionally —
+ * the emitted narrowing tests stay branch-free). Never throw. */
+bool scr_dyn_isl_typeof_is(const ScrDyn *d, const char *name);
+bool scr_dyn_isl_is_array(const ScrDyn *d);
+bool scr_dyn_isl_is_error(const ScrDyn *d);
+/* The JSVAL honesty ladder: when d is a JSVAL node, THROWS the catchable
+ * "<what> on an island value held in 'unknown' is not supported yet"
+ * Error and returns false; every other kind returns false untouched.
+ * Callers gate un-armed operations with it — never a silent wrong
+ * answer (the retired fence-box bug). */
+bool scr_dyn_isl_fence(const ScrDyn *d, const char *what);
+/* The emitted keyed READ's JSVAL arm (sc_dyn_key_get): routes o[k] to the
+ * engine through the installed ops and wraps the result back (+1, scalars
+ * normalized) — the retired `.length -> fence` row. d MUST be a JSVAL
+ * node; NULL with the engine's exception bridged catchably. */
+ScrDyn *scr_dyn_isl_key_get(const ScrDyn *d, const ScrStr *k);
+/* The `??`/optional-chain nullish test over a DOM value: UNDEF/NULL
+ * native, JSVAL through the engine's own test (defensively — the wrap
+ * constructor scalar-normalizes engine null/undefined away), every other
+ * kind false. Never throws. */
+bool scr_dyn_is_nullish(const ScrDyn *d);
+/* scr_dyn_isl_tostr_buf (the display walkers' JSVAL arm) is declared
+ * with the ScrJsonBuf surface below. */
+
 /* ── the ambient receiver (JS `this` inside listener/callback bodies) ──
  * Node calls a handle's listeners with `this` bound to the emitting
  * handle (server.listen(0, function() { this.address().port })), and a
@@ -2991,6 +3142,24 @@ const char *scr_dyn_specific_type(const ScrDyn *v, char *buf, size_t cap);
  * error.argTypeThrow libCall). Borrows all three; always throws. */
 void scr_throw_arg_type(const ScrStr *argname, const ScrStr *expected, const ScrDyn *got);
 void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrDyn *got);
+/* The property flavor ("The \"options.x\" property must be ...") — the
+ * option-bag validators' gate (error.propTypeThrow). Always throws. */
+void scr_throw_prop_type(const ScrStr *name, const ScrStr *expected, const ScrDyn *got);
+void scr_dyn_prop_type_fail(const char *name, const char *expected, const ScrDyn *got);
+/* Node's ERR_INVALID_ARG_VALUE ("The argument 'encoding' is invalid
+ * encoding. Received 'no'") — reason NULL renders "is invalid".
+ * TypeError; always throws catchably. */
+void scr_dyn_arg_value_fail(const char *name, const char *reason, const ScrDyn *got);
+/* The ERR_INVALID_ARG_VALUE/%j "Received" renderer (inspect-lite:
+ * strings quote, scalars print plain, deep shapes sketch). */
+const char *scr_dyn_inspect_lite(const ScrDyn *v, char *buf, size_t cap);
+/* A ladder's post-validation refuse: throws the compiler-rendered SC2020
+ * statement-fence text verbatim (Node's validation errors run first). */
+void scr_throw_lowering_fence(const ScrStr *msg);
+/* ERR_OUT_OF_RANGE's "Received" number rendering (Node's
+ * addNumericalSeparator underscores past 2^32) — scr_bytes.c's renderer,
+ * shared by the fs/net/tls option-ladder validators. */
+size_t scr_num_received(double v, char out[48]);
 /* Listener-closure builders for the handle dispatchers' .on(...) paths:
  * a runtime-built ScrClosure whose capture is the boxed dyn listener and
  * whose invoke boxes the event tuple back into the DOM and calls through
@@ -3065,6 +3234,12 @@ void scr_jb_put_f64(ScrJsonBuf *b, double v);
  * as \u00XX, everything else (UTF-8 included) verbatim — exactly the JS
  * JSON.stringify escape set for well-formed strings. */
 void scr_jb_put_json_str(ScrJsonBuf *b, const ScrStr *s);
+/* String(v) of a JSVAL node appended into b (the emitted sc_ds display
+ * walkers' arm; scr_dyn_display/to_string route here too): the engine's
+ * ToString. A bridged failure (throwing user toString, a symbol) leaves
+ * the exception PENDING and appends nothing — the loud path, never a
+ * fabricated rendering. */
+void scr_dyn_isl_tostr_buf(ScrJsonBuf *b, const ScrDyn *d);
 /* JSON-serialize a DOM value into the buffer — the sc_jw_* walker for the
  * dyn leaves the compiler cannot type: object members holding undefined
  * DROP, array slots holding undefined print null (exactly Node). */
@@ -3738,11 +3913,27 @@ ScrJsval *scr_jsval_from_f64(double v);
 ScrJsval *scr_jsval_from_bool(bool v);
 ScrJsval *scr_jsval_from_str(const ScrStr *s);
 ScrJsval *scr_jsval_from_json(const ScrStr *json);
-/* A CHECKED-DYNAMIC (DOM) value entering the island — deep copy, data
- * kinds only (a boxed function/handle/promise throws the catchable
- * TypeError). NULL with a pending exception on failure. Borrows d. */
+/* A CHECKED-DYNAMIC (DOM) value entering the island — deep copy for data
+ * kinds (a boxed handle/promise throws the catchable TypeError). A JSVAL
+ * node unwraps to its OWN cell (+1) — an engine value that crossed into
+ * the DOM and back is the SAME engine value, by reference (nested JSVAL
+ * members embed their engine values directly). A boxed FUNCTION crosses
+ * as one generic host-function shim over its uniform ScrDynThunk: the
+ * shim wraps engine arguments as DOM values (scalar-normalizing), calls
+ * the thunk, and converts the DOM result back — each crossing mints a
+ * fresh engine function (identity is not preserved for re-crossings;
+ * SEMANTICS.md). NULL with a pending exception on failure. Borrows d. */
 ScrJsval *scr_jsval_from_dyn(const ScrDyn *d);
 
+/* The jsval→DOM crossing (the IR's dynFromJsval): wraps an island value
+ * as a SCR_DYN_JSVAL node, SCALAR-NORMALIZING first — engine numbers/
+ * strings/booleans/null/undefined convert to the native DOM kinds (the
+ * strict exits cannot fail on engine-reported scalars), so JSVAL nodes
+ * only ever hold engine objects/arrays/functions (and the symbol/bigint
+ * edge). Installs the DOM's engine-routing ops on first use. Borrows
+ * the cell (retains it into the node); +1 out; never throws. */
+ScrDyn *scr_dyn_from_jsval(ScrJsval *cell);
+
 /* Engine operations. Arithmetic yields a fresh cell (NULL = bridged);
  * comparisons yield 0/1 (-1 = bridged); truthy/not never fail. */
 ScrJsval *scr_jsval_binop(int op, ScrJsval *a, ScrJsval *b);
@@ -4236,6 +4427,23 @@ ScrBytes *scr_buffer_new_string_fail(const ScrDyn *got);
  * numbers coerce (negatives answer now/1000), the rest throw Node's
  * ERR_INVALID_ARG_TYPE. Borrowed. */
 double scr_fs_to_unix_timestamp(const ScrDyn *t);
+/* The fs argument-validation ladders (the fs.*Chk libCalls): Node-order
+ * validation over DOM values with Node's exact typed errors; a pass
+ * meets the real operation where one exists (mkdtempSync, macOS
+ * lchmodSync) or the compiler-rendered fence. All borrowed; the Chk
+ * forms without results always leave an exception pending. */
+ScrDyn *scr_fs_exists_async(const ScrDyn *path, const ScrDyn *cb);
+void scr_fs_mkdtemp_chk(const ScrDyn *prefix, const ScrDyn *cb, const ScrStr *fence);
+ScrStr *scr_fs_mkdtemp_sync_chk(const ScrDyn *prefix, const ScrDyn *opts, const ScrStr *fence);
+void scr_fs_read_file_chk(const ScrDyn *path, const ScrDyn *opts, const ScrDyn *cb, const ScrStr *fence);
+void scr_fs_opendir_chk(const ScrDyn *path, const ScrDyn *opts, const ScrStr *fence);
+void scr_fs_watch_file_chk(const ScrDyn *path, const ScrDyn *listener, const ScrStr *fence);
+void scr_fs_lchmod_chk(const ScrDyn *path, const ScrDyn *mode, const ScrDyn *cb, const ScrStr *fence);
+ScrDyn *scr_fs_lchmod_sync_chk(const ScrDyn *path, const ScrDyn *mode);
+ScrPromise *scr_fsp_lchmod_chk(const ScrDyn *path, const ScrDyn *mode);
+void scr_fs_read_chk(const ScrDyn *fd, const ScrDyn *buffer, const ScrDyn *offset,
+                     const ScrDyn *length, const ScrDyn *position, const ScrStr *fence);
+void scr_fs_stream_opts_chk(const ScrDyn *path, const ScrDyn *opts, const ScrStr *fence);
 /* The checked-dynamic max-listeners ladders (scr_events_emitter.c). */
 ScrEmitter *scr_emitter_set_max_chk(ScrEmitter *em, const ScrDyn *n);
 void scr_emitter_set_default_max_chk(const ScrDyn *n, const ScrStr *name);
@@ -4503,6 +4711,16 @@ void scr_net_server_on_connection(ScrNetServer *s, ScrClosure *cb /*moves*/, Scr
  * server never fires it, like Node). */
 void scr_net_server_on_secure_connection(ScrNetServer *s, ScrClosure *cb /*moves*/, ScrNetConnFn fn, bool once);
 ScrNetSocket *scr_net_connect(double port, ScrStr *host /*borrowed, nullable*/, ScrClosure *cb /*moves, nullable*/); /* +1 */
+/* connect with a validated autoSelectFamilyAttemptTimeout option: the
+ * budget runs Node's validateInt32-from-1 ladder (ERR_OUT_OF_RANGE /
+ * ERR_INVALID_ARG_TYPE) and is then inert — the single dial has nothing
+ * to time. +1, or NULL with the throw pending. */
+ScrNetSocket *scr_net_connect_attempt(double port, ScrStr *host /*borrowed*/, const ScrDyn *t /*borrowed*/);
+/* net.connect/createConnection over a RUNTIME option bag (computed
+ * keys): Node-order validation (objectMode trio, port, host,
+ * autoSelectFamily, attempt budget), then the compiler-rendered fence —
+ * always leaves an exception pending. Borrowed. */
+void scr_net_connect_opts_chk(const ScrDyn *opts, const ScrStr *fence);
 /* connect with a caller lookup (net.connect({ ..., lookup })): invokes
  * lookup(hostname, options, answer-closure) synchronously; answer_fn is
  * the emitted per-shape thunk that decodes the answer down to
@@ -4717,6 +4935,13 @@ void scr_tls_h2_client_wrap(ScrNetSocket *sock, ScrStr *host /*borrowed*/, bool
  * the default pair, exactly Node. */
 typedef struct ScrSecureCtx ScrSecureCtx;
 ScrSecureCtx *scr_tls_create_secure_context(const char *cert, size_t cert_len, const char *key, size_t key_len); /* +1 */
+/* createSecureContext over a RUNTIME options record: Node's typed option
+ * validations first, then the pem walk (+1, or NULL with the exception
+ * pending). Borrowed. */
+ScrSecureCtx *scr_tls_create_secure_context_dyn(const ScrDyn *opts);
+/* tls.getCACertificates(type): validateString + the documented name set,
+ * then the compiler-rendered fence — always leaves an exception pending. */
+void scr_tls_ca_certs_chk(const ScrDyn *type, const ScrStr *fence);
 ScrSecureCtx *scr_secure_ctx_retain(ScrSecureCtx *c);
 void scr_secure_ctx_release(ScrSecureCtx *c);
 void *scr_secure_ctx_retain_v(void *p);
@@ -5140,6 +5365,13 @@ void scr_dgram_bind(ScrDgramSocket *s, double port, ScrStr *host /*borrowed*/, S
 void scr_dgram_connect(ScrDgramSocket *s, double port, ScrStr *host /*borrowed*/, ScrClosure *cb /*moves, nullable*/);
 void scr_dgram_send_str(ScrDgramSocket *s, ScrStr *data /*borrowed*/, double port, ScrStr *host /*borrowed*/);
 void scr_dgram_send_bytes(ScrDgramSocket *s, ScrBytes *data /*borrowed*/, double port, ScrStr *host /*borrowed*/);
+/* The send argument-validation ladder over DOM arguments (Node's
+ * signature shuffle, slice bounds, list/type contracts, port/address
+ * validation, and the connected-state errors); a fully-validated
+ * unconnected single-payload send RUNS, the rest meet the fence. */
+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);
 /* address() parts: ip THROWS "Not running" before bind/connect (+1
  * otherwise); family/port are only called after ip succeeded. */
 ScrStr *scr_dgram_addr_ip(ScrDgramSocket *s);     /* +1, may throw */