@scriptc/runtime 0.0.23 → 0.0.24

package/src/scr_number.c

@@ -24,6 +24,15 @@
  * unchanged. Provides d2d(), d2d_small_int(), decimalLength17(), div10(). */
 #include "../vendor/ryu/d2s.c"
 
+/* ECMA ToUint32, shared by bitwise operators and split's limit: non-finite
+ * values become zero, finite values truncate toward zero and wrap mod 2^32. */
+uint32_t scr_to_uint32(double d) {
+  if (!isfinite(d)) return 0;
+  double t = fmod(trunc(d), 4294967296.0);
+  if (t < 0) t += 4294967296.0;
+  return (uint32_t)t;
+}
+
 /* 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

package/src/scr_regex.c

@@ -624,8 +624,10 @@ ScrStr *scr_regex_replace_all(ScrStr *s, ScrRegex *re, ScrStr *rep) {
 
 /* ── split ────────────────────────────────────────────────────────────── */
 
-ScrArr *scr_regex_split(ScrStr *s, ScrRegex *re) {
+ScrArr *scr_regex_split_limit(ScrStr *s, ScrRegex *re, double limit_num) {
   uint8_t *bc = scr_regex_bc(re);
+  uint32_t limit = scr_to_uint32(limit_num);
+  if (limit == 0) return scr_arr_new(SCR_ELEM_STR, 0);
   if (lre_get_capture_count(bc) > 1) {
     /* JS splices every capture group's value into the result between the
      * pieces, changing the array's SHAPE per match — not modeled this
@@ -675,6 +677,11 @@ ScrArr *scr_regex_split(ScrStr *s, ScrRegex *re) {
       q = scr_advance(u, len, start, unicode);
     } else {
       scr_arr_push_ref(out, scr_str_from_utf16(u, p, start));
+      if (out->len == limit) {
+        free(capture);
+        free(u);
+        return out;
+      }
       p = end;
       q = p;
     }
@@ -685,6 +692,10 @@ ScrArr *scr_regex_split(ScrStr *s, ScrRegex *re) {
   return out;
 }
 
+ScrArr *scr_regex_split(ScrStr *s, ScrRegex *re) {
+  return scr_regex_split_limit(s, re, 4294967295.0);
+}
+
 /* ── String.prototype.toLowerCase / toUpperCase (the static path) ──────
  * ECMA-262 Default Case Conversion via the vendored libunicode's
  * lre_case_conv — the exact tables and algorithm the engine's own

package/src/scr_runtime.h

@@ -612,12 +612,14 @@ ScrStr *scr_str_cp_at(ScrStr *s, double i);
 ScrStr *scr_str_trim_start(ScrStr *s);
 ScrStr *scr_str_trim_end(ScrStr *s);
 
-/* split(separator) with a STRING separator, no limit: empty separator
+/* split(separator[, limit]) with a STRING separator: limit uses ToUint32;
+ * the no-limit wrapper supplies 2^32-1. Empty separator
  * splits into single UTF-16 code units (each half of an astral char is
  * U+FFFD — divergence, see above); otherwise splits on every occurrence,
  * empty pieces kept. Borrows both; returns a +1 string[] (SCR_ELEM_STR). */
 struct ScrArr;
 struct ScrArr *scr_str_split(ScrStr *s, ScrStr *sep);
+struct ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit);
 
 /* padStart(maxLength, fill)/padEnd — ECMA StringPad, UTF-16 unit counts.
  * Target at or below the length (or empty fill) returns the receiver
@@ -720,6 +722,12 @@ 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);
 
+/* node:util.parseArgs — the static checked-dynamic boundary. `config` is
+ * the documented JSON-safe configuration object; the returned dyn tree is
+ * a fresh ParsedResults object whose `values` child has null prototype.
+ * Borrows config; returns +1, or NULL with a Node-coded TypeError pending. */
+struct ScrDyn *scr_util_parse_args(const struct ScrDyn *config);
+
 /* querystring.stringify — Node's stringify over a borrowed dyn value (the
  * frontend dynFroms the typed record; JS-world dyn values pass straight
  * through). Non-object dyn values answer "" like Node; object keys iterate in
@@ -880,6 +888,15 @@ double scr_arr_push_f64(ScrArr *a, double v);
 double scr_arr_push_bool(ScrArr *a, bool v);
 double scr_arr_push_ref(ScrArr *a, void *v);
 
+/* unshift returns the new length and _ref takes ownership. The spread form
+ * borrows a same-element-kind source, retains copied refs, and snapshots
+ * self-spread. reverse mutates in place and returns the receiver at +1. */
+double scr_arr_unshift_f64(ScrArr *a, double v);
+double scr_arr_unshift_bool(ScrArr *a, bool v);
+double scr_arr_unshift_ref(ScrArr *a, void *v);
+double scr_arr_unshift_spread(ScrArr *a, const ScrArr *src);
+ScrArr *scr_arr_reverse(ScrArr *a);
+
 /* pop traps on an empty array; _ref transfers ownership out (+1 to the
  * caller, no release). */
 double scr_arr_pop_f64(ScrArr *a);
@@ -983,8 +1000,10 @@ ScrStr *scr_regex_flags(ScrRegex *re);        /* +1 */
 ScrStr *scr_regex_replace(ScrStr *s, ScrRegex *re, ScrStr *rep);
 /* replaceAll: throws Node's TypeError when /g is missing (may-throw). */
 ScrStr *scr_regex_replace_all(ScrStr *s, ScrRegex *re, ScrStr *rep);
-/* split: capture-free patterns only — capture groups throw (may-throw). */
+/* split: capture-free patterns only — capture groups throw (may-throw).
+ * limit uses ToUint32; the no-limit wrapper supplies 2^32-1. */
 ScrArr *scr_regex_split(ScrStr *s, ScrRegex *re);
+ScrArr *scr_regex_split_limit(ScrStr *s, ScrRegex *re, double limit);
 /* matchAll drained eagerly: +1 string[][] of honest match slices; throws
  * Node's TypeError on a non-global regex (catchable). */
 ScrArr *scr_regex_match_all(ScrStr *s, ScrRegex *re);
@@ -2047,6 +2066,11 @@ void scr_fs_chmod(ScrStr *path, double mode);
 void scr_fs_chown(ScrStr *path, double uid, double gid);
 void scr_fs_copyfile(ScrStr *src, ScrStr *dest);
 void scr_fs_rename(ScrStr *oldpath, ScrStr *newpath);
+/* The callback rename worker uses the non-throwing syscall seam off the
+ * runtime thread, then materializes any Node-shaped Error back on the main
+ * thread. raw returns 0 on success or a positive errno value on failure. */
+int scr_fs_rename_raw(const ScrStr *oldpath, const ScrStr *newpath);
+void scr_fs_rename_error(int error, const ScrStr *oldpath, const ScrStr *newpath);
 void scr_fs_write_file_mode(ScrStr *path, ScrStr *data, double mode);
 void scr_fs_mkdir_mode(ScrStr *path, double mode);
 void scr_fs_mkdir_recursive_mode(ScrStr *path, double mode);
@@ -2079,6 +2103,7 @@ double scr_process_columns(double fd);
  * stat(2) — follows symlinks, like Node's stat family. scr_fs_stat
  * THROWS like the other sync calls. */
 typedef struct ScrStats ScrStats;
+typedef struct ScrFileHandle ScrFileHandle;
 typedef struct ScrPromise ScrPromise; /* full section further down */
 
 ScrStats *scr_fs_stat(ScrStr *path);  /* +1, or throws */
@@ -2091,6 +2116,9 @@ bool scr_stats_is_file(ScrStats *s);
 bool scr_stats_is_dir(ScrStats *s);
 bool scr_stats_is_symlink(ScrStats *s); /* lstat snapshots only */
 double scr_stats_size(ScrStats *s);
+double scr_stats_blocks(ScrStats *s); /* allocated size in 512-byte units */
+double scr_stats_nlink(ScrStats *s);
+double scr_stats_atime_ms(ScrStats *s); /* ms with the sub-second fraction */
 double scr_stats_mtime_ms(ScrStats *s); /* ms with the ns fraction */
 
 /* fs/promises: the SAME sync operations, minting an already-settled
@@ -2101,6 +2129,7 @@ double scr_stats_mtime_ms(ScrStats *s); /* ms with the ns fraction */
  * scr_lib.c without the fiber slice). */
 ScrPromise *scr_fsp_read_file(ScrStr *path);
 ScrPromise *scr_fsp_write_file(ScrStr *path, ScrStr *data);
+ScrPromise *scr_fsp_write_file_mode(ScrStr *path, ScrStr *data, double mode);
 ScrPromise *scr_fsp_mkdir(ScrStr *path);
 ScrPromise *scr_fsp_mkdir_mode(ScrStr *path, double mode);
 ScrPromise *scr_fsp_mkdir_recursive(ScrStr *path);
@@ -2110,6 +2139,24 @@ ScrPromise *scr_fsp_chmod(ScrStr *path, double mode);
 ScrPromise *scr_fsp_readdir(ScrStr *path);
 ScrPromise *scr_fsp_rm(ScrStr *path);
 ScrPromise *scr_fsp_stat(ScrStr *path);
+ScrPromise *scr_fsp_rename(ScrStr *oldpath, ScrStr *newpath);
+ScrPromise *scr_fsp_open(ScrStr *path, ScrStr *flags, double mode);
+ScrPromise *scr_file_handle_close_promise(ScrFileHandle *h);
+ScrPromise *scr_file_handle_read_file_promise(ScrFileHandle *h, ScrStr *encoding);
+ScrPromise *scr_file_handle_read_file_bytes_promise(ScrFileHandle *h, ScrStr *encoding);
+ScrPromise *scr_file_handle_write_file_promise(ScrFileHandle *h, ScrStr *data, ScrStr *encoding);
+ScrPromise *scr_file_handle_write_file_bytes_promise(ScrFileHandle *h, ScrBytes *data, ScrStr *encoding);
+ScrPromise *scr_file_handle_stat_promise(ScrFileHandle *h);
+
+/* fs.rename: the syscall is submitted to a native worker immediately and
+ * its error-first callback fires on a later event-loop turn through an
+ * emitted, program-shaped adapter. Both paths and the callback are borrowed
+ * at entry; the callback MOVES into the operation. err is borrowed and NULL
+ * on success. */
+typedef void (*ScrFsRenameFn)(ScrClosure *cb, ScrError *err);
+void scr_fs_rename_async(ScrStr *oldpath, ScrStr *newpath,
+                         ScrClosure *cb /*moves*/, ScrFsRenameFn fn);
+void scr_fs_rename_thunk0(ScrClosure *cb, ScrError *err);
 
 /* ── node:timers/promises (scr_async.c) ──────────────────────────────
  * The promisified pair: a PENDING void promise a one-shot heap timer /
@@ -2459,10 +2506,36 @@ ScrStr *scr_path_win32_to_namespaced_path(ScrStr *path);
  * (failure throws the path-less "EBADF: bad file descriptor, close").
  * The pair behind spawn's fd-stdio form. */
 double scr_fs_open(ScrStr *path, ScrStr *flags);
+ScrFileHandle *scr_file_handle_open(ScrStr *path, ScrStr *flags, double mode);
+ScrFileHandle *scr_file_handle_retain(ScrFileHandle *h);
+void scr_file_handle_release(ScrFileHandle *h);
+void *scr_file_handle_retain_v(void *p);
+void scr_file_handle_release_v(void *p);
+double scr_file_handle_fd(ScrFileHandle *h);
+void scr_file_handle_close(ScrFileHandle *h);
+double scr_file_handle_read(ScrFileHandle *h, ScrBytes *buf, double offset,
+                            double length, double position, bool length_default);
+double scr_file_handle_write_bytes(ScrFileHandle *h, ScrBytes *buf,
+                                   double offset, double length,
+                                   double position, bool length_default);
+double scr_file_handle_write_str(ScrFileHandle *h, ScrStr *data,
+                                 double position, ScrStr *encoding);
+ScrStr *scr_file_handle_read_file(ScrFileHandle *h);
+ScrBytes *scr_file_handle_read_file_bytes(ScrFileHandle *h);
+void scr_file_handle_write_file(ScrFileHandle *h, ScrStr *data);
+void scr_file_handle_write_file_bytes(ScrFileHandle *h, ScrBytes *data);
+ScrStats *scr_file_handle_stat(ScrFileHandle *h);
 /* position == -1 reads from and advances the descriptor's current offset;
  * nonnegative positions leave that offset unchanged (pread/ReadFile seam). */
 double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length,
                         double position);
