@scriptc/runtime 0.0.9 → 0.0.11

package/src/scr_bytes_io.c

@@ -12,6 +12,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#ifdef __APPLE__
+#include <sys/stat.h> /* lchmod(2) — the fs.lchmodSync ladder's real tail */
+#endif
 
 static void scr_bytes_io_oom(void) {
   scr_trap("scriptc: out of memory\n");
@@ -254,3 +257,410 @@ double scr_fs_to_unix_timestamp(const ScrDyn *t) {
   scr_dyn_arg_type_fail("time", "an instance of Date or an Time in seconds", t);
   return 0;
 }
+
+/* ── the fs argument-validation ladders (checked-dynamic lane) ─────────
+ * Each fs.*Chk libCall replicates its API's Node-order validation over
+ * DOM values and throws Node's exact typed errors; when every validation
+ * passes, the honest tail runs — the real operation where one exists
+ * (mkdtempSync, lchmodSync on macOS), the compiler-rendered SC2020 fence
+ * otherwise (scr_throw_lowering_fence). All arguments borrowed. */
+
+static bool scr_fs_dyn_absent(const ScrDyn *v) {
+  return v->kind == SCR_DYN_UNDEF || v->kind == SCR_DYN_NULL;
+}
+
+static bool scr_fs_str_is(const ScrStr *s, const char *lit) {
+  size_t n = strlen(lit);
+  return s->len == n && memcmp(s->data, lit, n) == 0;
+}
+
+/* Node's maybeCallback/validateFunction over a callback slot. */
+static bool scr_fs_cb_chk(const ScrDyn *cb, const char *name) {
+  if (cb->kind == SCR_DYN_FUNC) return true;
+  scr_dyn_arg_type_fail(name, "of type function", cb);
+  return false;
+}
+
+/* getValidatedPath: strings and Buffers pass (URL instances never reach
+ * these ladders — the DOM has no URL kind here, and Node would accept
+ * only file: URLs anyway). */
+static bool scr_fs_path_chk(const ScrDyn *p, const char *name) {
+  if (p->kind == SCR_DYN_STR || p->kind == SCR_DYN_BYTES) return true;
+  scr_dyn_arg_type_fail(name, "of type string or an instance of Buffer or URL", p);
+  return false;
+}
+
+/* assertEncoding over an options slot (a bare encoding string or an
+ * options record's `encoding` member): Node throws ERR_INVALID_ARG_VALUE
+ * for any truthy value Buffer.isEncoding rejects. */
+static bool scr_fs_encoding_chk(const ScrDyn *opts) {
+  const ScrDyn *enc = opts;
+  if (opts->kind == SCR_DYN_OBJ) {
+    enc = scr_dyn_obj_get(opts, "encoding", 8);
+    if (enc == NULL) return true;
+  }
+  if (scr_fs_dyn_absent(enc)) return true;
+  if (enc->kind == SCR_DYN_STR) {
+    if (enc->v.str->len == 0) return true; /* falsy: assertEncoding's `encoding &&` gate */
+    if (scr_bytes_is_encoding(enc->v.str)) return true;
+  }
+  if (enc->kind == SCR_DYN_BOOL && !enc->v.b) return true;
+  if (enc->kind == SCR_DYN_NUM && enc->v.num == 0) return true;
+  scr_dyn_arg_value_fail("encoding", "is invalid encoding", enc);
+  return false;
+}
+
+/* parseFileMode: integers 0..2^32-1 pass, octal strings parse, and the
+ * rest throw Node's exact ladder (validateUint32's wording). */
+static bool scr_fs_mode_chk(const ScrDyn *m, const char *name) {
+  if (m->kind == SCR_DYN_STR) {
+    const ScrStr *s = m->v.str;
+    bool octal = s->len > 0;
+    for (size_t i = 0; octal && i < s->len; i++) {
+      if (s->data[i] < '0' || s->data[i] > '7') octal = false;
+    }
+    if (octal) return true;
+    scr_dyn_arg_value_fail(name, "must be a 32-bit unsigned integer or an octal string", m);
+    return false;
+  }
+  if (m->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail(name, "of type number", m);
+    return false;
+  }
+  double v = m->v.num;
+  if (!(isfinite(v) && trunc(v) == v)) {
+    char recv[48], msg[160];
+    scr_num_received(v, 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 (v < 0 || v > 4294967295.0) {
+    char recv[48], msg[160];
+    scr_num_received(v, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be >= 0 && <= 4294967295. Received %s",
+                       name, recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  return true;
+}
+
+/* fs.exists(path, cb) — the REAL deprecated-API shape: the callback
+ * validates synchronously (Node's one throwing arm), and the answer
+ * arrives asynchronously through it — string/Buffer paths run the
+ * existsSync probe at fire time, every other path kind answers `false`
+ * (Node swallows getValidatedPath failures there). The loop-held timer
+ * matches Node's I/O-completion timing closely enough for the
+ * sequential CLI corpus. */
+#ifndef SCR_LIB
+static void scr_fs_exists_fire(ScrClosure *self) {
+  ScrDyn *path = scr_box_get_ref(self->caps[0]); /* +1 */
+  ScrDyn *cb = scr_box_get_ref(self->caps[1]);   /* +1 */
+  bool ans = false;
+  if (path->kind == SCR_DYN_STR) {
+    ScrStr *p = scr_str_retain(path->v.str);
+    ans = scr_fs_exists(p);
+    scr_str_release(p);
+  } else if (path->kind == SCR_DYN_BYTES) {
+    ScrStr *p = scr_str_new((const char *)path->v.bytes->data, path->v.bytes->len);
+    ans = scr_fs_exists(p);
+    scr_str_release(p);
+  }
+  ScrDyn *arg = scr_dyn_new_bool(ans);
+  ScrDyn *r = scr_dyn_call(cb, &arg, 1, "the fs.exists callback");
+  scr_dyn_release(arg);
+  scr_dyn_release(r);
+  scr_dyn_release(path);
+  scr_dyn_release(cb);
+}
+#endif
+
+ScrDyn *scr_fs_exists_async(const ScrDyn *path, const ScrDyn *cb) {
+  if (!scr_fs_cb_chk(cb, "cb")) return NULL;
+  if (path->kind != SCR_DYN_STR && path->kind != SCR_DYN_BYTES) {
+    /* Node's wart, kept exactly: a path getValidatedPath rejects answers
+     * false through the callback SYNCHRONOUSLY (`return callback(false)`
+     * in lib/fs.js exists). */
+    ScrDyn *arg = scr_dyn_new_bool(false);
+    ScrDyn *r = scr_dyn_call(cb, &arg, 1, "the fs.exists callback");
+    scr_dyn_release(arg);
+    scr_dyn_release(r);
+    if (scr_exc_pending()) return NULL;
+    return scr_dyn_retain(scr_dyn_undefined());
+  }
+#ifdef SCR_LIB
+  /* Library links exclude the event-loop unit, and the compile-time scan
+   * refuses the fs.exists surface (SC4005's family) — this arm exists
+   * only so the TU links without scr_async. Unreachable by construction. */
+  scr_trap("scriptc: internal error: fs.exists async fire reached in a library build — please report this");
+  return NULL;
+#else
+  ScrClosure *clo = scr_closure_new((void *)scr_fs_exists_fire, 2);
+  clo->caps[0] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, NULL);
+  scr_box_set_ref(clo->caps[0], scr_dyn_retain((ScrDyn *)path));
+  clo->caps[1] = scr_box_new_obj(scr_dyn_retain_v, scr_dyn_release_v, NULL);
+  scr_box_set_ref(clo->caps[1], scr_dyn_retain((ScrDyn *)cb));
+  scr_set_timeout(clo, 0);
+  return scr_dyn_retain(scr_dyn_undefined());
+#endif
+}
+
+/* fs.mkdtemp(prefix, options?, cb): callback first (makeCallback), then
+ * the prefix (getValidatedPath's 'prefix' slot); the async op fences. */
+void scr_fs_mkdtemp_chk(const ScrDyn *prefix, const ScrDyn *cb, const ScrStr *fence) {
+  if (!scr_fs_cb_chk(cb, "cb")) return;
+  if (!scr_fs_path_chk(prefix, "prefix")) return;
+  scr_throw_lowering_fence(fence);
+}
+
+/* fs.mkdtempSync(prefix, options?): prefix validates (Node's 'prefix'
+ * slot), the options walk accepts only shapes that leave utf8 semantics
+ * (absent/empty records, utf8 spellings — invalid encodings throw the
+ * assertEncoding ladder, other effectful options fence), then the REAL
+ * mkdtemp runs. +1 result or NULL with the exception pending. */
+ScrStr *scr_fs_mkdtemp_sync_chk(const ScrDyn *prefix, const ScrDyn *opts, const ScrStr *fence) {
+  if (!scr_fs_path_chk(prefix, "prefix")) return NULL;
+  if (!scr_fs_encoding_chk(opts)) return NULL;
+  bool utf8 = true;
+  if (opts->kind == SCR_DYN_OBJ) {
+    for (size_t i = 0; i < opts->v.obj.len; i++) {
+      const ScrDynEntry *e = &opts->v.obj.entries[i];
+      if (scr_fs_dyn_absent(e->value)) continue;
+      if (strcmp(e->key, "encoding") == 0) {
+        const ScrDyn *enc = e->value;
+        if (!(enc->kind == SCR_DYN_STR &&
+              (scr_fs_str_is(enc->v.str, "utf8") || scr_fs_str_is(enc->v.str, "utf-8")))) {
+          utf8 = false;
+        }
+        continue;
+      }
+      utf8 = false; /* an unmodeled effectful option */
+    }
+  } else if (opts->kind == SCR_DYN_STR) {
+    utf8 = scr_fs_str_is(opts->v.str, "utf8") || scr_fs_str_is(opts->v.str, "utf-8");
+  } else if (!scr_fs_dyn_absent(opts)) {
+    utf8 = false;
+  }
+  if (!utf8 || prefix->kind != SCR_DYN_STR) {
+    scr_throw_lowering_fence(fence);
+    return NULL;
+  }
+  ScrStr *p = scr_str_retain(prefix->v.str);
+  ScrStr *r = scr_fs_mkdtemp(p);
+  scr_str_release(p);
+  return r;
+}
+
+/* fs.readFile(path, options?, cb): Node's order — the callback
+ * (maybeCallback), the options walk's assertEncoding, then the path;
+ * the async read itself fences. */
+void scr_fs_read_file_chk(const ScrDyn *path, const ScrDyn *opts, const ScrDyn *cb,
+                          const ScrStr *fence) {
+  if (!scr_fs_cb_chk(cb, "cb")) return;
+  if (!scr_fs_encoding_chk(opts)) return;
+  if (!scr_fs_path_chk(path, "path")) return;
+  scr_throw_lowering_fence(fence);
+}
+
+/* fs.opendirSync(path, options?): getValidatedPath, then getOptions'
+ * assertEncoding; the Dir machinery fences. */
+void scr_fs_opendir_chk(const ScrDyn *path, const ScrDyn *opts, const ScrStr *fence) {
+  if (!scr_fs_path_chk(path, "path")) return;
+  if (!scr_fs_encoding_chk(opts)) return;
+  scr_throw_lowering_fence(fence);
+}
+
+/* fs.watchFile(path, options?, listener): the path first, the listener's
+ * function check second (Node's watchFile order); real watching fences. */
+void scr_fs_watch_file_chk(const ScrDyn *path, const ScrDyn *listener, const ScrStr *fence) {
+  if (!scr_fs_path_chk(path, "path")) return;
+  if (listener->kind != SCR_DYN_FUNC) {
+    scr_dyn_arg_type_fail("listener", "of type function", listener);
+    return;
+  }
+  scr_throw_lowering_fence(fence);
+}
+
+/* fs.lchmod / lchmodSync / fs.promises.lchmod — macOS-only in Node (the
+ * callback/sync pair is not even exported elsewhere, so non-APPLE builds
+ * answer the not-a-function TypeError; the promise form rejects
+ * ERR_METHOD_NOT_IMPLEMENTED, Node's own linux shape). On macOS the
+ * validation ladder runs in Node's order and the real lchmod(2) applies
+ * where an operation survives it. */
+static bool scr_fs_lchmod_defined(const char *api) {
+#ifdef __APPLE__
+  (void)api;
+  return true;
+#else
+  char msg[64];
+  int len = snprintf(msg, sizeof msg, "%s is not a function", api);
+  scr_throw_error_msg(SCR_ERR_TYPE, msg, (size_t)len);
+  return false;
+#endif
+}
+
+void scr_fs_lchmod_chk(const ScrDyn *path, const ScrDyn *mode, const ScrDyn *cb,
+                       const ScrStr *fence) {
+  if (!scr_fs_lchmod_defined("fs.lchmod")) return;
+  if (!scr_fs_cb_chk(cb, "cb")) return;
+  if (!scr_fs_path_chk(path, "path")) return;
+  if (!scr_fs_mode_chk(mode, "mode")) return;
+  scr_throw_lowering_fence(fence); /* the async op + callback dispatch */
+}
+
+#ifdef __APPLE__
+static void scr_fs_lchmod_apply(const ScrDyn *path, const ScrDyn *mode) {
+  ScrStr *p = path->kind == SCR_DYN_STR ? scr_str_retain(path->v.str)
+                                        : scr_str_new((const char *)path->v.bytes->data, path->v.bytes->len);
+  double m = mode->kind == SCR_DYN_NUM ? mode->v.num : (double)strtol(mode->v.str->data, NULL, 8);
+  if (lchmod(p->data, (mode_t)m) != 0) scr_fs_throw(errno, "lchmod", p);
+  scr_str_release(p);
+}
+#endif
+
+/* Answers the DOM undefined (+1) on success — lchmodSync's JS value, so
+ * return-position uses lower; NULL with the exception pending. */
+ScrDyn *scr_fs_lchmod_sync_chk(const ScrDyn *path, const ScrDyn *mode) {
+  if (!scr_fs_lchmod_defined("fs.lchmodSync")) return NULL;
+  if (!scr_fs_path_chk(path, "path")) return NULL;
+  if (!scr_fs_mode_chk(mode, "mode")) return NULL;
+#ifdef __APPLE__
+  scr_fs_lchmod_apply(path, mode);
+  if (scr_exc_pending()) return NULL;
+#endif
+  return scr_dyn_retain(scr_dyn_undefined());
+}
+
+ScrPromise *scr_fsp_lchmod_chk(const ScrDyn *path, const ScrDyn *mode) {
+#ifndef __APPLE__
+  (void)path;
+  (void)mode;
+  static const char ni[] = "The lchmod() method is not implemented";
+  scr_throw_error_msg_code(SCR_ERR_ERROR, ni, sizeof ni - 1, "ERR_METHOD_NOT_IMPLEMENTED");
+  return scr_promise_settled_void();
+#else
+  if (scr_fs_path_chk(path, "path") && scr_fs_mode_chk(mode, "mode")) {
+    scr_fs_lchmod_apply(path, mode);
+  }
+  return scr_promise_settled_void();
+#endif
+}
+
+/* fs.read(fd, buffer, offset, length, position, cb) — the full argument
+ * ladder in Node's order (buffer, fd, offset, length, position); the
+ * async read fences. Bounds follow lib/fs.js read(): offset within the
+ * buffer, length within buffer - offset. */
+static bool scr_fs_int_range_chk(const ScrDyn *v, const char *name, double min, double max,
+                                 const char *range) {
+  if (v->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail(name, "of type number", v);
+    return false;
+  }
+  double n = v->v.num;
+  char recv[48], msg[192];
+  if (!(isfinite(n) && trunc(n) == n)) {
+    scr_num_received(n, 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 (n < min || n > max) {
+    scr_num_received(n, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be %s. Received %s",
+                       name, range, recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  return true;
+}
+
+void scr_fs_read_chk(const ScrDyn *fd, const ScrDyn *buffer, const ScrDyn *offset,
+                     const ScrDyn *length, const ScrDyn *position, const ScrStr *fence) {
+  if (buffer->kind != SCR_DYN_BYTES) {
+    scr_dyn_arg_type_fail("buffer", "an instance of Buffer, TypedArray, or DataView", buffer);
+    return;
+  }
+  if (fd->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail("fd", "of type number", fd);
+    return;
+  }
+  double buflen = (double)buffer->v.bytes->len;
+  if (!scr_fs_dyn_absent(offset)) {
+    /* validateInteger's MAX_SAFE range first, the buffer bound second —
+     * Node renders each with its own max. */
+    if (!scr_fs_int_range_chk(offset, "offset", 0, 9007199254740991.0,
+                              ">= 0 && <= 9007199254740991")) {
+      return;
+    }
+    if (offset->v.num > buflen) {
+      char range[64];
+      snprintf(range, sizeof range, ">= 0 && <= %.0f", buflen);
+      if (!scr_fs_int_range_chk(offset, "offset", 0, buflen, range)) return;
+    }
+  }
+  double off = offset->kind == SCR_DYN_NUM ? offset->v.num : 0;
+  if (!scr_fs_dyn_absent(length)) {
+    if (length->kind != SCR_DYN_NUM || !(isfinite(length->v.num) && trunc(length->v.num) == length->v.num) ||
+        length->v.num < 0) {
+      /* Node renders the bare ">= 0" form here (checkPosition's cousin). */
+      if (length->kind == SCR_DYN_NUM) {
+        char recv[48], msg[160];
+        scr_num_received(length->v.num, recv);
+        const char *shape = (isfinite(length->v.num) && trunc(length->v.num) == length->v.num)
+                                ? "It must be >= 0."
+                                : "It must be an integer.";
+        int len = snprintf(msg, sizeof msg,
+                           "The value of \"length\" is out of range. %s Received %s", shape, recv);
+        scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+        return;
+      }
+      scr_dyn_arg_type_fail("length", "of type number", length);
+      return;
+    }
+    if (length->v.num > buflen - off) {
+      char recv[48], msg[160];
+      scr_num_received(length->v.num, recv);
+      int len = snprintf(msg, sizeof msg,
+                         "The value of \"length\" is out of range. It must be <= %.0f. Received %s",
+                         buflen - off, recv);
+      scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+      return;
+    }
+  }
+  if (!scr_fs_dyn_absent(position)) {
+    if (position->kind != SCR_DYN_NUM) {
+      scr_dyn_arg_type_fail("position", "of type bigint or integer", position);
+      return;
+    }
+    if (!scr_fs_int_range_chk(position, "position", -1, 9007199254740991.0,
+                              ">= -1 && <= 9007199254740991")) {
+      return;
+    }
+  }
+  scr_throw_lowering_fence(fence);
+}
+
+/* createReadStream/createWriteStream(path, options?): getOptions'
+ * assertEncoding, the fd member's FileHandle-or-integer contract when
+ * present, the path contract otherwise; the stream machinery fences. */
+void scr_fs_stream_opts_chk(const ScrDyn *path, const ScrDyn *opts, const ScrStr *fence) {
+  if (!scr_fs_encoding_chk(opts)) return;
+  const ScrDyn *fd = opts->kind == SCR_DYN_OBJ ? scr_dyn_obj_get(opts, "fd", 2) : NULL;
+  if (fd != NULL && !scr_fs_dyn_absent(fd)) {
+    if (fd->kind != SCR_DYN_NUM) {
+      scr_dyn_prop_type_fail("options.fd", "of type number or an instance of FileHandle", fd);
+      return;
+    }
+    if (!scr_fs_int_range_chk(fd, "fd", 0, 2147483647.0, ">= 0 && <= 2147483647")) return;
+  } else if (!scr_fs_path_chk(path, "path")) {
+    return;
+  }
+  scr_throw_lowering_fence(fence);
+}

package/src/scr_dc.c

@@ -132,6 +132,12 @@ static void dc_throw_bad_fn_arg(const ScrDyn *cb, const char *arg_name) {
              (int)(cb->v.str->len < 28 ? cb->v.str->len : 28), cb->v.str->data);
     received = detail;
     break;
+  case SCR_DYN_JSVAL:
+    /* An engine callback may well BE a function — subscribing island
+     * values is unarmed (lane dyn-routing-ops); fence loudly rather
+     * than claim "Received an instance of Object". */
+    scr_dyn_isl_fence(cb, "subscribing");
+    return;
   default: break;
   }
   char buf[160];

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);
+}