@scriptc/runtime 0.0.10 → 0.0.11

package/package.json

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

package/src/scr_async.c

@@ -591,7 +591,8 @@ ScrArr *scr_active_resources(void) {
  * left queued on the uncaught paths) never run — the teardown releases
  * them, like Node dropping the queue at exit. */
 typedef struct ScrNtick {
-  ScrClosure *cb; /* owned */
+  ScrClosure *cb;    /* owned; NULL for a raw C-hook entry */
+  void (*raw)(void); /* the hook when cb == NULL (stream tick markers) */
   struct ScrNtick *next;
 } ScrNtick;
 
@@ -612,11 +613,25 @@ void scr_next_tick(ScrClosure *cb /*moves*/) {
   scr_nt_tail = t;
 }
 
+/* A RAW C-hook tick: the stream unit enqueues one marker per deferred
+ * stream emission so those emissions interleave with user nextTicks in
+ * true FIFO order — in Node they ARE nextTicks (resume_, emitReadable_,
+ * endReadableNT, ...). The hook dispatches exactly one stream tick;
+ * teardown just drops markers (the stream queue owns its entries). */
+void scr_next_tick_raw(void (*fn)(void)) {
+  ScrNtick *t = calloc(1, sizeof *t);
+  if (!t) scr_oom();
+  t->raw = fn;
+  if (scr_nt_tail) scr_nt_tail->next = t;
+  else scr_nt_head = t;
+  scr_nt_tail = t;
+}
+
 void scr_nticks_teardown(void) {
   while (scr_nt_head != NULL) {
     ScrNtick *t = scr_nt_head;
     scr_nt_head = t->next;
-    scr_closure_release(t->cb);
+    if (t->cb) scr_closure_release(t->cb);
     free(t);
   }
   scr_nt_tail = NULL;
@@ -1677,9 +1692,14 @@ void scr_loop_run(void) {
         scr_nt_head = t->next;
         if (scr_nt_head == NULL) scr_nt_tail = NULL;
         ScrClosure *cb = t->cb;
+        void (*raw)(void) = t->raw;
         free(t);
-        ((void (*)(ScrClosure *))cb->fn)(cb);
-        scr_closure_release(cb);
+        if (cb) {
+          ((void (*)(ScrClosure *))cb->fn)(cb);
+          scr_closure_release(cb);
+        } else {
+          raw(); /* one stream tick, FIFO with the user ticks around it */
+        }
         if (scr_exc_pending()) return;
       }
     }

package/src/scr_bytes.c

@@ -1,6 +1,8 @@
 /* Typed arrays / Buffer: ONE runtime representation (ScrBytes — see the
- * header contract). Element buffers own their storage outright: no views,
- * no byteOffset, slice/subarray both copy. Coercions are JS-exact
+ * header contract). An ScrBytes either OWNS its storage or is a VIEW into
+ * an owner's (backing set, chain depth exactly 1): DataView, subarray(),
+ * and Buffer's slice() all alias JS-exactly; only the plain typed arrays'
+ * slice() copies. Coercions are JS-exact
  * (ToUint8/ToUint32 modular truncation, double→float rounding); the
  * encoding conversions (utf8 with WHATWG replacement, hex, base64) match
  * Node byte-for-byte — the differential corpus holds them to it. */
@@ -164,7 +166,7 @@ void scr_bytes_set(ScrBytes *b, double i, double v) {
   }
 }
 
-/* ── slice / subarray (both COPY) ──────────────────────────────────────── */
+/* ── slice (copy) / subarray (view) ────────────────────────────────────── */
 
 /* Relative index: ToIntegerOrInfinity, negatives from the end, clamped. */
 static size_t scr_bytes_rel_index(double i, size_t len) {
@@ -186,6 +188,41 @@ ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end) {
   return out;
 }
 
