@scriptc/runtime 0.0.22 → 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

@@ -197,9 +197,15 @@ void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len);
  * collection walks the buffer (markGray: trial-decrement internal edges;
  * scan: restore externally-referenced subgraphs; collectWhite: free the
  * dead cycle members, releasing only edges that LEAVE the white set).
- * Collection points: program exit (before the RC audit), event-loop
- * quiescence, and a root-buffer threshold (SCR_CYCLE_THRESHOLD env var,
- * default 256). There is no concurrent or incremental collection.
+ * It is GENERATIONAL: each header carries a generation, a pass names the
+ * oldest one it will walk, and objects that survive a pass are promoted out
+ * of the nursery so later nursery passes never re-walk them. That is what
+ * keeps a pass proportional to recent allocation rather than to the whole
+ * live heap — see the generation note in scr_cycle.c for the soundness
+ * argument and the schedule. Collection points: program exit (before the RC
+ * audit), event-loop quiescence, and the per-generation triggers.
+ * SCR_CYCLE_THRESHOLD pins the nursery trigger to a fixed candidate count.
+ * There is no concurrent or incremental collection.
  *
  * Contract for trace/teardown pairs (the compiler emits them for shapes,
  * the runtime owns its own): trace(obj) visits exactly the strong
@@ -214,16 +220,44 @@ typedef void (*ScrTraceVisit)(void *child, void *ctx);
 typedef void (*ScrTraceFn)(void *obj, ScrTraceVisit visit, void *ctx);
 typedef void (*ScrCycFreeFn)(void *obj);
 
-enum { SCR_CYC_BLACK = 0, SCR_CYC_PURPLE = 1, SCR_CYC_GRAY = 2, SCR_CYC_WHITE = 3 };
+/* DOOMED is WHITE that collectWhite has already gathered: it stops the
+ * gather recursing twice, and distinguishes "about to be freed" from a
+ * survivor for the re-buffering step (see scr_cycle.c). */
+enum {
+  SCR_CYC_BLACK = 0, SCR_CYC_PURPLE = 1, SCR_CYC_GRAY = 2, SCR_CYC_WHITE = 3,
+  SCR_CYC_DOOMED = 4
+};
+
+/* Generations. A candidate sits in the buffer named by its own `gen`, and a
+ * pass walks only objects at or below the generation it collects. */
+enum { SCR_CYC_NURSERY = 0, SCR_CYC_MATURE = 1, SCR_CYC_NGENS = 2 };
 
 typedef struct ScrCycHdr {
   ScrTraceFn trace;
   ScrCycFreeFn free_fn;
   uint32_t color;    /* SCR_CYC_* */
-  uint32_t buffered; /* 1 = sitting in the candidate-root buffer */
+  uint16_t buffered; /* 1 = sitting in its generation's candidate buffer */
+  uint16_t gen;      /* SCR_CYC_NURSERY..SCR_CYC_MATURE (the walk filter) */
   size_t buf_index;  /* position there (O(1) removal when rc hits 0) */
 } ScrCycHdr;
 
+/* This layout is an ABI, not an implementation detail: the LLVM backend
+ * inlines scr_cyc_mark_live as a raw `store i32 0` at obj-16 (it is a
+ * static inline here, so there is no symbol to call) and reaches the header
+ * at obj-32. Three sites emit it — llvm/shapes.ts, llvm/classes.ts,
+ * llvm/emitter.ts. Nothing but `color` may share those four bytes: a field
+ * placed in them is silently zeroed by every retain, which is invisible to
+ * the type system and to the C compiler. Hence the assertions. */
+_Static_assert(sizeof(ScrCycHdr) == 32, "LLVM backend reads the header at obj-32");
+_Static_assert(offsetof(ScrCycHdr, color) == 16,
+               "LLVM backend's inlined mark-live stores i32 0 at obj-16");
+_Static_assert(sizeof(((ScrCycHdr *)0)->color) == 4,
+               "mark-live is an i32 store: color must own all four bytes");
+_Static_assert(SCR_CYC_BLACK == 0,
+               "the emitted mark-live stores the LITERAL 0, not the enumerator "
+               "— reordering the colors would make every compiled retain write "
+               "the wrong one");
+
 static inline ScrCycHdr *scr_cyc_hdr(void *obj) { return (ScrCycHdr *)obj - 1; }
 
 /* Zeroed allocation with a cycle header in front; returns the OBJECT
@@ -243,9 +277,18 @@ static inline void scr_cyc_mark_live(void *obj) {
   scr_cyc_hdr(obj)->color = SCR_CYC_BLACK;
 }
 
-/* Run one full trial-deletion pass over the buffered candidates now. */
+/* Full sweep: trial-deletion passes over EVERY generation, to a fixpoint.
+ * This is the exit / session-reset entry point (the RC audit runs straight
+ * after and wants nothing reclaimable left), and it costs a walk of the
+ * live heap — do not put it on a per-turn path. */
 void scr_collect_cycles(void);
 