+/* writeSync's classic Buffer window and utf8 string forms. position -1 (or
+ * any other non-safe/nonnegative-integer value) writes at and advances the
+ * current descriptor offset; safe nonnegative positions leave it unchanged. */
+double scr_fs_write_sync(double fd, ScrBytes *buf, double offset, double length,
+                         double position);
+double scr_fs_write_str_sync(double fd, ScrStr *data, double position,
+                             ScrStr *encoding);
 void scr_fs_close(double fd);
 
 /* ── WHATWG URL (scr_url.c) ──────────────────────────────────────────
@@ -3397,6 +3470,8 @@ typedef struct {
 } ScrJsonBuf;
 
 void scr_jb_init(ScrJsonBuf *b);
+/* Append one borrowed runtime string verbatim (no JSON quoting). */
+void scr_jb_put_str(ScrJsonBuf *b, const ScrStr *s);
 /* Push a container onto the circular-detection stack before serializing
  * its members. If `v` is already ON the stack, throws V8's exact
  * "Converting circular structure to JSON" TypeError (the --> starting at /
@@ -3712,6 +3787,10 @@ bool scr_immediate_has_ref(double handle);
  * teardown (they must never run yet must not leak). cb ownership moves
  * in. */
 void scr_next_tick(ScrClosure *cb);