+/* TypedArray.prototype.fill on non-u8 receivers: per-ELEMENT fill with
+ * the element write's JS-exact coercion (ToUint32/ToInt32 wrap, f32
+ * rounding), slice-clamped relative indices; answers the receiver +1
+ * (chaining). Never throws — Buffer's throwing fill family is separate. */
+ScrBytes *scr_bytes_fill_elem(ScrBytes *b, double v, double start, double end) {
+  size_t s = scr_bytes_rel_index(start, b->len);
+  size_t e = scr_bytes_rel_index(end, b->len);
+  for (size_t i = s; i < e; i++) scr_bytes_set(b, (double)i, v);
+  return scr_bytes_retain(b);
+}
+
+/* subarray(start, end): a same-elem VIEW over the receiver's storage —
+ * TypedArray.prototype.subarray and Buffer's slice()/subarray() all alias
+ * in JS (mutations are visible both ways; buffer-swap through a slice is
+ * the canonical Node use). Chain depth stays exactly 1: a subarray of a
+ * view retains the OWNER, offsets composed here (the DataView rule).
+ * Relative indices clamp like slice; never throws. */
+ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end) {
+  size_t s = scr_bytes_rel_index(start, b->len);
+  size_t e = scr_bytes_rel_index(end, b->len);
+  size_t count = e > s ? e - s : 0;
+  ScrBytes *owner = b->backing ? b->backing : b;
+  ScrBytes *v = malloc(sizeof(ScrBytes));
+  if (!v) scr_bytes_oom();
+  v->rc = 1;
+  v->len = count;
+  v->elem = b->elem;
+  v->data = b->data + s * scr_bytes_elem_size(b->elem);
+  v->backing = scr_bytes_retain(owner);
+#ifdef SCR_RC_AUDIT
+  scr_live_bytes++;
+#endif
+  return v;
+}
+
 void scr_bytes_set_from(ScrBytes *dst, const ScrBytes *src, double offset) {
   double t = (offset != offset) ? 0 : trunc(offset);
   if (!(t >= 0) || (double)src->len + t > (double)dst->len) {

package/src/scr_events_emitter.c

@@ -85,6 +85,12 @@ typedef struct ScrEeBucket {
 struct ScrEeReg {
   ScrEeBucket *head; /* singly linked, first-registration order */
   double max;        /* -1 = unset (follows the default), 0 = unlimited */
+  /* Node's kShapeMode: set when names were PRE-CREATED (the stream
+   * constructors). In shape mode removeListener KEEPS an emptied name's
+   * rank (Node writes events[type] = undefined instead of deleting) —
+   * only removeAllListeners deletes: the named form drops the one key,
+   * the no-argument wipe resets everything and leaves shape mode. */
+  bool shape;
 };
 
 /* The vtable of BARE `new EventEmitter()` instances; the emitted main()
@@ -145,6 +151,21 @@ static ScrEeBucket *scr_ee_bucket_ensure(ScrEeReg *reg, ScrStr *name) {
   return b;
 }
 
+/* Reserve a name's first-registration RANK without any listener: Node's
+ * stream classes pre-create their known _events keys (a V8 shape
+ * optimization eventNames() order observes — 'error'/'data'/... list
+ * before user events added earlier). An empty bucket is ABSENT for every
+ * read (n == 0 everywhere); the first add fills it in place, and a bucket
+ * emptied by removal still drops — Node deleting the key. */
+void scr_emitter_reserve(ScrEmitter *em, const char *name) {
+  ScrEeReg *reg = scr_ee_reg_ensure(em);
+  reg->shape = true;
+  if (scr_ee_bucket_find(reg, name, strlen(name))) return;
+  ScrStr *n = scr_str_new(name, strlen(name));
+  scr_ee_bucket_ensure(reg, n);
+  scr_str_release(n);
+}
+
 /* Drops an emptied bucket from the list (Node deletes the _events key; a
  * later add re-appends at the end). */
 static void scr_ee_bucket_drop(ScrEeReg *reg, ScrEeBucket *b) {
@@ -402,13 +423,14 @@ void scr_ee_inv_fixed4(ScrClosure *cb, va_list ap) {
 
 /* Removes one entry (by index) from a bucket's live list and fires the
  * 'removeListener' meta event AFTER the removal, Node's order. Drops the
- * bucket when emptied. */
+ * bucket when emptied — except in shape mode, where the emptied name
+ * keeps its rank (Node's events[type] = undefined). */
 static void scr_ee_remove_at(ScrEmitter *em, ScrEeBucket *b, size_t i) {
   ScrEeEntry *e = b->ls[i];
   memmove(b->ls + i, b->ls + i + 1, (b->n - i - 1) * sizeof *b->ls);
   b->n--;
   ScrStr *name = scr_str_retain(b->name);
-  if (b->n == 0) scr_ee_bucket_drop(em->reg, b);
+  if (b->n == 0 && !em->reg->shape) scr_ee_bucket_drop(em->reg, b);
   scr_ee_entry_unref(e);
   scr_ee_emit_meta(em, "removeListener", name);
   scr_str_release(name);
@@ -456,6 +478,13 @@ void scr_emitter_check_listener(const ScrDyn *cb) {
  * firing the meta event — and the whole-emitter form does every other
  * event first (bucket order), 'removeListener' itself LAST. Returns em +1. */
 static void scr_ee_remove_all_named(ScrEmitter *em, ScrEeBucket *b, bool meta) {
+  if (b->n == 0) {
+    /* An empty rank-holding bucket reaches here only from the WIPE scan
+     * (the named form skips undefined keys — Node no-ops and the rank
+     * stays): drop it, the wipe resets _events wholesale. */
+    scr_ee_bucket_drop(em->reg, b);
+    return;
+  }
   if (!meta) {
     for (size_t i = 0; i < b->n; i++) scr_ee_entry_unref(b->ls[i]);
     b->n = 0;
@@ -497,7 +526,26 @@ ScrEmitter *scr_emitter_remove_all(ScrEmitter *em, ScrStr *name, bool all) {
   bool meta = scr_ee_has(reg, "removeListener");
   if (!all) {
     ScrEeBucket *b = scr_ee_bucket_find(reg, name->data, name->len);
-    if (b) scr_ee_remove_all_named(em, b, meta);
+    /* A rank-holding empty bucket is Node's `events[type] === undefined`:
+     * the named form no-ops there (the rank survives). A POPULATED name
+     * deletes its key even in shape mode — but through the meta path each
+     * listener leaves via removeListener, whose shape rule KEEPS the
+     * emptied rank (Node's exact split). */
+    if (b && b->n > 0) {
+      scr_ee_remove_all_named(em, b, meta);
+      if (!meta) {
+        /* Node's non-meta named branch: the count hitting zero replaces
+         * _events wholesale — every rank (pre-created included) goes,
+         * though kShapeMode itself stays set (Node's exact quirk). */
+        bool any_live = false;
+        for (ScrEeBucket *w = reg->head; w; w = w->next) {
+          if (w->n > 0) { any_live = true; break; }
+        }
+        if (!any_live) {
+          while (reg->head) scr_ee_bucket_drop(reg, reg->head);
+        }
+      }
+    }
     return scr_emitter_retain(em);
   }
   /* Every event except 'removeListener' first, in bucket order; then
@@ -515,6 +563,10 @@ ScrEmitter *scr_emitter_remove_all(ScrEmitter *em, ScrStr *name, bool all) {
   }
   ScrEeBucket *rl = scr_ee_bucket_find(reg, "removeListener", 14);
   if (rl) scr_ee_remove_all_named(em, rl, meta);
+  /* The wipe replaces _events wholesale in Node — pre-created ranks are
+   * gone and the emitter leaves shape mode. */
+  while (reg->head) scr_ee_bucket_drop(reg, reg->head);
+  reg->shape = false;
   return scr_emitter_retain(em);
 }
 
@@ -633,12 +685,13 @@ double scr_emitter_listener_count_fn(ScrEmitter *em, ScrStr *name, ScrClosure *f
 }
 
 /* eventNames(): +1 string[] of the bucket names in first-registration
- * order (exactly Node's _events key order). */
+ * order (exactly Node's _events key order). Reserved-but-empty buckets
+ * (the stream pre-created keys) are invisible until a listener lands. */
 ScrArr *scr_emitter_event_names(ScrEmitter *em) {
   ScrArr *out = scr_arr_new(SCR_ELEM_STR, 0);
   if (em->reg) {
     for (ScrEeBucket *b = em->reg->head; b; b = b->next) {
-      scr_arr_push_ref(out, scr_str_retain(b->name));
+      if (b->n > 0) scr_arr_push_ref(out, scr_str_retain(b->name));
     }
   }
   return out;

package/src/scr_library.c

@@ -251,6 +251,21 @@ ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len, const char *trap_ms
   return b;
 }
 
+double scr_library_i64_in(int64_t v, const char *trap_msg) {
+  /* The inbound declared-integer edge (ask 4): only |v| <= 2^53-1 rides
+   * f64 exactly; past it, (double)v silently rounds — a coercion the
+   * author never wrote, so the wrapper funnels the host-contract
+   * violation instead (same story as an impossible bytes length; the
+   * message is the compiler-assembled structured trap-teaching form). */
+  if (v > 9007199254740991LL || v < -9007199254740991LL) scr_trap(trap_msg);
+  return (double)v;
+}
+
+double scr_library_u64_in(uint64_t v, const char *trap_msg) {
+  if (v > 9007199254740991ULL) scr_trap(trap_msg);
+  return (double)v;
+}
+
 void scr_library_str_out(ScrStr *s, const uint8_t **out, size_t *out_len) {
   scr_library_arena_keep(s, true);
   *out = (const uint8_t *)s->data; /* NUL-terminated after len (ScrStr layout) */

package/src/scr_regex.c

@@ -484,13 +484,20 @@ ScrArr *scr_regex_match_all_into(ScrStr *s, ScrRegex *re, ScrArr *indices) {
  * replacements are frontend-fenced): $$, $&, $` and $', $1..$99 (two digits
  * win when in range — the refined ES2019 rule quickjs implements), with
  * out-of-range references left literal and unmatched groups substituting
- * empty. $<name> stays literal: named capture groups are frontend-fenced,
- * so namedCaptures is always undefined here (the spec's literal case).
- * The template is scanned byte-wise: every '$' directive is ASCII, and
- * UTF-8 continuation bytes can never alias it. */
+ * empty. $<name> resolves against the pattern's named capture groups
+ * (lre_get_groupnames — one NUL-terminated name per capture, "" for
+ * unnamed): the first PARTICIPATING capture with that name substitutes
+ * (ES2025 duplicates live in distinct alternatives, so at most one
+ * participates); a nonexistent or nonparticipating name substitutes
+ * empty (the spec's Get→undefined→"" path, Node-exact). When the pattern
+ * has NO named groups, namedCaptures is undefined and '$<' stays literal
+ * — also Node's unterminated-'$<name' answer either way. The template is
+ * scanned byte-wise: every '$' directive is ASCII, and UTF-8 continuation
+ * bytes can never alias it. */
 static void scr_put_substitution(ScrJsonBuf *b, const uint16_t *u, int len,
                                   int start, int end, uint8_t **capture,
-                                  int capture_count, const ScrStr *rep) {
+                                  int capture_count, const char *groupnames,
+                                  const ScrStr *rep) {
   const uint8_t *ubase = (const uint8_t *)u;
   size_t i = 0;
   while (i < rep->len) {
@@ -534,6 +541,31 @@ static void scr_put_substitution(ScrJsonBuf *b, const uint16_t *u, int len,
         scr_jb_putc(b, '$');
         i++;
       }
+    } else if (c1 == '<' && groupnames != NULL) {
+      /* $<name>: scan for '>'; absent, the '$' is literal (the rest
+       * re-scans verbatim — GetSubstitution's not-found answer). */
+      size_t gt = i + 2;
+      while (gt < rep->len && rep->data[gt] != '>') gt++;
+      if (gt >= rep->len) {
+        scr_jb_putc(b, '$');
+        i++;
+        continue;
+      }
+      const char *name = rep->data + i + 2;
+      size_t name_len = gt - (i + 2);
+      const char *p = groupnames; /* capture_count-1 entries: name NUL scope */
+      for (int k = 1; k < capture_count; k++) {
+        size_t glen = strlen(p);
+        if (glen == name_len && memcmp(p, name, name_len) == 0) {
+          const uint8_t *cs = capture[2 * k], *ce = capture[2 * k + 1];
+          if (cs && ce) {
+            scr_jb_put_utf16(b, u, (int)((cs - ubase) >> 1), (int)((ce - ubase) >> 1));
+            break; /* at most one duplicate participates */
+          }
+        }
+        p += glen + LRE_GROUP_NAME_TRAILER_LEN;
+      }
+      i = gt + 1;
     } else {
       scr_jb_putc(b, '$');
       i++;
@@ -550,6 +582,7 @@ static ScrStr *scr_replace_impl(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   bool global = (re_flags & LRE_FLAG_GLOBAL) != 0;
   bool unicode = (re_flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
   int capture_count = lre_get_capture_count(bc);
+  const char *groupnames = lre_get_groupnames(bc);
   int len;
   uint16_t *u = scr_to_utf16(s, &len);
   uint8_t **capture = scr_capture_alloc(bc);
@@ -562,7 +595,7 @@ static ScrStr *scr_replace_impl(ScrStr *s, ScrRegex *re, ScrStr *rep) {
     int start = (int)((capture[0] - ubase) >> 1);
     int end = (int)((capture[1] - ubase) >> 1);
     scr_jb_put_utf16(&b, u, next, start);
-    scr_put_substitution(&b, u, len, start, end, capture, capture_count, rep);
+    scr_put_substitution(&b, u, len, start, end, capture, capture_count, groupnames, rep);
     next = end;
     if (!global) break;
     pos = end == start ? scr_advance(u, len, end, unicode) : end;

package/src/scr_runtime.h

@@ -163,6 +163,12 @@ ScrStr *scr_library_str_in(const uint8_t *p, size_t len);   /* +1 */
  * (structured trap-teaching bytes naming this entry's symbol), delivered
  * through the funnel when len falls outside the marshalling class. */
 ScrBytes *scr_library_bytes_in(const uint8_t *p, size_t len, const char *trap_msg); /* +1, u8 */
+/* The inbound declared-integer edge (ask 4's i64/u64 parameter classes):
+ * exact conversion for |v| <= 2^53-1, the host-contract trap (same
+ * assembled SC4012 message shape as the bytes trap) past it — silent
+ * rounding is a coercion the author never wrote. */
+double scr_library_i64_in(int64_t v, const char *trap_msg);
+double scr_library_u64_in(uint64_t v, const char *trap_msg);
 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);
 
@@ -1362,6 +1368,10 @@ bool scr_emitter_emit_error(ScrEmitter *em, ScrStr *name, ScrError *err);
 double scr_emitter_listener_count(ScrEmitter *em, ScrStr *name);
 double scr_emitter_listener_count_fn(ScrEmitter *em, ScrStr *name, ScrClosure *fn);
 ScrArr *scr_emitter_event_names(ScrEmitter *em);          /* +1 string[] */
+/* Pre-create a name's eventNames() rank with no listener (Node's stream
+ * classes pre-create their known _events keys; empty = absent for every
+ * other read). The stream constructors call this. */
+void scr_emitter_reserve(ScrEmitter *em, const char *name);
 ScrArr *scr_emitter_listeners(ScrEmitter *em, ScrStr *name); /* +1 closures */
 ScrEmitter *scr_emitter_set_max(ScrEmitter *em, double n);   /* returns em +1 */
 double scr_emitter_get_max(ScrEmitter *em);
@@ -1562,6 +1572,13 @@ ScrDyn *scr_stream_done_dyn_l(ScrClosure *clo, ScrDyn *const *args, size_t argc)
  * utf8, Node's decodeStrings default); push answers the below-hwm bool. */
 bool scr_stream_push(ScrStream *s, ScrBytes *chunk);
 bool scr_stream_push_str(ScrStream *s, ScrStr *str);
+/* push(chunk, enc): the per-call literal encoding (canonical); overrides
+ * the stream's defaultEncoding. Borrows both. */
+bool scr_stream_push_str_enc(ScrStream *s, ScrStr *str, ScrStr *enc);
+/* The defaultEncoding option's push side: how push(string) decodes chunks
+ * (Buffer.from(chunk, enc)). Canonical literal, never "utf8". Receiver
+ * answers +1 (the setEncoding chaining shape). */
+ScrStream *scr_stream_set_push_encoding(ScrStream *s, ScrStr *enc);
 bool scr_stream_push_null(ScrStream *s);
 void scr_stream_unshift(ScrStream *s, ScrBytes *chunk);
 void scr_stream_unshift_str(ScrStream *s, ScrStr *str);
@@ -1591,6 +1608,18 @@ ScrPromise *scr_stream_next_chunk_dyn(ScrStream *s);
  * Streams borrowed; +1 promises. */
 ScrPromise *scr_sp_finished(ScrStream *s);
 ScrPromise *scr_sp_pipeline(double n, ScrStream **streams);
+/* node:stream/consumers — the promise consumers over the readable
+ * machinery: accumulate every chunk (string chunks as their utf8 bytes)
+ * and settle at the terminal point (right after 'close', the eos timing
+ * Node's consumers share) — text answers the utf8 decode, json parses
+ * the text (malformed input rejects with the parse's SyntaxError; the
+ * result is a +1 DOM tree), buffer the concatenated bytes. Stream
+ * errors reject; an early close rejects ERR_STREAM_PREMATURE_CLOSE; a
+ * stream with no readable side rejects Node's async-iterable TypeError.
+ * Streams borrowed; +1 promises. */
+ScrPromise *scr_sc_text(ScrStream *s);
+ScrPromise *scr_sc_json(ScrStream *s);
+ScrPromise *scr_sc_buffer(ScrStream *s);
 /* Readable.from(array): +1 fully-seeded object-entry stream (one WHOLE
  * chunk per element — strings or Buffers per the flag; hwm 1, already
  * EOF'd). Borrows arr. */
@@ -3487,6 +3516,11 @@ 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 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).
+ * Teardown drops markers without running them. */
+void scr_next_tick_raw(void (*fn)(void));
 void scr_nticks_teardown(void);
 /* ── the events unit (scr_events.c — OPTIONAL, link-gated) ────────────
  * Process signal/exit events and the piped-stdin surface. The unit links
@@ -4207,13 +4241,15 @@ double scr_bit_not(double a);
 /* ── typed arrays / Buffer (scr_bytes.c) ──────────────────────────────
  * ONE runtime representation for Uint8Array/Uint32Array/Float32Array,
  * Node's Buffer (a Uint8Array subclass), and DataView: a refcounted,
- * MUTABLE, fixed-length element buffer. Typed arrays OWN their storage
- * (backing == NULL) — subarray()/slice() both COPY (slice matches JS;
- * subarray's sharing is a documented divergence, SEMANTICS.md) — so a
- * typed array never aliases another and its byteOffset is always 0. The
- * ONE view kind is DataView (scr_dataview_new): a u8-elem ScrBytes whose
- * `data` points INTO an owner's storage and whose `backing` retains that
- * owner, so reads/writes through the view alias the source JS-exactly.
+ * MUTABLE, fixed-length element buffer. An ScrBytes either OWNS its
+ * storage (backing == NULL, byteOffset 0) or is a VIEW: its `data` points
+ * INTO an owner's storage and its `backing` retains that owner (chain
+ * depth is always exactly 1 — views over views resolve to the owner at
+ * construction), so reads/writes through the view alias the source
+ * JS-exactly. Views come from DataView (scr_dataview_new) and from
+ * subarray()/Buffer-slice() (scr_bytes_subarray — Buffer's slice is
+ * subarray's deprecated alias in Node); only the plain typed arrays'
+ * slice() copies (scr_bytes_slice, matching JS).
  * Elements are scalars only and the backing edge is acyclic by
  * construction (owners point at nothing): never part of a cycle, no
  * trace. Element reads widen to double; writes coerce JS-exactly (ToUint8
@@ -4236,10 +4272,10 @@ typedef struct ScrBytes {
   size_t len; /* ELEMENT count, fixed at construction */
   ScrBytesElem elem;
   uint8_t *data; /* len * elem_size bytes; owned unless backing is set */
-  /* NULL for owners (every typed array/Buffer). A DataView sets this to
-   * the retained OWNER it aliases (chain depth is always exactly 1: views
-   * over a view's .buffer resolve to the owner at construction) and its
-   * `data` points into backing->data — released, never freed. */
+  /* NULL for owners. A view (DataView, subarray, Buffer-slice) sets this
+   * to the retained OWNER it aliases (chain depth is always exactly 1:
+   * views over views resolve to the owner at construction) and its `data`
+   * points into backing->data — released, never freed. */
   struct ScrBytes *backing;
 } ScrBytes;
 
@@ -4344,10 +4380,21 @@ void scr_bytes_set(ScrBytes *b, double i, double v);
 
 /* TypedArray.prototype.slice(start, end): relative indices clamp like
  * string/array slice (ToIntegerOrInfinity, negatives from the end); the
- * result is a fresh same-kind copy. subarray() lowers here too — a COPY,
- * the documented divergence. Never throws. */
+ * result is a fresh same-kind copy. Never throws. */
 ScrBytes *scr_bytes_slice(const ScrBytes *b, double start, double end); /* +1 */
 
+/* TypedArray.prototype.fill on non-u8 receivers: per-element fill with
+ * the element write's coercion, slice-clamped relative indices; answers
+ * the receiver +1 (chaining). Never throws. */
+ScrBytes *scr_bytes_fill_elem(ScrBytes *b, double v, double start, double end); /* +1 */
+
+/* TypedArray.prototype.subarray(start, end) — and Buffer's slice(), its
+ * deprecated alias: a same-elem VIEW aliasing the receiver's storage
+ * (mutations visible both ways, JS-exactly). The view retains the OWNER
+ * (chain depth exactly 1, the DataView rule) and its byteOffset composes.
+ * Same index clamping as slice; never throws. */
+ScrBytes *scr_bytes_subarray(ScrBytes *b, double start, double end); /* +1 */
+
 /* dst.set(src, offset): same-kind bulk copy (memmove — dst may be src).
  * offset goes through ToIntegerOrInfinity; a negative offset or
  * src.len + offset > dst.len THROWS Node's "offset is out of bounds"

package/src/scr_stream.c

@@ -13,11 +13,12 @@
  * nothing.
  *
  * EVENT TIMING. Node schedules most stream emissions on process.nextTick;
- * here those deferrals ride a FIFO tick queue drained at the top of every
- * loop turn (scr_loop_set_stream — the station before events/net/timers,
- * the closest to nextTick; ticks scheduled from user code on the main
- * stack run when the loop starts, i.e. after all synchronous code — the
- * nextTick shape). The implemented orderings follow lib/internal/streams:
+ * here each deferral enqueues on the stream tick FIFO AND posts a raw
+ * marker on the USER nextTick queue (scr_next_tick_raw), so stream
+ * emissions and user nextTicks run in true FIFO enqueue order — Node's,
+ * where they are the same queue. The scr_loop_set_stream station remains
+ * as the drain of anything a marker never reached (and the uncaught-throw
+ * cleanup). The implemented orderings follow lib/internal/streams:
  *   - on('data') starts flowing on a TICK (resume_): synchronous code
  *     after the registration runs before the first 'data'.
  *   - push() while flowing with an empty buffer emits 'data'
@@ -103,6 +104,10 @@ struct ScrStreamState {
     bool encoded;       /* string-chunk mode (decoder active) */
     ScrStr *enc;        /* owned canonical encoding name, or NULL */
     double dec_pending; /* scr_strdec packed pending state */
+    /* The defaultEncoding option's push-side effect: how push(string)
+     * DECODES string chunks into bytes (Node's Buffer.from(chunk,
+     * state.defaultEncoding)). Owned canonical name; NULL = utf8. */
+    ScrStr *push_enc;
     /* Readable.from mode: entries are whole OBJECTS (each counts 1
      * toward length/hwm and delivers undivided — Node's objectMode
      * accounting for the from() surface; hwm is 1). */
@@ -223,6 +228,7 @@ static void scr_stream_state_drop(ScrStreamState *st, bool gc) {
   for (size_t i = 0; i < st->r.n; i++) scr_stream_entry_release(st, st->r.buf[i]);
   free(st->r.buf);
   if (st->r.enc) scr_str_release(st->r.enc);
+  if (st->r.push_enc) scr_str_release(st->r.push_enc);
   if (!gc && st->r.next_waiter) scr_promise_release(st->r.next_waiter);
   if (!gc) {
     if (st->r.read_cb) scr_closure_release(st->r.read_cb);
@@ -350,6 +356,8 @@ typedef struct ScrStreamTick {
 static ScrStreamTick *scr_st_head = NULL;
 static ScrStreamTick *scr_st_tail = NULL;
 
+static void scr_stream_dispatch_one(void);
+
 static void scr_st_tick(ScrStream *s, ScrStreamTickOp op, ScrError *err /*moves*/,
                         ScrClosure *cb /*moves*/) {
   ScrStreamTick *t = calloc(1, sizeof *t);
@@ -361,6 +369,13 @@ static void scr_st_tick(ScrStream *s, ScrStreamTickOp op, ScrError *err /*moves*
   if (scr_st_tail) scr_st_tail->next = t;
   else scr_st_head = t;
   scr_st_tail = t;
+  /* One marker per tick on the USER nextTick queue: stream emissions are
+   * process.nextTicks in Node (resume_, emitReadable_, endReadableNT,
+   * afterWrite, ...), so they must interleave with user nextTicks in
+   * enqueue order — a `push(); on('data'); process.nextTick(assert)`
+   * sequence sees its data before the assert runs. The station dispatch
+   * below stays as the drain of anything a marker never reached. */
+  scr_next_tick_raw(&scr_stream_dispatch_one);
 }
 
 static bool scr_stream_ticks_pending(void) { return scr_st_head != NULL; }
@@ -1222,6 +1237,24 @@ static ScrStream *scr_stream_alloc(const ScrVt *vt, const char *cls, bool has_r,
   s->reg = NULL;
   s->cls = cls;
   s->st = scr_stream_state_new(has_r, has_w, rhwm, whwm, auto_destroy, emit_close, allow_half_open);
+  /* Node's stream constructors pre-create their known _events keys (a V8
+   * shape optimization) — eventNames() lists these BEFORE user events
+   * added earlier. Same names, same order: Readable close/error/data/end/
+   * readable, Writable close/error/prefinish/finish/drain, Duplex the
+   * union (writable trio first — Node's observed key order). */
+  ScrEmitter *em = (ScrEmitter *)s;
+  scr_emitter_reserve(em, "close");
+  scr_emitter_reserve(em, "error");
+  if (has_w) {
+    scr_emitter_reserve(em, "prefinish");
+    scr_emitter_reserve(em, "finish");
+    scr_emitter_reserve(em, "drain");
+  }
+  if (has_r) {
+    scr_emitter_reserve(em, "data");
+    scr_emitter_reserve(em, "end");
+    scr_emitter_reserve(em, "readable");
+  }
   scr_obj_alloc_note();
   return s;
 }
@@ -2193,6 +2226,133 @@ ScrPromise *scr_sp_pipeline(double n, ScrStream **streams) {
   return p;
 }
 
+/* ── node:stream/consumers ────────────────────────────────────────────
+ * text/json/buffer over the readable machinery: a native 'data' listener
+ * accumulates every chunk (Buffer chunks as-is; string chunks — an
+ * encoded stream or Readable.from strings — as their utf8 bytes, the
+ * Blob rule Node's consumers share for whole-stream accumulation), and
+ * the finished watcher settles at the terminal point — the accumulated
+ * result on a clean end (right after 'close', Node's own timing: the
+ * consumer's async iterator completes through eos), the stream's error,
+ * or ERR_STREAM_PREMATURE_CLOSE on an early close — and marks lifecycle
+ * errors handled, exactly like the iterator's eos registration. Both
+ * closures share the cap layout: caps[0] the pending promise, caps[1]
+ * the chunk list (Buffer entries). */
+
+enum { SCR_SC_TEXT = 0, SCR_SC_JSON = 1, SCR_SC_BUFFER = 2 };
+
+static void scr_sc_settle_ok(ScrClosure *cb, int kind) {
+  ScrPromise *p = scr_box_get_ref(cb->caps[0]);  /* +1 */
+  ScrArr *chunks = scr_box_get_ref(cb->caps[1]); /* +1 */
+  ScrBytes *all = scr_bytes_concat(chunks);
+  scr_arr_release(chunks);
+  if (kind == SCR_SC_BUFFER) {
+    scr_promise_fulfill_ref(p, all, scr_bytes_retain_v, scr_bytes_release_v, NULL);
+    scr_promise_release(p);
+    return;
+  }
+  ScrStr *enc = scr_str_new("utf8", 4);
+  ScrStr *text = scr_bytes_to_str(all, enc); /* U+FFFD per invalid subpart */
+  scr_str_release(enc);
+  scr_bytes_release(all);
+  if (kind == SCR_SC_TEXT) {
+    scr_promise_fulfill_str(p, text); /* moves */
+  } else {
+    ScrDyn *doc = scr_json_parse(text);
+    scr_str_release(text);
+    if (doc == NULL) {
+      /* the parse's SyntaxError rides the cell — the rejection, like
+       * Node's json() rejecting with JSON.parse's throw */
+      scr_promise_reject_pending(p);
+    } else {
+      scr_promise_fulfill_ref(p, doc, scr_dyn_retain_v, scr_dyn_release_v, NULL);
+    }
+  }
+  scr_promise_release(p);
+}
+
+/* The 'data' accumulation (the emit ABI's two payload slots — exactly
+ * one non-NULL). */
+static void scr_sc_data(ScrClosure *cb, void *b, void *str) {
+  ScrArr *chunks = scr_box_get_ref(cb->caps[1]); /* +1 */
+  if (b != NULL) {
+    scr_arr_push_ref(chunks, scr_bytes_retain((ScrBytes *)b));
+  } else if (str != NULL) {
+    ScrStr *enc = scr_str_new("utf8", 4);
+    scr_arr_push_ref(chunks, scr_bytes_from_str((ScrStr *)str, enc));
+    scr_str_release(enc);
+  }
+  scr_arr_release(chunks);
+}
+
+static void scr_sc_fin(ScrClosure *cb, ScrError *err, int kind) {
+  if (err != NULL) {
+    ScrPromise *p = scr_box_get_ref(cb->caps[0]); /* +1 */
+    scr_throw_obj(scr_error_retain(err), &scr_error_retain_v, &scr_error_release_v,
+                  scr_error_trace_arg());
+    scr_promise_reject_pending(p);
+    scr_promise_release(p);
+    return;
+  }
+  scr_sc_settle_ok(cb, kind);
+}
+
+static void scr_sc_fin_text(ScrClosure *cb, ScrStream *s, ScrError *err) {
+  (void)s;
+  scr_sc_fin(cb, err, SCR_SC_TEXT);
+}
+static void scr_sc_fin_json(ScrClosure *cb, ScrStream *s, ScrError *err) {
+  (void)s;
+  scr_sc_fin(cb, err, SCR_SC_JSON);
+}
+static void scr_sc_fin_buffer(ScrClosure *cb, ScrStream *s, ScrError *err) {
+  (void)s;
+  scr_sc_fin(cb, err, SCR_SC_BUFFER);
+}
+
+static ScrClosure *scr_sc_closure(void *fn, ScrPromise *p, ScrArr *chunks) {
+  ScrClosure *c = scr_closure_new(fn, 2);
+  c->caps[0] = scr_box_new_obj(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v);
+  scr_box_set_ref(c->caps[0], scr_promise_retain(p));
+  c->caps[1] = scr_box_new_obj(scr_arr_retain_v, scr_arr_release_v, NULL);
+  scr_box_set_ref(c->caps[1], scr_arr_retain(chunks));
+  return c;
+}
+
+static ScrPromise *scr_sc_consume(ScrStream *s, int kind) {
+  ScrPromise *p = scr_promise_new();
+  if (s->st == NULL || !s->st->has_r) {
+    /* Node's consumers for-await the argument; a stream with no readable
+     * side has no async iterator — the TypeError rejects. */
+    static const char msg[] = "stream is not async iterable";
+    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+    scr_promise_reject_pending(p);
+    return p;
+  }
+  ScrArr *chunks = scr_arr_new_ref(scr_bytes_retain_v, scr_bytes_release_v, NULL, 4);
+  ScrStreamErrInv fin_inv = kind == SCR_SC_TEXT    ? &scr_sc_fin_text
+                            : kind == SCR_SC_JSON  ? &scr_sc_fin_json
+                                                   : &scr_sc_fin_buffer;
+  /* The terminal watcher first (it marks lifecycle errors handled); the
+   * promise form exposes no unhook — the cleanup closure drops. */
+  ScrClosure *cleanup = scr_stream_finished(s, scr_sc_closure((void *)fin_inv, p, chunks), fin_inv);
+  scr_closure_release(cleanup);
+  ScrStr *dn = scr_str_new("data", 4);
+  scr_emitter_release(scr_emitter_on((ScrEmitter *)s, dn,
+                                     scr_sc_closure((void *)&scr_sc_data, p, chunks),
+                                     scr_ee_inv_fixed2, false, false));
+  scr_str_release(dn);
+  /* resume() rather than the 'data' hook alone: Node's consumer pulls
+   * through the iterator, which drains a PAUSED stream too. */
+  scr_stream_release(scr_stream_resume(s));
+  scr_arr_release(chunks);
+  return p;
+}
+
+ScrPromise *scr_sc_text(ScrStream *s) { return scr_sc_consume(s, SCR_SC_TEXT); }
+ScrPromise *scr_sc_json(ScrStream *s) { return scr_sc_consume(s, SCR_SC_JSON); }
+ScrPromise *scr_sc_buffer(ScrStream *s) { return scr_sc_consume(s, SCR_SC_BUFFER); }
+
 /* ── the readable surface ─────────────────────────────────────────────── */
 
 bool scr_stream_push(ScrStream *s, ScrBytes *chunk) {
@@ -2200,13 +2360,41 @@ bool scr_stream_push(ScrStream *s, ScrBytes *chunk) {
 }
 
 bool scr_stream_push_str(ScrStream *s, ScrStr *str) {
-  ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)str->len);
-  memcpy(b->data, str->data, str->len);
+  ScrStr *enc = s->st->has_r ? s->st->r.push_enc : NULL;
+  ScrBytes *b;
+  if (enc != NULL) {
+    /* Node: Buffer.from(chunk, state.defaultEncoding). */
+    b = scr_bytes_from_str(str, enc);
+  } else {
+    b = scr_bytes_new(SCR_BYTES_U8, (double)str->len);
+    memcpy(b->data, str->data, str->len);
+  }
+  bool ret = scr_stream_add_chunk(s, b, false);
+  scr_bytes_release(b);
+  return ret;
+}
+
+/* push(chunk, encoding) with an explicit non-utf8 literal: the per-call
+ * encoding overrides the stream's default. Borrows both strings. */
+bool scr_stream_push_str_enc(ScrStream *s, ScrStr *str, ScrStr *enc) {
+  ScrBytes *b = scr_bytes_from_str(str, enc);
   bool ret = scr_stream_add_chunk(s, b, false);
   scr_bytes_release(b);
   return ret;
 }
 
+/* The defaultEncoding option's push side (canonical literal, frontend-
+ * folded; never "utf8" — that stays the NULL fast path). Answers the
+ * receiver +1, the setEncoding chaining shape. */
+ScrStream *scr_stream_set_push_encoding(ScrStream *s, ScrStr *enc) {
+  ScrStreamState *st = s->st;
+  if (st->has_r) {
+    if (st->r.push_enc) scr_str_release(st->r.push_enc);
+    st->r.push_enc = scr_str_retain(enc);
+  }
+  return scr_stream_retain(s);
+}
+
 bool scr_stream_push_null(ScrStream *s) {
   ScrStreamState *st = s->st;
   if (!st->has_r || st->destroyed) return false;
@@ -2891,6 +3079,25 @@ static void scr_stream_run_tick(ScrStreamTick *t) {
   }
 }
 
+static void scr_stream_dispatch(void);
+
+/* One tick-marker's dispatch: the queue's FIFO head (markers and entries
+ * are enqueued 1:1 in the same order). After an uncaught throw the
+ * remaining entries drop through the station's exc branch below, keeping
+ * the RC audit clean. */
+static void scr_stream_dispatch_one(void) {
+  ScrStreamTick *t = scr_st_head;
+  if (t == NULL || scr_exc_pending()) return;
+  scr_st_head = t->next;
+  if (scr_st_head == NULL) scr_st_tail = NULL;
+  scr_stream_run_tick(t);
+  scr_stream_release(t->s);
+  if (t->err) scr_error_release(t->err);
+  if (t->cb) scr_closure_release(t->cb);
+  free(t);
+  if (scr_exc_pending()) scr_stream_dispatch(); /* its exc branch drops the rest */
+}
+
 static void scr_stream_dispatch(void) {
   while (scr_st_head != NULL && !scr_exc_pending() && !scr_loop_has_ready()) {
     ScrStreamTick *t = scr_st_head;