@scriptc/runtime 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "scriptc native runtime — C sources, compiled into every scriptc binary",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/src/scr_island.c

@@ -2945,7 +2945,7 @@ static const char isl_modules_bootstrap[] =
     /* The reason carries the __scr_wasm_stub marker (non-enumerable):
      * the rejection tracker below SKIPS ledgering it, so a top-level
      * `WebAssembly.compile(...)` chain the program never awaits (es-
-     * module-lexer's `export const init`, alive in the vercel CLI's
+     * module-lexer's `export const init`, alive in real CLI
      * graph) stays silent at teardown — under real wasm the compile
      * SUCCEEDS unobserved, so silence is Node's observable — while an
      * actual await site still sees the rejection untouched. The marker
@@ -7489,7 +7489,7 @@ static const char isl_modules_bootstrap[] =
     "    return ah;\n"
     "  });\n"
     /* node:domain — the deprecated legacy module, shimmed because
-     * @sentry/node (inside the vercel CLI's graph) REQUIRES it at load
+     * @sentry/node (inside a real CLI's graph) REQUIRES it at load
      * on every path (async/domain.js's top level) while only DRIVING it
      * on Node < 14, which never happens here. The shim keeps the module
      * loadable with the real synchronous surface: create()/Domain,
@@ -7560,7 +7560,7 @@ static const char isl_modules_bootstrap[] =
     "    return d;\n"
     "  });\n"
     /* node:worker_threads — the MAIN-THREAD surface, loadable because
-     * undici (proxy-agent's dispatcher, in the vercel CLI's graph when
+     * undici (proxy-agent's dispatcher, in a real CLI's graph when
      * proxy env vars exist) requires it UNGUARDED at load: fetch/
      * constants.js destructures MessageChannel/receiveMessageOnPort for
      * its structuredClone fallback, websocket/events.js MessagePort.
@@ -7680,7 +7680,7 @@ static const char isl_modules_bootstrap[] =
     "    return v8;\n"
     "  });\n"
     /* node:dns — LOADABLE with Node's surface shape, answers fenced at
-     * the call. proxy-agent's pac-resolver (in the vercel CLI's graph
+     * the call. proxy-agent's pac-resolver (in a real CLI's graph
      * whenever proxy env vars exist) requires dns at LOAD and only calls
      * lookup when a PAC proxy actually resolves — so the module must
      * import cleanly, and the callback-taking members deliver their
@@ -8625,7 +8625,7 @@ static const char isl_modules_bootstrap[] =
     "      exitCode: undefined,\n"
     "      stdout: stream(1),\n"
     "      stderr: stream(2),\n"
-    /* stdin: a REAL Readable over a whole-input host read (prettier's
+    /* stdin: a REAL Readable over a whole-input host read (the formatter idiom's
      * get-stdin async-iterates it when no file arguments arrive). The
      * host read happens lazily on the first pull — a program that only
      * probes isTTY or registers listeners never blocks on a silent pipe,
@@ -9232,7 +9232,7 @@ static const char isl_url_src[] =
     "      }\n"
     "      const c = parse(s);\n"
     /* href and search are LIVE-COUPLED (the one WHATWG mutation loop the
-     * vercel CLI's API client drives: url.searchParams.set('teamId', …)
+     * a real CLI's API client drives: url.searchParams.set('teamId', …)
      * then fetch(url)): both live in writable slots, the search setter
      * recomposes href around the old query, and the searchParams getter
      * hands out ONE URLSearchParams whose mutators write back through

package/src/scr_lib.c

@@ -1093,6 +1093,16 @@ double scr_process_uptime(void) {
   return (scr_uptime_now_ms() - scr_uptime_t0_ms) / 1000.0;
 }
 
+/* perf_hooks performance.now(): milliseconds since the process's own
+ * start (Node's timeOrigin anchor), fractional — the same monotonic
+ * clock and anchor as uptime, in Node's performance.now units. */
+double scr_perf_now(void) {
+#ifdef _WIN32
+  if (scr_uptime_t0_ms == 0) scr_uptime_anchor_init();
+#endif
+  return scr_uptime_now_ms() - scr_uptime_t0_ms;
+}
+
 #ifdef _WIN32
 /* GetProcessTimes/GetThreadTimes answer 100ns units; Node reports µs. */
 static double scr_filetime_us(FILETIME ft) {

package/src/scr_qs.c

@@ -0,0 +1,496 @@
+/* node:querystring (scr_runtime.h has the API contract): Node v24's
+ * legacy query-string codec — NOT URLSearchParams (the escaping and '+'
+ * rules differ; that surface lives in scr_url_params.c). LINK-GATED:
+ * compiled into the binary only when the IR uses the qs surface
+ * (moduleUsesQs — the scr_url_params gating precedent), so qs-free
+ * programs pay zero bytes. querystring.escape never reaches this unit at
+ * all: Node's qsEscape encodes exactly the component unreserved set, so
+ * the frontend lowers it to the always-linked
+ * scr_str_encode_uri_component.
+ *
+ * Everything here is a quirk-faithful port of lib/querystring.js (Node is
+ * the oracle): parse's interleaved sep/eq scan with its naive
+ * partial-match resets and the encodeCheck fast path, unescapeBuffer's
+ * UTF-16-code-unit byte truncation, and stringify's encodeStringified
+ * value rules. The scans run byte-wise over the runtime's UTF-8 storage —
+ * equivalent to Node's code-unit scans for well-formed input, because the
+ * machine only assigns meaning to ASCII ('%', '+', hex, and the sep/eq
+ * sequences positionally) and UTF-8 multibyte alignment mirrors UTF-16
+ * unit alignment. */
+#include "scr_runtime.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ── a tiny growable byte buffer (scr_url_params.c's, redeclared) ────── */
+
+typedef struct {
+  char *data;
+  size_t len;
+  size_t cap;
+} QsBuf;
+
+static void qb_init(QsBuf *b) {
+  b->cap = 64;
+  b->len = 0;
+  b->data = malloc(b->cap);
+  if (!b->data) {
+    fputs("scriptc: out of memory\n", stderr);
+    abort();
+  }
+}
+
+static void qb_append(QsBuf *b, const char *bytes, size_t n) {
+  if (b->len + n > b->cap) {
+    while (b->len + n > b->cap) b->cap *= 2;
+    char *grown = realloc(b->data, b->cap);
+    if (!grown) {
+      fputs("scriptc: out of memory\n", stderr);
+      abort();
+    }
+    b->data = grown;
+  }
+  memcpy(b->data + b->len, bytes, n);
+  b->len += n;
+}
+
+static void qb_push(QsBuf *b, char c) { qb_append(b, &c, 1); }
+
+static void qb_append_str(QsBuf *b, const ScrStr *s) {
+  qb_append(b, s->data, s->len);
+}
+
+static ScrStr *qb_take(QsBuf *b) {
+  ScrStr *s = scr_str_new(b->data, b->len);
+  free(b->data);
+  return s;
+}
+
+/* ── shared scan helpers ─────────────────────────────────────────────── */
+
+static int qs_unhex(unsigned c) {
+  if (c >= '0' && c <= '9') return (int)(c - '0');
+  if (c >= 'A' && c <= 'F') return (int)(c - 'A' + 10);
+  if (c >= 'a' && c <= 'f') return (int)(c - 'a' + 10);
+  return -1;
+}
+
+/* One UTF-8 code point at p (well-formed by the runtime invariant);
+ * *adv gets the byte length. */
+static uint32_t qs_utf8_decode(const char *p, size_t *adv) {
+  unsigned char b0 = (unsigned char)p[0];
+  if (b0 < 0x80) {
+    *adv = 1;
+    return b0;
+  }
+  if (b0 < 0xE0) {
+    *adv = 2;
+    return (uint32_t)((b0 & 0x1Fu) << 6) | ((unsigned char)p[1] & 0x3Fu);
+  }
+  if (b0 < 0xF0) {
+    *adv = 3;
+    return (uint32_t)((b0 & 0x0Fu) << 12) |
+           (uint32_t)(((unsigned char)p[1] & 0x3Fu) << 6) |
+           ((unsigned char)p[2] & 0x3Fu);
+  }
+  *adv = 4;
+  return (uint32_t)((b0 & 0x07u) << 18) |
+         (uint32_t)(((unsigned char)p[1] & 0x3Fu) << 12) |
+         (uint32_t)(((unsigned char)p[2] & 0x3Fu) << 6) |
+         ((unsigned char)p[3] & 0x3Fu);
+}
+
+static void qs_utf8_encode(QsBuf *b, uint32_t cp) {
+  char tmp[4];
+  if (cp < 0x80) {
+    tmp[0] = (char)cp;
+    qb_append(b, tmp, 1);
+  } else if (cp < 0x800) {
+    tmp[0] = (char)(0xC0 | (cp >> 6));
+    tmp[1] = (char)(0x80 | (cp & 0x3F));
+    qb_append(b, tmp, 2);
+  } else if (cp < 0x10000) {
+    tmp[0] = (char)(0xE0 | (cp >> 12));
+    tmp[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
+    tmp[2] = (char)(0x80 | (cp & 0x3F));
+    qb_append(b, tmp, 3);
+  } else {
+    tmp[0] = (char)(0xF0 | (cp >> 18));
+    tmp[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+    tmp[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
+    tmp[3] = (char)(0x80 | (cp & 0x3F));
+    qb_append(b, tmp, 4);
+  }
+}
+
+/* ── unescape (Node's qsUnescape) ────────────────────────────────────── */
+
+/* The string's UTF-16 code units (astral chars split into surrogate
+ * pairs) — unescapeBuffer's scan is defined over these, byte-truncation
+ * quirk included, so the fallback builds them first. Caller frees. */
+static uint16_t *qs_utf16_units(const ScrStr *s, size_t *out_n) {
+  /* One unit per byte is a safe cap (ASCII 1:1; multibyte shrinks). */
+  uint16_t *units = malloc(sizeof(uint16_t) * (s->len ? s->len : 1));
+  if (!units) {
+    fputs("scriptc: out of memory\n", stderr);
+    abort();
+  }
+  size_t n = 0, i = 0;
+  while (i < s->len) {
+    size_t adv;
+    uint32_t cp = qs_utf8_decode(s->data + i, &adv);
+    i += adv;
+    if (cp >= 0x10000) {
+      cp -= 0x10000;
+      units[n++] = (uint16_t)(0xD800 + (cp >> 10));
+      units[n++] = (uint16_t)(0xDC00 + (cp & 0x3FF));
+    } else {
+      units[n++] = (uint16_t)cp;
+    }
+  }
+  *out_n = n;
+  return units;
+}
+
+/* WHATWG UTF-8 decode with replacement (maximal subpart) — the semantics
+ * of Buffer.prototype.toString('utf8') the fallback path ends with. */
+static ScrStr *qs_utf8_replace_decode(const unsigned char *p, size_t n) {
+  QsBuf out;
+  qb_init(&out);
+  size_t i = 0;
+  while (i < n) {
+    unsigned char b0 = p[i];
+    if (b0 < 0x80) {
+      qb_push(&out, (char)b0);
+      i++;
+      continue;
+    }
+    int need;
+    unsigned lo = 0x80, hi = 0xBF;
+    if (b0 >= 0xC2 && b0 <= 0xDF) need = 1;
+    else if (b0 == 0xE0) { need = 2; lo = 0xA0; }
+    else if (b0 == 0xED) { need = 2; hi = 0x9F; }
+    else if (b0 >= 0xE1 && b0 <= 0xEF) need = 2;
+    else if (b0 == 0xF0) { need = 3; lo = 0x90; }
+    else if (b0 == 0xF4) { need = 3; hi = 0x8F; }
+    else if (b0 >= 0xF1 && b0 <= 0xF3) need = 3;
+    else { /* 0x80..0xC1, 0xF5..0xFF: never a leading byte */
+      qs_utf8_encode(&out, 0xFFFD);
+      i++;
+      continue;
+    }
+    /* Consume as many valid continuations as exist (maximal subpart):
+     * an invalid or missing continuation replaces the consumed prefix
+     * with ONE U+FFFD and rescans at the offending byte. */
+    uint32_t cp = b0 & (uint32_t)(0xFF >> (need + 2));
+    size_t j = i + 1;
+    int k = 0;
+    bool ok = true;
+    for (; k < need; k++, j++) {
+      if (j >= n) { ok = false; break; }
+      unsigned c = p[j];
+      unsigned clo = (k == 0) ? lo : 0x80, chi = (k == 0) ? hi : 0xBF;
+      if (c < clo || c > chi) { ok = false; break; }
+      cp = (cp << 6) | (c & 0x3F);
+    }
+    if (!ok) {
+      qs_utf8_encode(&out, 0xFFFD);
+      i = j; /* prefix consumed; rescan at the offending byte */
+      continue;
+    }
+    qs_utf8_encode(&out, cp);
+    i = j;
+  }
+  return qb_take(&out);
+}
+
+/* Node's unescapeBuffer(s) (decodeSpaces false — neither qsUnescape nor
+ * the exported unescape passes it) over the UTF-16 units, then the
+ * replacement decode of the byte buffer. */
+static ScrStr *qs_unescape_buffer(const ScrStr *s) {
+  size_t n;
+  uint16_t *units = qs_utf16_units(s, &n);
+  unsigned char *out = malloc(n ? n : 1);
+  if (!out) {
+    fputs("scriptc: out of memory\n", stderr);
+    abort();
+  }
+  size_t w = 0, index = 0;
+  /* maxLength = s.length - 2 as a signed comparison (n < 2 must refuse
+   * every escape, matching Node's `index < maxLength` on negatives). */
+  while (index < n) {
+    unsigned cur = units[index];
+    if (cur == '%' && n >= 3 && index < n - 2) {
+      unsigned c1 = units[index + 1];
+      int hexHigh = (c1 < 256) ? qs_unhex(c1) : -1;
+      if (hexHigh < 0) {
+        out[w++] = '%';
+        index++;
+        continue;
+      }
+      unsigned c2 = units[index + 2];
+      int hexLow = (c2 < 256) ? qs_unhex(c2) : -1;
+      if (hexLow < 0) {
+        out[w++] = '%';
+        index++; /* Node: ++index then index-- — net one step */
+        continue;
+      }
+      cur = (unsigned)(hexHigh * 16 + hexLow);
+      index += 2;
+    }
+    out[w++] = (unsigned char)(cur & 0xFF); /* Buffer write truncates */
+    index++;
+  }
+  free(units);
+  ScrStr *res = qs_utf8_replace_decode(out, w);
+  free(out);
+  return res;
+}
+
+ScrStr *scr_qs_unescape(const ScrStr *s) {
+  ScrStr *strict = scr_str_decode_uri_component_try((ScrStr *)s);
+  if (strict) return strict;
+  return qs_unescape_buffer(s);
+}
+
+/* ── parse ───────────────────────────────────────────────────────────── */
+
+/* addKeyVal's tail: decode-if-encoded, then group into the overflow map
+ * (first value = the str_tag arm; a repeat REPLACES it with a two-element
+ * string[] in the arr_tag arm; later repeats push). key/value move in. */
+static void qs_add_key_val(ScrMap *out, ScrStr *key, ScrStr *value,
+                           bool key_encoded, bool val_encoded,
+                           uint32_t str_tag, uint32_t arr_tag) {
+  if (key->len > 0 && key_encoded) {
+    ScrStr *dec = scr_qs_unescape(key);
+    scr_str_release(key);
+    key = dec;
+  }
+  if (value->len > 0 && val_encoded) {
+    ScrStr *dec = scr_qs_unescape(value);
+    scr_str_release(value);
+    value = dec;
+  }
+  ScrUnion *cell = scr_map_get_str_ref(out, key);
+  if (!cell) {
+    scr_map_set_str_ref(out, key,
+                        scr_union_new_ref(str_tag, value, &scr_str_retain_v,
+                                          &scr_str_release_v, NULL));
+    scr_str_release(key);
+    return;
+  }
+  if (cell->tag == str_tag) {
+    /* obj[key] = [curValue, value] */
+    ScrArr *rows = scr_arr_new(SCR_ELEM_STR, 2);
+    scr_arr_push_ref(rows, scr_str_retain_v(scr_union_peek(cell)));
+    scr_arr_push_ref(rows, value);
+    scr_map_set_str_ref(out, key,
+                        scr_union_new_ref(arr_tag, rows, &scr_arr_retain_v,
+                                          &scr_arr_release_v, NULL));
+  } else {
+    scr_arr_push_ref((ScrArr *)scr_union_peek(cell), value);
+  }
+  scr_union_release(cell);
+  scr_str_release(key);
+}
+
+void scr_qs_parse_into(ScrMap *out, const ScrStr *qs, const ScrStr *sep,
+                       const ScrStr *eq, double max_keys, uint32_t str_tag,
+                       uint32_t arr_tag) {
+  if (qs->len == 0) return;
+  /* Node's falsy rule: undefined/null/'' all mean the default. */
+  const char *sep_b = (sep && sep->len) ? sep->data : "&";
+  size_t sep_len = (sep && sep->len) ? sep->len : 1;
+  const char *eq_b = (eq && eq->len) ? eq->data : "=";
+  size_t eq_len = (eq && eq->len) ? eq->len : 1;
+
+  /* pairs: Node's `maxKeys > 0 ? maxKeys : -1` as a double so Infinity
+   * decrements forever, exactly like Node's -1 sentinel. */
+  double pairs = max_keys > 0 ? max_keys : -1;
+
+  const char *p = qs->data;
+  size_t n = qs->len;
+  QsBuf key, value;
+  qb_init(&key);
+  qb_init(&value);
+  size_t last_pos = 0, sep_idx = 0, eq_idx = 0;
+  bool key_encoded = false, val_encoded = false;
+  int encode_check = 0;
+  bool returned = false;
+
+  for (size_t i = 0; i < n; ++i) {
+    unsigned char code = (unsigned char)p[i];
+
+    /* Try matching the pair separator (e.g. '&'). */
+    if (code == (unsigned char)sep_b[sep_idx]) {
+      if (++sep_idx == sep_len) {
+        /* Key/value pair separator match. */
+        size_t end = i - sep_idx + 1;
+        if (eq_idx < eq_len) {
+          /* No (entire) key/value separator seen. */
+          if (last_pos < end) {
+            qb_append(&key, p + last_pos, end - last_pos);
+          } else if (key.len == 0) {
+            /* An empty substring between separators. */
+            if (--pairs == 0) { returned = true; break; }
+            last_pos = i + 1;
+            sep_idx = eq_idx = 0;
+            continue;
+          }
+        } else if (last_pos < end) {
+          qb_append(&value, p + last_pos, end - last_pos);
+        }
+
+        qs_add_key_val(out, scr_str_new(key.data, key.len),
+                       scr_str_new(value.data, value.len), key_encoded,
+                       val_encoded, str_tag, arr_tag);
+
+        if (--pairs == 0) { returned = true; break; }
+        key_encoded = val_encoded = false;
+        key.len = value.len = 0;
+        encode_check = 0;
+        last_pos = i + 1;
+        sep_idx = eq_idx = 0;
+      }
+    } else {
+      sep_idx = 0;
+      /* Try matching the key/value separator (e.g. '=') if we haven't. */
+      if (eq_idx < eq_len) {
+        if (code == (unsigned char)eq_b[eq_idx]) {
+          if (++eq_idx == eq_len) {
+            /* Key/value separator match. */
+            size_t end = i - eq_idx + 1;
+            if (last_pos < end) qb_append(&key, p + last_pos, end - last_pos);
+            encode_check = 0;
+            last_pos = i + 1;
+          }
+          continue;
+        }
+        eq_idx = 0;
+        if (!key_encoded) {
+          /* Match a valid encoded byte once, to minimize decode calls. */
+          if (code == '%') {
+            encode_check = 1;
+            continue;
+          } else if (encode_check > 0) {
+            if (qs_unhex(code) >= 0) {
+              if (++encode_check == 3) key_encoded = true;
+              continue;
+            } else {
+              encode_check = 0;
+            }
+          }
+        }
+        if (code == '+') {
+          if (last_pos < i) qb_append(&key, p + last_pos, i - last_pos);
+          qb_push(&key, ' ');
+          last_pos = i + 1;
+          continue;
+        }
+      }
+      if (code == '+') {
+        if (last_pos < i) qb_append(&value, p + last_pos, i - last_pos);
+        qb_push(&value, ' ');
+        last_pos = i + 1;
+      } else if (!val_encoded) {
+        if (code == '%') {
+          encode_check = 1;
+        } else if (encode_check > 0) {
+          if (qs_unhex(code) >= 0) {
+            if (++encode_check == 3) val_encoded = true;
+          } else {
+            encode_check = 0;
+          }
+        }
+      }
+    }
+  }
+
+  if (!returned) {
+    /* Leftover key or value data. */
+    bool ended_empty = false;
+    if (last_pos < n) {
+      if (eq_idx < eq_len) qb_append(&key, p + last_pos, n - last_pos);
+      else if (sep_idx < sep_len) qb_append(&value, p + last_pos, n - last_pos);
+    } else if (eq_idx == 0 && key.len == 0) {
+      ended_empty = true; /* ended on an empty substring */
+    }
+    if (!ended_empty) {
+      qs_add_key_val(out, scr_str_new(key.data, key.len),
+                     scr_str_new(value.data, value.len), key_encoded,
+                     val_encoded, str_tag, arr_tag);
+    }
+  }
+  free(key.data);
+  free(value.data);
+}
+
+/* ── stringify ───────────────────────────────────────────────────────── */
+
+/* Node's encodeStringified over one DOM value: strings escape, finite
+ * numbers render then escape, booleans are bare, everything else is the
+ * empty value. Appends to b. */
+static void qs_stringify_value(QsBuf *b, const ScrDyn *v) {
+  switch (v->kind) {
+    case SCR_DYN_STR: {
+      ScrStr *enc = scr_str_encode_uri_component(v->v.str);
+      qb_append_str(b, enc);
+      scr_str_release(enc);
+      return;
+    }
+    case SCR_DYN_NUM: {
+      if (!isfinite(v->v.num)) return;
+      ScrStr *num = scr_f64_to_scrstr(v->v.num);
+      ScrStr *enc = scr_str_encode_uri_component(num);
+      qb_append_str(b, enc);
+      scr_str_release(enc);
+      scr_str_release(num);
+      return;
+    }
+    case SCR_DYN_BOOL:
+      if (v->v.b) qb_append(b, "true", 4);
+      else qb_append(b, "false", 5);
+      return;
+    default:
+      return; /* null/undefined/objects/arrays/functions → '' */
+  }
+}
+
+ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
+                         const ScrStr *eq) {
+  const char *sep_b = (sep && sep->len) ? sep->data : "&";
+  size_t sep_len = (sep && sep->len) ? sep->len : 1;
+  const char *eq_b = (eq && eq->len) ? eq->data : "=";
+  size_t eq_len = (eq && eq->len) ? eq->len : 1;
+  if (!obj || obj->kind != SCR_DYN_OBJ) return scr_str_new("", 0);
+
+  QsBuf fields;
+  qb_init(&fields);
+  /* JS own-key order (array-index keys ascending first) — ObjectKeys. */
+  ScrDyn *keys = scr_dyn_obj_keys((ScrDyn *)obj);
+  for (size_t i = 0; i < keys->v.arr.len; i++) {
+    const ScrDyn *kd = keys->v.arr.items[i];
+    const ScrStr *k = kd->v.str;
+    const ScrDyn *v = scr_dyn_obj_get(obj, k->data, k->len);
+    if (!v) continue; /* unreachable: keys came from the object */
+    ScrStr *ks = scr_str_encode_uri_component((ScrStr *)k);
+    if (v->kind == SCR_DYN_ARR) {
+      for (size_t j = 0; j < v->v.arr.len; j++) {
+        if (fields.len) qb_append(&fields, sep_b, sep_len);
+        qb_append_str(&fields, ks);
+        qb_append(&fields, eq_b, eq_len);
+        qs_stringify_value(&fields, v->v.arr.items[j]);
+      }
+    } else {
+      if (fields.len) qb_append(&fields, sep_b, sep_len);
+      qb_append_str(&fields, ks);
+      qb_append(&fields, eq_b, eq_len);
+      qs_stringify_value(&fields, v);
+    }
+    scr_str_release(ks);
+  }
+  scr_dyn_release(keys);
+  return qb_take(&fields);
+}

package/src/scr_runtime.h

@@ -484,6 +484,64 @@ ScrStr *scr_str_encode_uri_component(ScrStr *s);
  * malformed") and returns NULL. Borrows s; result +1. */
 ScrStr *scr_str_decode_uri_component(ScrStr *s);
 
+/* The non-throwing core of decodeURIComponent: NULL on malformed input
+ * instead of the URIError — the try/catch shape node:querystring's
+ * unescape wraps around decodeURIComponent (scr_qs.c's strict pass). */
+ScrStr *scr_str_decode_uri_component_try(ScrStr *s);
+
+/* ── node:querystring (scr_qs.c — LINK-GATED by moduleUsesQs; the
+ * scr_url_params.c precedent: pure data transforms, no loop hooks).
+ * querystring.escape needs no entry here: Node's qsEscape encodes exactly
+ * the component unreserved set, so the frontend lowers it to
+ * scr_str_encode_uri_component (always linked; a program using only
+ * escape never pulls this unit). */
+
+/* querystring.unescape — Node's qsUnescape: strict decodeURIComponent
+ * first, and on failure the lenient legacy unescapeBuffer(s).toString()
+ * (valid %XX escapes decode to their byte, malformed escapes copy
+ * literally, every non-escape UTF-16 CODE UNIT truncates to its low byte
+ * — Node's Buffer element write — and the byte buffer decodes as UTF-8
+ * with U+FFFD replacement per maximal subpart, Buffer.toString's rule).
+ * Borrows s; result +1; never throws. */
+ScrStr *scr_qs_unescape(const ScrStr *s);
+
+/* querystring.parse — Node v24's scan state machine, byte-wise over the
+ * UTF-8 storage (equivalent to the code-unit scan for well-formed input:
+ * the machine compares sep/eq sequences positionally and treats '%'/'+'/
+ * hex as ASCII, and multibyte alignment is preserved). Decoded pairs land
+ * in `out` — the PURE-index-signature Dict record's overflow map (the
+ * emitters pass rec->sc_ovf) — grouped like Node's addKeyVal: a first
+ * value stores the `str_tag` union arm, a repeat REPLACES it with a
+ * two-element string[] wrapped in `arr_tag`, later repeats push. sep/eq
+ * fall back to "&"/"=" when empty (Node's falsy rule; the frontend
+ * completes omitted/null arguments to the defaults). max_keys is Node's
+ * rule exactly: > 0 caps the PAIR count (empty skipped segments count,
+ * like Node's --pairs), anything else (0, negatives, NaN) is unlimited;
+ * the frontend completes the omitted option to 1000. Only the DEFAULT
+ * decoder runs (custom decodeURIComponent options fence at compile time),
+ * so '+' means ' ' and segments decode with scr_qs_unescape's semantics
+ * only when they carry a full valid %XX triple (Node's encodeCheck).
+ * Borrows everything; never throws. */
+typedef struct ScrMap ScrMap; /* full definition below (C11 repeat) */
+void scr_qs_parse_into(ScrMap *out, const ScrStr *qs, const ScrStr *sep,
+                       const ScrStr *eq, double max_keys, uint32_t str_tag,
+                       uint32_t arr_tag);
+
+/* querystring.stringify — Node's stringify over a borrowed DOM value (the
+ * frontend dynFroms the typed record; JS-world dyn values pass straight
+ * through). Non-object DOMs answer "" like Node; object keys iterate in
+ * JS own-key order (scr_dyn_obj_keys — array-index keys ascending first,
+ * then insertion order, Node's ObjectKeys). Values serialize per Node's
+ * encodeStringified: strings escape, finite numbers render shortest-
+ * roundtrip then escape ('1e+21' → '1e%2B21'), booleans are bare
+ * true/false, arrays expand to repeated keys (empty arrays emit NOTHING,
+ * key included), and everything else (null, undefined, nested objects/
+ * arrays, functions) is the empty value — key and eq still emitted.
+ * sep/eq fall back to "&"/"=" when empty (Node's `sep ||= '&'`). Result
+ * +1; never throws. */
+ScrStr *scr_qs_stringify(const struct ScrDyn *obj, const ScrStr *sep,
+                         const ScrStr *eq);
+
 /* encodeURI — the same ECMA-262 Encode() with the reserved set and '#'
  * kept unescaped (scr_encode_uri_impl's keep_reserved arm). Total by the
  * well-formed-UTF-8 invariant. Borrows s; result +1. */
@@ -1675,6 +1733,9 @@ double scr_process_umask(double mask);
  * has no answer). scr_active_resources (scr_async.c) walks the loop's
  * own bookkeeping — 'Timeout'/'Immediate' strings, +1. */
 double scr_process_uptime(void);
+/* perf_hooks performance.now(): fractional ms since process start (the
+ * uptime anchor — Node's timeOrigin for a compiled program). */
+double scr_perf_now(void);
 double scr_cpu_user(void);
 double scr_cpu_system(void);
 double scr_cpu_user_diff(double prev);

package/src/scr_string.c

@@ -1212,7 +1212,12 @@ static int scr_uri_hex_byte(const char *p, size_t rem) {
   return (hi << 4) | lo;
 }
 
-ScrStr *scr_str_decode_uri_component(ScrStr *s) {
+/* The non-throwing core of decodeURIComponent: NULL on malformed input
+ * (bad hex, invalid UTF-8 octets) instead of the URIError — the
+ * querystring unit's unescape needs exactly the try/catch shape Node's
+ * qsUnescape wraps around decodeURIComponent (scr_qs.c), and the throwing
+ * entry point below stays byte-identical by rethrowing over NULL. */
+ScrStr *scr_str_decode_uri_component_try(ScrStr *s) {
   /* Decoding only ever shrinks (%XX → 1 byte), so len is a safe cap. */
   ScrStr *out = scr_str_alloc_raw(0, s->len);
   size_t w = 0;
@@ -1258,7 +1263,15 @@ ScrStr *scr_str_decode_uri_component(ScrStr *s) {
   return out;
 malformed:
   scr_str_release(out);
-  scr_uri_malformed();
   return NULL;
 }
 
+ScrStr *scr_str_decode_uri_component(ScrStr *s) {
+  ScrStr *out = scr_str_decode_uri_component_try(s);
+  if (!out) {
+    scr_uri_malformed();
+    return NULL;
+  }
+  return out;
+}
+

package/vendor/mbedtls/library/ecp.c

@@ -3155,7 +3155,7 @@ int mbedtls_ecp_gen_keypair(mbedtls_ecp_group *grp,
 }
 
 /*
- * Generate a keypair, prettier wrapper
+ * Generate a keypair, the formatter wrapper
  */
 int mbedtls_ecp_gen_key(mbedtls_ecp_group_id grp_id, mbedtls_ecp_keypair *key,
                         int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)