@scriptc/runtime 0.0.8 → 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>'"
@@ -1647,7 +1667,7 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length)
     mlen = snprintf(msg, sizeof msg,
                     "The value of \"offset\" is out of range. It must be >= 0 && <= 9007199254740991. Received %s",
                     numbuf);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return 0;
   }
   size_t off = (size_t)offset;
@@ -1656,7 +1676,7 @@ double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length)
     mlen = snprintf(msg, sizeof msg,
                     "The value of \"length\" is out of range. It must be <= %zu. Received %s",
                     bytelen - off, numbuf);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return 0;
   }
   size_t want = (size_t)length;
@@ -2528,7 +2548,7 @@ ScrStr *scr_crypto_random_string(double n, ScrStr *enc) {
     int mlen = snprintf(msg, sizeof msg,
                         "The value of \"size\" is out of range. It must be >= 0 && <= 2147483647. Received %.*s",
                         (int)numlen, num);
-    scr_throw_error_msg(SCR_ERR_RANGE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)mlen, "ERR_OUT_OF_RANGE");
     return NULL;
   }
   size_t size = (size_t)n;
@@ -3486,6 +3506,104 @@ ScrStr *scr_num_to_fixed0(double x) {
   return r;
 }
 
+/* Increment a decimal digit string in place. Returns true on overflow —
+ * the value becomes 1 followed by len zeros (the caller folds the zeros
+ * into its scale); an EMPTY string increments to "1" the same way (the
+ * round-up-from-nothing case: 0.0005 at 3 fraction digits). */
+static bool scr_dec_inc(char *d, int len) {
+  for (int i = len - 1; i >= 0; i--) {
+    if (d[i] != '9') {
+      d[i]++;
+      return false;
+    }
+    d[i] = '0';
+  }
+  d[0] = '1';
+  return true;
+}
+
+/* Intl.NumberFormat("en-US").format(x) / x.toLocaleString("en-US") with
+ * DEFAULT options: decimal notation, minimum 0 / maximum 3 fraction
+ * digits, "," grouping every three integer digits, "∞"/"NaN" texts, and
+ * "-0" whenever the input is negative or negative zero even after
+ * rounding to zero. Rounding is half-up ON THE SHORTEST ROUND-TRIPPING
+ * DECIMAL — ICU's rounding input, probed against Node: format(1.0005) is
+ * "1.001" although the double is 1.000499... and toFixed(3) answers
+ * "1.000"; format(1e23) prints the shortest form's trailing zeros, not
+ * the double's exact expansion. The en-US/latn symbols (",", ".", "∞",
+ * "NaN", group size 3) are the whole embedded locale surface. Verified
+ * differentially against Node. Result +1; never throws. */
+ScrStr *scr_intl_num_format_en_us(double x) {
+  if (isnan(x)) return scr_str_new("NaN", 3);
+  if (isinf(x)) {
+    return x < 0 ? scr_str_new("-\xE2\x88\x9E", 4) : scr_str_new("\xE2\x88\x9E", 3);
+  }
+  bool neg = signbit(x) != 0;
+  if (x == 0) return neg ? scr_str_new("-0", 2) : scr_str_new("0", 1);
+  double a = neg ? -x : x;
+
+  /* Shortest digits: value = 0.d × 10^n (no trailing zeros, k ≤ 17). */
+  char d[18];
+  int n;
+  int k = scr_f64_digits(a, d, &n);
+
+  /* Round at 3 fraction digits: fraction position p is digit index
+   * n+p-1, so index n+3 is the first DROPPED digit. Half-up on the
+   * decimal digits — the shortest string ends right after them, so
+   * "first dropped digit ≥ 5" IS the whole decision. */
+  int keep = n + 3;
+  if (keep < k) {
+    bool up = keep >= 0 && d[keep] >= '5';
+    k = keep < 0 ? 0 : keep;
+    if (up && scr_dec_inc(d, k)) {
+      /* Carried out (all nines, or the round-up-from-nothing 0.0005
+       * case): one leading 1, the dropped nines fold into the scale. */
+      k = 1;
+      n += 1;
+    } else if (k == 0) {
+      /* Everything rounded away: ±0 with the sign preserved. */
+      return neg ? scr_str_new("-0", 2) : scr_str_new("0", 1);
+    }
+  }
+
+  /* Assemble: integer digits (indices [0, n)), zero-padded past k, then
+   * the ≤ 3 fraction digits (indices n..n+2, '0' outside [0, k)) with
+   * trailing zeros trimmed, then commas every three integer digits. */
+  char frac[3];
+  int flen = 0;
+  for (int p = 1; p <= 3; p++) {
+    int idx = n + p - 1;
+    frac[flen++] = (idx >= 0 && idx < k) ? d[idx] : '0';
+  }
+  while (flen > 0 && frac[flen - 1] == '0') flen--;
+
+  char out[512];
+  int o = 0;
+  if (neg) out[o++] = '-';
+  if (n <= 0) {
+    out[o++] = '0';
+  } else {
+    for (int i = 0; i < n; i++) {
+      if (i > 0 && (n - i) % 3 == 0) out[o++] = ',';
+      out[o++] = (i < k) ? d[i] : '0';
+    }
+  }
+  if (flen > 0) {
+    out[o++] = '.';
+    memcpy(out + o, frac, (size_t)flen);
+    o += flen;
+  }
+  return scr_str_new(out, (size_t)o);
+}
+
+/* Object.is over two numbers — the spec's SameValue on doubles: NaN
+ * equals NaN, +0 differs from -0, everything else is ==. */
+bool scr_num_same_value(double a, double b) {
+  if (a != a) return b != b;
+  if (a == 0 && b == 0) return signbit(a) == signbit(b);
+  return a == b;
+}
+
 bool scr_num_is_nan(double x) { return isnan(x) != 0; }
 
 bool scr_num_is_integer(double x) { return isfinite(x) && trunc(x) == x; }