+/* A successful process.stdout/stderr.write completion on that same queue.
+ * The callback and its program-shaped Error | null adapter both MOVE into
+ * the entry; the adapter is invoked with NULL (Node's success argument). */
+void scr_process_write_callback(ScrClosure *cb, ScrFsRenameFn fn);
 /* A raw C-hook entry on the SAME queue: the stream unit enqueues one
  * marker per deferred stream emission, so stream ticks and user
  * nextTicks run in true FIFO order (in Node they are the same queue).
@@ -4493,12 +4572,14 @@ double scr_date_get_minutes_utc(double ms);
 double scr_date_get_seconds_local(double ms);
 double scr_date_get_seconds_utc(double ms);
 
-/* ── bitwise operators (scr_lib.c) ────────────────────────────────────
+/* ── numeric coercion + bitwise operators ─────────────────────────────
  * JS-exact ToInt32/ToUint32 semantics: NaN/±Infinity → 0, truncation
  * toward zero, modular wrap into 32 bits; the operation runs in 32-bit
  * space (shift counts mask to 5 bits, `>>` is an arithmetic shift spelled
  * portably — no C UB/implementation-defined shifts) and the result
- * returns to f64: `>>>` as Uint32, everything else as Int32. */
+ * returns to f64: `>>>` as Uint32, everything else as Int32.
+ * scr_to_uint32 lives in scr_number.c; the bitwise operations in scr_lib.c. */
+uint32_t scr_to_uint32(double d);
 double scr_bit_and(double a, double b);
 double scr_bit_or(double a, double b);
 double scr_bit_xor(double a, double b);
