@scriptc/runtime 0.0.3 → 0.0.5

package/src/scr_runtime.h

@@ -39,6 +39,81 @@ char *strcasestr(const char *hay, const char *needle);
  * flush-at-exit, RC audit registration (when built with -DSCR_RC_AUDIT). */
 void scr_init(void);
 
+/* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ──────
+ * Every unrecoverable runtime trap — OOM, semantic range traps, internal-
+ * invariant failures — funnels through this pair instead of open-coded
+ * fputs/fprintf + abort. Executable builds expand to exactly the historical
+ * behavior (the message's bytes on stderr, then abort — the default lane
+ * must not change by a byte). Library builds (-DSCR_LIB) route the message to
+ * the host-registered panic sink and abort only as the last resort: before
+ * registration, or if the sink returns (the ruled host-contract violation —
+ * a conforming sink longjmps to a host frame BELOW the entry, never back
+ * into library frames). Messages keep their trailing newline in both lanes so
+ * the funnel is a pure indirection over identical bytes. */
+_Noreturn void scr_trap(const char *msg);
+_Noreturn void scr_trap_fmt(const char *fmt, ...);
+
+/* ── library mode (scr_library.c, linked only into library artifacts) ─────
+ * A library artifact has no main, no event loop, no signal handlers, no
+ * atexit registrations, and never touches host stdio modes or buffering:
+ * initialization runs inside the profile-named init entry (re-runnable
+ * deterministically), traps route to the sink above, and buffer-class
+ * results live in a library-owned result arena. Everything here compiles only
+ * under -DSCR_LIB; executable builds never contain it. */
+#ifdef SCR_LIB
+typedef struct ScrStr ScrStr;     /* full definitions below (C11 repeat) */
+typedef struct ScrBytes ScrBytes;
+/* The host's panic sink: msg is UTF-8, valid only for the duration of the
+ * call; address is the trap site's return address (0 when the toolchain
+ * cannot supply one); ctx is the registration's opaque pointer. The sink
+ * must not call back into any library entry and must not unwind or longjmp
+ * back into library frames. */
+typedef void (*ScrLibSinkFn)(void *ctx, const uint8_t *msg, size_t msg_len,
+                              uint64_t address);
+void scr_library_set_sink(ScrLibSinkFn fn, void *ctx); /* latest wins */
+
+/* Entry prologue: aborts deterministically when the library is poisoned (a
+ * trap already fired — no profile entry may run again; recovery is process
+ * restart). reset_arena additionally drops the result arena (the
+ * auto-reset posture, and the reset/collect entries' shared body). */
+void scr_library_entry(bool reset_arena);
+void scr_library_arena_reset(void);
+/* The mode-provided collect entry's body: arena reset + a full cycle
+ * collection (snapshot-invariant by construction — collection frees only
+ * unreachable cycles). */
+void scr_library_collect(void);
+
+/* Full session reset, called by the generated init entry AFTER the program
+ * TU released and zeroed its globals: pending-exception clear, arena
+ * reset, the reset registry's drains (the units' repointed atexit halves),
+ * the library's interned process values, a cycle collection, and — under
+ * SCR_RC_AUDIT — the zero-live-heap assertion (a failure is a trap through
+ * the sink, never _Exit). */
+void scr_library_reset(void);
+/* Where a unit would atexit() a lazy teardown, library builds register it
+ * here instead (called on every scr_library_reset, registered once). */
+void scr_library_register_reset(void (*fn)(void));
+/* An escaped exception at an entry boundary: renders the same "Uncaught
+ * ..." text the executable epilogue prints, releases the payload, and
+ * routes the text through the trap funnel. No-op when nothing is pending.
+ * Defined in scr_exception.c (it owns the cell). */
+void scr_library_check_exc(void);
+
+/* Marshalling helpers the generated wrappers call (both emissions share
+ * these bodies, which is how the two lanes stay identical by
+ * construction). Inbound is borrowed-and-copied; outbound values MOVE into
+ * the result arena and stay valid until the next arena reset. String
+ * results are NUL-terminated after *out_len bytes (ScrStr's layout). */
+ScrStr *scr_library_str_in(const uint8_t *p, size_t len);   /* +1 */
+ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len); /* +1, u8 */
+void scr_library_str_out(ScrStr *s, const uint8_t **out, size_t *out_len);
+void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len);
+
+#define scr_atexit(fn) scr_library_register_reset(fn)
+#else
+#define scr_atexit(fn) atexit(fn)
+#endif /* SCR_LIB */
+
 /* ── cycle collection (scr_cycle.c) ───────────────────────────────────
  * Reference counting alone cannot free cycles, so every object that can
  * participate in one — capture boxes, heap closures, unions, promises, and
@@ -484,6 +559,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 +1808,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

@@ -15,8 +15,7 @@ long scr_str_live_count(void) { return scr_live_strings; }
 #endif
 
 static void scr_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 /* ── UTF-16 index cache ───────────────────────────────────────────────
@@ -519,8 +518,7 @@ ScrStr *scr_str_slice(ScrStr *s, double start, double end) {
 ScrStr *scr_str_repeat(ScrStr *s, double count) {
   double n = scr_to_integer_or_infinity(count);
   if (n < 0 || (isinf(n) && n > 0)) {
-    fputs("scriptc: RangeError: Invalid count value\n", stderr);
-    abort();
+    scr_trap("scriptc: RangeError: Invalid count value\n");
   }
   if (n == 0 || s->len == 0) return scr_str_empty();
   /* n is a finite non-negative integer here. Reject sizes malloc could not
@@ -1212,7 +1210,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 +1261,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/src/scr_symbol.c

@@ -44,8 +44,7 @@ void scr_sym_release_v(void *p) { scr_sym_release(p); }
 ScrSym *scr_sym_new(ScrStr *desc) {
   ScrSym *s = malloc(sizeof(ScrSym));
   if (!s) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   s->rc = 1;
   s->desc = desc ? scr_str_retain(desc) : NULL;
@@ -75,7 +74,7 @@ ScrSym *scr_sym_for(ScrStr *key) {
   /* First request for this key: a fresh symbol whose description IS the
    * key (the spec's Symbol.for behavior), chained into the registry with
    * the registry's own reference. */
