@scriptc/runtime 0.0.9 → 0.0.11

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

@@ -251,6 +251,21 @@ ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len, const char *trap_ms
   return b;
 }
 
+double scr_library_i64_in(int64_t v, const char *trap_msg) {
+  /* The inbound declared-integer edge (ask 4): only |v| <= 2^53-1 rides
+   * f64 exactly; past it, (double)v silently rounds — a coercion the
+   * author never wrote, so the wrapper funnels the host-contract
+   * violation instead (same story as an impossible bytes length; the
+   * message is the compiler-assembled structured trap-teaching form). */
+  if (v > 9007199254740991LL || v < -9007199254740991LL) scr_trap(trap_msg);
+  return (double)v;
+}
+
+double scr_library_u64_in(uint64_t v, const char *trap_msg) {
+  if (v > 9007199254740991ULL) scr_trap(trap_msg);
+  return (double)v;
+}
+
 void scr_library_str_out(ScrStr *s, const uint8_t **out, size_t *out_len) {
   scr_library_arena_keep(s, true);
   *out = (const uint8_t *)s->data; /* NUL-terminated after len (ScrStr layout) */

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

@@ -484,13 +484,20 @@ ScrArr *scr_regex_match_all_into(ScrStr *s, ScrRegex *re, ScrArr *indices) {
  * replacements are frontend-fenced): $$, $&, $` and $', $1..$99 (two digits
  * win when in range — the refined ES2019 rule quickjs implements), with
  * out-of-range references left literal and unmatched groups substituting
- * empty. $<name> stays literal: named capture groups are frontend-fenced,
- * so namedCaptures is always undefined here (the spec's literal case).
- * The template is scanned byte-wise: every '$' directive is ASCII, and
- * UTF-8 continuation bytes can never alias it. */
+ * empty. $<name> resolves against the pattern's named capture groups
+ * (lre_get_groupnames — one NUL-terminated name per capture, "" for
+ * unnamed): the first PARTICIPATING capture with that name substitutes
+ * (ES2025 duplicates live in distinct alternatives, so at most one
+ * participates); a nonexistent or nonparticipating name substitutes
+ * empty (the spec's Get→undefined→"" path, Node-exact). When the pattern
+ * has NO named groups, namedCaptures is undefined and '$<' stays literal
+ * — also Node's unterminated-'$<name' answer either way. The template is
+ * scanned byte-wise: every '$' directive is ASCII, and UTF-8 continuation
+ * bytes can never alias it. */
 static void scr_put_substitution(ScrJsonBuf *b, const uint16_t *u, int len,
                                   int start, int end, uint8_t **capture,
-                                  int capture_count, const ScrStr *rep) {
+                                  int capture_count, const char *groupnames,
+                                  const ScrStr *rep) {
   const uint8_t *ubase = (const uint8_t *)u;
   size_t i = 0;
   while (i < rep->len) {
@@ -534,6 +541,31 @@ static void scr_put_substitution(ScrJsonBuf *b, const uint16_t *u, int len,
         scr_jb_putc(b, '$');
         i++;
       }
+    } else if (c1 == '<' && groupnames != NULL) {
+      /* $<name>: scan for '>'; absent, the '$' is literal (the rest
+       * re-scans verbatim — GetSubstitution's not-found answer). */
+      size_t gt = i + 2;
+      while (gt < rep->len && rep->data[gt] != '>') gt++;
+      if (gt >= rep->len) {
+        scr_jb_putc(b, '$');
+        i++;
+        continue;
+      }
+      const char *name = rep->data + i + 2;
+      size_t name_len = gt - (i + 2);
+      const char *p = groupnames; /* capture_count-1 entries: name NUL scope */
+      for (int k = 1; k < capture_count; k++) {
+        size_t glen = strlen(p);
+        if (glen == name_len && memcmp(p, name, name_len) == 0) {
+          const uint8_t *cs = capture[2 * k], *ce = capture[2 * k + 1];
+          if (cs && ce) {
+            scr_jb_put_utf16(b, u, (int)((cs - ubase) >> 1), (int)((ce - ubase) >> 1));
+            break; /* at most one duplicate participates */
+          }
+        }
+        p += glen + LRE_GROUP_NAME_TRAILER_LEN;
+      }
+      i = gt + 1;
     } else {
       scr_jb_putc(b, '$');
       i++;
@@ -550,6 +582,7 @@ static ScrStr *scr_replace_impl(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   bool global = (re_flags & LRE_FLAG_GLOBAL) != 0;
   bool unicode = (re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
   int capture_count = lre_get_capture_count(bc);
+  const char *groupnames = lre_get_groupnames(bc);
   int len;
   uint16_t *u = scr_to_utf16(s, &len);
   uint8_t **capture = scr_capture_alloc(bc);
@@ -562,7 +595,7 @@ static ScrStr *scr_replace_impl(ScrStr *s, ScrRegex *re, ScrStr *rep) {
     int start = (int)((capture[0] - ubase) >> 1);
     int end = (int)((capture[1] - ubase) >> 1);
     scr_jb_put_utf16(&b, u, next, start);
-    scr_put_substitution(&b, u, len, start, end, capture, capture_count, rep);
+    scr_put_substitution(&b, u, len, start, end, capture, capture_count, groupnames, rep);
     next = end;
     if (!global) break;
     pos = end == start ? scr_advance(u, len, end, unicode) : end;