@@ -4695,12 +4776,22 @@ void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset);
  * compiler fences other encodings). */
 ScrStr *scr_bytes_to_str(const ScrBytes *b, const ScrStr *enc);
 ScrStr *scr_bytes_to_str_range(const ScrBytes *b, const ScrStr *enc, double start, double end);
+/* Runtime-valued Buffer.toString encoding: aliases/case canonicalize;
+ * unknown names throw ERR_UNKNOWN_ENCODING. +1, or NULL when throwing. */
+ScrStr *scr_bytes_to_str_checked(const ScrBytes *b, const ScrStr *enc);
+ScrStr *scr_bytes_to_str_checked_range(const ScrBytes *b, const ScrStr *enc, double start, double end);
 
 /* WHATWG TextDecoder.decode over u8 bytes (utf-8, default options): the
  * same replacement decode as toString("utf8") with the leading BOM
  * stripped. Borrows; +1; never throws. */
 ScrStr *scr_text_decode(const ScrBytes *b);
 
+/* TextDecoder with a compile-time WHATWG legacy-encoding id. The frontend
+ * owns label canonicalization and emits only the ids understood by
+ * scr_bytes.c; keeping this separate from scr_text_decode means default
+ * UTF-8 users do not retain the legacy mapping tables. Borrows; +1. */
+ScrStr *scr_text_decode_legacy(const ScrBytes *b, double encoding);
+
 /* Buffer.from(string, enc): "utf8" copies the bytes; "hex" parses pairs
  * and stops at the first invalid/odd tail (Node-lenient); "base64" and
  * "base64url" decode the standard AND url-safe alphabets, skipping
@@ -4895,10 +4986,12 @@ ScrPromise *scr_fsp_read_file_bytes(ScrStr *path); /* +1 */
  * RangeError catchably (same check as scr_crypto_random_string). */
 ScrBytes *scr_crypto_random_bytes(double n); /* +1 */
 