-  if (!g_sym_registry) atexit(scr_sym_registry_cleanup);
+  if (!g_sym_registry) scr_atexit(scr_sym_registry_cleanup);
   ScrSym *s = scr_sym_new(key);
   s->reg_key = scr_str_retain(key);
   s->reg_next = g_sym_registry;

package/src/scr_url.c

@@ -69,8 +69,7 @@ static void ub_init(UrlBuf *b) {
   b->len = 0;
   b->data = malloc(b->cap);
   if (!b->data) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
 }
 
@@ -79,8 +78,7 @@ static void ub_append(UrlBuf *b, const char *bytes, size_t n) {
     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();
+      scr_trap("scriptc: out of memory\n");
     }
     b->data = grown;
   }
@@ -182,8 +180,7 @@ static ScrStr *parse_rooted_path(const char *raw, size_t len, bool special) {
   size_t seg_starts_cap = 8, seg_count = 0;
   size_t *seg_starts = malloc(seg_starts_cap * sizeof(size_t));
   if (!seg_starts) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   size_t i = 0;
   /* One leading separator opens the first segment (rooted). */
@@ -206,7 +203,7 @@ static ScrStr *parse_rooted_path(const char *raw, size_t len, bool special) {
         if (seg_count == seg_starts_cap) {
           seg_starts_cap *= 2;
           seg_starts = realloc(seg_starts, seg_starts_cap * sizeof(size_t));
-          if (!seg_starts) abort();
+          if (!seg_starts) scr_trap("scriptc: out of memory\n");
         }
         seg_starts[seg_count++] = out.len;
       }
@@ -215,7 +212,7 @@ static ScrStr *parse_rooted_path(const char *raw, size_t len, bool special) {
         if (seg_count == seg_starts_cap) {
           seg_starts_cap *= 2;
           seg_starts = realloc(seg_starts, seg_starts_cap * sizeof(size_t));
-          if (!seg_starts) abort();
+          if (!seg_starts) scr_trap("scriptc: out of memory\n");
         }
         seg_starts[seg_count++] = out.len;
       }
@@ -224,8 +221,7 @@ static ScrStr *parse_rooted_path(const char *raw, size_t len, bool special) {
         seg_starts_cap *= 2;
         seg_starts = realloc(seg_starts, seg_starts_cap * sizeof(size_t));
         if (!seg_starts) {
-          fputs("scriptc: out of memory\n", stderr);
-          abort();
+          scr_trap("scriptc: out of memory\n");
         }
       }
       seg_starts[seg_count++] = out.len;
@@ -355,8 +351,7 @@ ScrUrl *scr_url_new(ScrStr *input) {
   while (e > b && (unsigned char)raw[e - 1] <= 0x20) e--;
   char *buf = malloc(e - b + 1);
   if (!buf) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   size_t len = 0;
   for (size_t i = b; i < e; i++) {
@@ -526,8 +521,7 @@ ScrUrl *scr_url_new(ScrStr *input) {
 
   ScrUrl *u = malloc(sizeof(ScrUrl));
   if (!u) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   u->rc = 1;
   u->scheme = scheme_str;
@@ -738,8 +732,7 @@ ScrStr *scr_url_str_to_path(ScrStr *input) {
 static ScrUrl *scr_url_new_file(ScrStr *host, ScrStr *encoded_path) {
   ScrUrl *u = malloc(sizeof(ScrUrl));
   if (!u) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   u->rc = 1;
   u->scheme = scr_str_new("file", 4);

package/src/scr_url_params.c

@@ -26,8 +26,7 @@ static void ub_init(UrlBuf *b) {
   b->len = 0;
   b->data = malloc(b->cap);
   if (!b->data) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
 }
 
@@ -36,8 +35,7 @@ static void ub_append(UrlBuf *b, const char *bytes, size_t n) {
     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();
+      scr_trap("scriptc: out of memory\n");
     }
     b->data = grown;
   }
@@ -94,8 +92,7 @@ struct ScrSearchParams {
 static ScrSearchParams *sp_alloc(void) {
   ScrSearchParams *sp = malloc(sizeof(ScrSearchParams));
   if (!sp) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   sp->rc = 1;
   sp->len = 0;
@@ -103,8 +100,7 @@ static ScrSearchParams *sp_alloc(void) {
   sp->names = malloc(sp->cap * sizeof(ScrStr *));
   sp->vals = malloc(sp->cap * sizeof(ScrStr *));
   if (!sp->names || !sp->vals) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   sp->owner = NULL;
   return sp;
@@ -142,8 +138,7 @@ static void sp_push(ScrSearchParams *sp, ScrStr *name, ScrStr *value) {
     ScrStr **gn = realloc(sp->names, sp->cap * sizeof(ScrStr *));
     ScrStr **gv = realloc(sp->vals, sp->cap * sizeof(ScrStr *));
     if (!gn || !gv) {
-      fputs("scriptc: out of memory\n", stderr);
-      abort();
+      scr_trap("scriptc: out of memory\n");
     }
     sp->names = gn;
     sp->vals = gv;
@@ -161,8 +156,7 @@ static ScrStr *sp_scrub_utf8(const char *in_c, size_t n) {
   const unsigned char *in = (const unsigned char *)in_c;
   char *out = malloc(n * 3 + 1);
   if (!out) {
-    fputs("scriptc: out of memory\n", stderr);
-    abort();
+    scr_trap("scriptc: out of memory\n");
   }
   size_t o = 0;
   uint32_t cp = 0;

package/src/scr_zlib.c

@@ -18,8 +18,7 @@
 #include <zlib.h>
 
 static void scr_zlib_oom(void) {
-  fputs("scriptc: out of memory\n", stderr);
-  abort();
+  scr_trap("scriptc: out of memory\n");
 }
 
 ScrBytes *scr_zlib_deflate(const ScrBytes *data) {

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)