+/* One pass on the normal generational schedule, for callers that reach a
+ * natural collection point rather than a threshold (the event loop between
+ * turns). Cheap: usually a nursery pass; a waiting mature backlog ages into
+ * a bounded full pass so sparse roots cannot float forever. */
+void scr_cyc_collect_scheduled(void);
+
 /* ── class hierarchies (single inheritance) ───────────────────────────
  * Classes in an `extends` hierarchy share a two-word object prefix: the
  * usual `size_t rc`, then a pointer to the class's static vtable (emitted
@@ -569,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
@@ -677,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
@@ -837,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);
@@ -940,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);
@@ -2004,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);
@@ -2036,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 */
@@ -2048,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
@@ -2058,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);
@@ -2067,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 /
@@ -2416,7 +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);
-double scr_fs_read_sync(double fd, ScrBytes *buf, double offset, double length);
+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) ──────────────────────────────────────────
@@ -2714,6 +2833,7 @@ typedef enum {
   SCR_DYNH_FETCH_RESPONSE, /* native static-fetch Response */
   SCR_DYNH_FETCH_HEADERS, /* native static-fetch response Headers */
   SCR_DYNH_EVENT,          /* native static-fetch abort Event */
+  SCR_DYNH_ABORT_CONTROLLER, /* native static-fetch AbortController */
   SCR_DYNH_COUNT,
 } ScrDynHandleTag;
 
@@ -2980,6 +3100,7 @@ ScrStr *scr_dyn_string_coerce(const ScrDyn *d);
  * called, their throws propagating) — the WHATWG USVString conversions.
  * Borrows; +1 or NULL with the exception pending. */
 ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d);
+bool scr_dyn_number_coerce_js(const ScrDyn *d, double *out);
 
 /* `d instanceof TypeError` (and the other builtin error classes) on a
  * checked-dynamic value: the from_error cache resolves the dyn encoding
@@ -3349,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 /
@@ -3664,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).
@@ -3907,9 +4034,11 @@ long scr_promise_live_count(void);
  * emitted main calls scr_fetch_install in either form. */
 void scr_fetch_install(void);
 ScrPromise *scr_fetch_static(ScrStr *url, ScrDyn *init); /* +1 promise<Response handle> */
+ScrDyn *scr_fetch_response_new(ScrDyn *body, ScrDyn *init); /* borrowed args; +1 Response handle or NULL pending */
 ScrPromise *scr_fetch_response_json(ScrDyn *response); /* +1 promise<dyn> */
 ScrPromise *scr_fetch_response_text(ScrDyn *response); /* +1 promise<dyn> */
 ScrPromise *scr_fetch_response_bytes(ScrDyn *response); /* +1 promise<dyn> */
+ScrDyn *scr_fetch_abort_controller_new(void); /* +1 AbortController handle */
 /* Borrowed number; +1 AbortSignal handle or NULL pending. */
 ScrDyn *scr_fetch_abort_timeout(ScrDyn *delay);
 ScrDyn *scr_fetch_abort_now(ScrDyn *reason); /* borrowed reason; +1 handle */
@@ -4398,10 +4527,13 @@ bool scr_num_same_value(double a, double b);
  * en-US is the one embedded locale. Result +1; never throws. */
 ScrStr *scr_intl_num_format_en_us(double x);
 
-/* ── Date, the composed slice (scr_lib.c) ─────────────────────────────
- * Date values have no representation; the runtime surface is exactly
- * Date.now() and toISOString over a millisecond time value. */
+/* ── Date, the read-only value slice (scr_lib.c) ──────────────────────
+ * A Date value is its TimeClip'd epoch-millisecond scalar. Identity and
+ * mutation are frontend-fenced; construction, storage, getters, and ISO
+ * formatting are exact over this representation. */
 double scr_date_now(void); /* integer ms since epoch, like Node */
+double scr_date_new_ms(double ms); /* TimeClip (NaN when invalid) */
+double scr_date_get_time(double ms);
 /* Node's exact ISO 8601 UTC format (expanded ±YYYYYY years outside
  * 0–9999). THROWS Node's "Invalid time value" RangeError on NaN or
  * |ms| > 8.64e15 and returns NULL; +1 otherwise. */
@@ -4415,13 +4547,39 @@ double scr_date_parse_get_time(ScrStr *s);
  * and years past V8's ±1e6 MakeDay bound. Never throws. */
 double scr_date_utc(double y, double mo, double d,
                     double h, double mi, double s, double ms);
-
-/* ── bitwise operators (scr_lib.c) ────────────────────────────────────
+double scr_date_get_full_year(double ms, bool utc);
+double scr_date_get_month(double ms, bool utc);
+double scr_date_get_date(double ms, bool utc);
+double scr_date_get_day(double ms, bool utc);
+double scr_date_get_hours(double ms, bool utc);
+double scr_date_get_minutes(double ms, bool utc);
+double scr_date_get_seconds(double ms, bool utc);
+double scr_date_get_milliseconds(double ms);
+double scr_date_get_timezone_offset(double ms);
+/* One-argument ABI wrappers used by the LLVM lib-call table. */
+double scr_date_get_full_year_local(double ms);
+double scr_date_get_full_year_utc(double ms);
+double scr_date_get_month_local(double ms);
+double scr_date_get_month_utc(double ms);
+double scr_date_get_date_local(double ms);
+double scr_date_get_date_utc(double ms);
+double scr_date_get_day_local(double ms);
+double scr_date_get_day_utc(double ms);
+double scr_date_get_hours_local(double ms);
+double scr_date_get_hours_utc(double ms);
+double scr_date_get_minutes_local(double ms);
+double scr_date_get_minutes_utc(double ms);
+double scr_date_get_seconds_local(double ms);
+double scr_date_get_seconds_utc(double ms);
+
+/* ── 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);
@@ -4618,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
@@ -4818,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