-/* process.stdout/stderr.write(buf): the raw byte writes' Buffer overloads
- * (same streams and buffering as the string forms). Constantly true. */
-bool scr_process_stdout_write_bytes(const ScrBytes *b);
-bool scr_process_stderr_write_bytes(const ScrBytes *b);
+/* process.stdout/stderr.write(buf[, encoding]): the raw byte writes' Buffer
+ * overloads (same streams and buffering as the string forms). The encoding
+ * is evaluated by the caller and ignored here, as Node does for bytes.
+ * Constantly true. */
+bool scr_process_stdout_write_bytes(const ScrBytes *b, const ScrStr *encoding);
+bool scr_process_stderr_write_bytes(const ScrBytes *b, const ScrStr *encoding);
 
 /* The Node-shaped fs error thrower (scr_lib.c): formats "ENOENT: no such
  * file or directory, open 'x'" and throws it catchably. Shared with

package/src/scr_string.c

@@ -678,7 +678,9 @@ ScrStr *scr_str_trim_end(ScrStr *s) {
 static const struct { size_t rc; size_t len; size_t cap; char data[4]; }
     scr_lit_fffd = {SIZE_MAX, 3, 3, "\xEF\xBF\xBD"};
 
-/* split(separator) with a STRING separator, no limit (ECMA-262 22.1.3.23):
+/* split(separator, limit) with a STRING separator (ECMA-262 22.1.3.23):
+ * limit is ToUint32'd; zero returns [] and reaching the limit stops before
+ * any later separator probes. The no-limit wrapper supplies 2^32-1.
  * an empty separator splits into single UTF-16 code units ("".split("") is
  * [] — no probe matches nothing); a non-empty separator splits on every
  * byte-level occurrence (well-formed UTF-8 is self-synchronizing, so byte
@@ -688,8 +690,10 @@ static const struct { size_t rc; size_t len; size_t cap; char data[4]; }
  * yield the two lone surrogate halves, each half is U+FFFD here
  * (divergence 2 — the same substitution the island's boundary marshal
  * applied). Borrows both; returns a +1 string[]. */
-ScrArr *scr_str_split(ScrStr *s, ScrStr *sep) {
+ScrArr *scr_str_split_limit(ScrStr *s, ScrStr *sep, double limit_num) {
   ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
+  uint32_t limit = scr_to_uint32(limit_num);
+  if (limit == 0) return out;
   if (sep->len == 0) {
     size_t i = 0;
     while (i < s->len) {
@@ -697,10 +701,12 @@ ScrArr *scr_str_split(ScrStr *s, ScrStr *sep) {
       uint32_t cp = scr_utf8_decode(s->data + i, &adv);
       if (cp >= 0x10000) { /* two units in JS: both halves become U+FFFD */
         scr_arr_push_ref(out, scr_str_retain((ScrStr *)&scr_lit_fffd));
+        if (out->len == limit) return out;
         scr_arr_push_ref(out, scr_str_retain((ScrStr *)&scr_lit_fffd));
       } else {
         scr_arr_push_ref(out, scr_str_from_span(s->data + i, adv));
       }
+      if (out->len == limit) return out;
       i += adv;
     }
     return out;
@@ -712,12 +718,17 @@ ScrArr *scr_str_split(ScrStr *s, ScrStr *sep) {
     if (!found) break;
     size_t at = (size_t)(found - s->data);
     scr_arr_push_ref(out, scr_str_from_span(s->data + start, at - start));
+    if (out->len == limit) return out;
     start = at + sep->len;
   }
   scr_arr_push_ref(out, scr_str_from_span(s->data + start, s->len - start));
   return out;
 }
 
+ScrArr *scr_str_split(ScrStr *s, ScrStr *sep) {
+  return scr_str_split_limit(s, sep, 4294967295.0);
+}
+
 /* StringPad (ECMA-262 22.1.3.16/17): target length in UTF-16 units, the
  * filler built from whole repetitions of `fill` plus a truncated prefix.
  * A target at or below the length (or an empty fill) returns the receiver