package/src/scr_library.c

@@ -40,7 +40,19 @@ void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
  * conforming survival pattern), then deliver exactly once, then abort:
  * before registration, or if the sink returns (the ruled host-contract
  * violation). The address is the funnel frame's return address — the trap
- * site — 0 where the toolchain cannot supply one. */
+ * site — 0 where the toolchain cannot supply one.
+ *
+ * Delivery shape (the ratified structured trap-teaching encoding): a
+ * message that already begins with the 0x01 marker — a facade-authored
+ * structured throw riding the verbatim rule, or the wrapper's compile-
+ * time-assembled SC4012 contract trap — is delivered byte-for-byte. Every
+ * OTHER message is a trap the runtime DETECTED, and the funnel assembles
+ * it here into 0x01 text 0x1F code 0x1F symbol [0x1F remediation]: the
+ * baseline human line becomes field 0 unchanged (so plain-text hosts read
+ * exactly what they always read), the code classifies the trap kind, the
+ * symbol is the entry the trapping call came through (recorded by the
+ * entry prologue below), and the remediation is the profile's for that
+ * code when the program TU's overlay table declares one. */
 
 #if defined(__GNUC__) || defined(__clang__)
 #define SCR_TRAP_ADDR() ((uint64_t)(uintptr_t)__builtin_return_address(0))
@@ -48,8 +60,95 @@ void scr_library_set_sink(ScrLibSinkFn fn, void *ctx) {
 #define SCR_TRAP_ADDR() ((uint64_t)0)
 #endif
 
+/* The current-entry slot: every generated entry's prologue records its
+ * external symbol before dispatching into core code. A single static slot
+ * is sound — exactly one core is live per process (the one-live-core rule),
+ * entries never nest, and a trap can only fire while an entry is on the
+ * stack. NULL (never entered) renders as the empty symbol field. */
+static const char *scr_library_entry_symbol = NULL;
+
+/* Detected-trap classification: the runtime's trap sites self-classify
+ * through their message conventions (the exact bytes the executable lane
+ * prints), so the kind → code mapping keys on those prefixes. The codes are
+ * the compiler registry's runtime family (diagnostics/diagnostic.ts —
+ * documented beside SC4012); SC4019 is the family's residual for detected
+ * traps outside the named kinds (environment failures, unsupported
+ * operations, the RC audit). */
+static const struct {
+  const char *prefix;
+  const char *code;
+} scr_library_trap_kinds[] = {
+  {"Uncaught ", "SC4013"},                  /* escaped exception at an entry */
+  {"scriptc: RangeError: ", "SC4014"},      /* range trap */
+  {"scriptc: TypeError: ", "SC4015"},       /* type trap */
+  {"scriptc: SyntaxError: ", "SC4016"},     /* syntax trap (regex compile) */
+  {"scriptc: out of memory", "SC4017"},     /* allocation failure */
+  {"scriptc: internal error: ", "SC4018"},  /* internal invariant failure */
+};
+
+static const char *scr_library_trap_code(const char *msg, size_t len) {
+  for (size_t i = 0; i < sizeof scr_library_trap_kinds / sizeof scr_library_trap_kinds[0]; i++) {
+    size_t plen = strlen(scr_library_trap_kinds[i].prefix);
+    if (len >= plen && memcmp(msg, scr_library_trap_kinds[i].prefix, plen) == 0) {
+      return scr_library_trap_kinds[i].code;
+    }
+  }
+  return "SC4019"; /* other detected trap */
+}
+
 static _Noreturn void scr_library_trap_deliver(const char *msg, size_t len, uint64_t addr) {
   scr_library_poisoned = true;
+  if (!(len > 0 && (uint8_t)msg[0] == 0x01)) {
+    /* A detected trap: assemble the structured message. Static buffer —
+     * no malloc on the failure path; text truncates before structure ever
+     * would (codes and symbols are short; an oversized remediation drops
+     * whole, never split). */
+    static char buf[2048];
+    const char *code = scr_library_trap_code(msg, len);
+    const char *text = msg;
+    size_t text_len = len;
+    const char *rem = NULL;
+    for (size_t i = 0; i < scr_library_trap_overlays_len; i++) {
+      const char *const *t = &scr_library_trap_overlays[3 * i];
+      if (strcmp(t[0], code) == 0) {
+        if (t[1] != NULL) {
+          text = t[1];
+          text_len = strlen(t[1]);
+        }
+        rem = t[2];
+        break;
+      }
+    }
+    const char *sym = scr_library_entry_symbol != NULL ? scr_library_entry_symbol : "";
+    size_t tail = 2 + strlen(code) + strlen(sym);
+    if (rem != NULL) {
+      if (tail + 1 + strlen(rem) > sizeof buf - 1) rem = NULL; /* drop whole, keep structure */
+      else tail += 1 + strlen(rem);
+    }
+    size_t n = 0;
+    buf[n++] = '\x01';
+    size_t cap = sizeof buf - 1 - tail;
+    if (text_len > cap) text_len = cap;
+    for (size_t i = 0; i < text_len; i++) {
+      /* The encoding reserves 0x01/0x1F; runtime messages never contain
+       * them, but an escaped exception's rendered text embeds user bytes. */
+      char c = text[i];
+      buf[n++] = (c == '\x01' || c == '\x1f') ? ' ' : c;
+    }
+    buf[n++] = '\x1f';
+    memcpy(buf + n, code, strlen(code));
+    n += strlen(code);
+    buf[n++] = '\x1f';
+    memcpy(buf + n, sym, strlen(sym));
+    n += strlen(sym);
+    if (rem != NULL) {
+      buf[n++] = '\x1f';
+      memcpy(buf + n, rem, strlen(rem));
+      n += strlen(rem);
+    }
+    msg = buf;
+    len = n;
+  }
   if (scr_library_sink != NULL) {
     scr_library_sink(scr_library_sink_ctx, (const uint8_t *)msg, len, addr);
   }
@@ -80,7 +179,11 @@ __attribute__((noinline)) _Noreturn void scr_trap_fmt(const char *fmt, ...) {
 
 /* ── entry prologues ──────────────────────────────────────────────────── */
 
-void scr_library_entry(bool reset_arena) {
+void scr_library_entry(bool reset_arena, const char *entry_symbol) {
+  /* Record the entry symbol FIRST so even a poisoned-abort's core dump
+   * names the entry; a trap anywhere below (the arena reset's OOM
+   * included) then reports the right symbol. */
+  scr_library_entry_symbol = entry_symbol;
   /* A poisoned library's entries abort deterministically — never through the
    * sink again (it received its exactly-once message when the trap fired),
    * never into a heap whose invariants already failed. */

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

@@ -24,27 +24,19 @@
  * unchanged. Provides d2d(), d2d_small_int(), decimalLength17(), div10(). */
 #include "../vendor/ryu/d2s.c"
 
-size_t scr_f64_to_str(double x, char *buf) {
-  if (isnan(x)) return (size_t)(stpcpy(buf, "NaN") - buf);
-  if (x == 0) return (size_t)(stpcpy(buf, "0") - buf); /* covers -0 */
-  if (isinf(x)) {
-    return (size_t)(stpcpy(buf, x < 0 ? "-Infinity" : "Infinity") - buf);
-  }
-
-  char *out = buf;
-  if (x < 0) {
-    *out++ = '-';
-    x = -x;
-  }
-
-  /* Shortest round-tripping digits via Ryū. Mirrors d2s_buffered_n's
-   * dispatch: the exact small-integer fast path first (trailing decimal
-   * zeros folded into the exponent), the full algorithm otherwise. */
+/* The Ryū digit core, shared by the ECMA placement below and the Intl
+ * en-US number formatter (scr_lib.c): the shortest round-tripping digit
+ * string for a positive finite double — value = 0.digits × 10^n with no
+ * trailing zeros. Returns k (the digit count, ≤ 17); digits is
+ * NUL-terminated. Mirrors d2s_buffered_n's dispatch: the exact
+ * small-integer fast path first (trailing decimal zeros folded into the
+ * exponent), the full algorithm otherwise. */
+int scr_f64_digits(double x, char digits[18], int *n_out) {
   uint64_t bits;
   memcpy(&bits, &x, sizeof bits);
   const uint64_t ieeeMantissa = bits & ((1ull << DOUBLE_MANTISSA_BITS) - 1);
   const uint32_t ieeeExponent =
-      (uint32_t)(bits >> DOUBLE_MANTISSA_BITS); /* sign already stripped */
+      (uint32_t)(bits >> DOUBLE_MANTISSA_BITS); /* sign must be stripped */
   floating_decimal_64 v;
   if (d2d_small_int(ieeeMantissa, ieeeExponent, &v)) {
     for (;;) {
@@ -60,9 +52,8 @@ size_t scr_f64_to_str(double x, char *buf) {
 
   /* Ryū's (mantissa, exponent) → ECMA's (digits, k, n): the k mantissa
    * digits have no trailing zeros, and value = 0.digits * 10^n. */
-  char digits[18];
   int k = (int)decimalLength17(v.mantissa);
-  int n = v.exponent + k;
+  *n_out = v.exponent + k;
   digits[k] = '\0';
   uint64_t m = v.mantissa;
   for (int i = k - 1; i >= 0; i--) {
@@ -70,6 +61,25 @@ size_t scr_f64_to_str(double x, char *buf) {
     digits[i] = (char)('0' + (uint32_t)m - 10 * (uint32_t)q);
     m = q;
   }
+  return k;
+}
+
+size_t scr_f64_to_str(double x, char *buf) {
+  if (isnan(x)) return (size_t)(stpcpy(buf, "NaN") - buf);
+  if (x == 0) return (size_t)(stpcpy(buf, "0") - buf); /* covers -0 */
+  if (isinf(x)) {
+    return (size_t)(stpcpy(buf, x < 0 ? "-Infinity" : "Infinity") - buf);
+  }
+
+  char *out = buf;
+  if (x < 0) {
+    *out++ = '-';
+    x = -x;
+  }
+
+  char digits[18];
+  int n;
+  int k = scr_f64_digits(x, digits, &n);
 
   if (k <= n && n <= 21) {
     /* Integer: digits followed by n-k zeros. */