@scriptc/runtime 0.0.7 → 0.0.9

package/src/scr_runtime.h

@@ -48,8 +48,10 @@ void scr_init(void);
  * 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. */
+ * into library frames). Messages keep their trailing newline in both lanes;
+ * the library funnel additionally assembles every DETECTED trap into the
+ * structured trap-teaching form before delivery (a message that already
+ * begins with the 0x01 marker passes verbatim) — see ScrLibSinkFn below. */
 _Noreturn void scr_trap(const char *msg);
 _Noreturn void scr_trap_fmt(const char *fmt, ...);
 
@@ -67,7 +69,32 @@ typedef struct ScrBytes ScrBytes;
  * 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. */
+ * back into library frames.
+ *
+ * Message shape (the ratified structured trap-teaching encoding): a
+ * BASELINE message is plain text whose first byte is printable (>= 0x20) —
+ * no emitter path ever produces an unstructured message starting below
+ * 0x20. A STRUCTURED message begins with the marker byte 0x01 followed by
+ * the human teaching text and 0x1F-separated fields:
+ *
+ *   0x01  text  0x1F code  0x1F symbol  [ 0x1F remediation ]
+ *
+ * so msg_len > 0 && msg[0] == 0x01 is the one version test. Parse: split
+ * the bytes after the marker on 0x1F — field 0 is the human text, 1 the
+ * diagnostic code, 2 the trapping symbol as the host linked it, 3 the
+ * remediation; a missing or empty field means none; ignore any field past
+ * the fourth. Fields are (pointer, length) — never assume NUL termination.
+ * A plain-text host may print the whole buffer: the teaching leads it.
+ *
+ * Every trap the runtime DETECTS arrives structured: the funnel assembles
+ * the baseline human line into field 0 unchanged, a stable code for the
+ * trap kind (the compiler registry's SC4013–SC4019 runtime family,
+ * classified in scr_library.c), the entry symbol recorded by the trapping
+ * entry's prologue, and the profile's remediation for that code when the
+ * program TU's overlay table declares one (the whole fourth field is
+ * absent otherwise). A message that already begins with the marker — a
+ * facade-authored structured throw, or the wrapper's compile-time-
+ * assembled SC4012 contract trap — passes through byte-for-byte. */
 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 */
@@ -75,8 +102,15 @@ 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);
+ * auto-reset posture, and the reset/collect entries' shared body).
+ * entry_symbol is the generated entry's external symbol exactly as the
+ * host linked it (a static string in the program TU): the prologue records
+ * it in the funnel's current-entry slot so a detected trap's structured
+ * message can name the trapping entry — sound as a single static slot
+ * because exactly one core is ever live and entries never nest. Init and
+ * the mode entries (reset, collect) record theirs too; the identity
+ * getters and sink registration touch no runtime and never trap. */
+void scr_library_entry(bool reset_arena, const char *entry_symbol);
 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
@@ -96,16 +130,39 @@ 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). */
+ * The ratified verbatim rule: a thrown message that ALREADY begins with the
+ * structured marker 0x01 (a thrown string, or an Error whose .message
+ * starts with it) is delivered byte-for-byte — no "Uncaught " prefix, no
+ * added newline — which is how facade-authored structured teachings ride
+ * the throw channel to the sink. Defined in scr_exception.c (it owns the
+ * cell). */
 void scr_library_check_exc(void);
 
+/* The length-taking funnel entry (library lane only): delivers exactly the
+ * given bytes to the sink — the verbatim path above needs it because a
+ * structured message is length-delimited, never NUL-scanned. */
+_Noreturn void scr_trap_len(const char *msg, size_t len);
+
+/* The runtime-trap overlay table, DEFINED by the generated program TU
+ * (both emissions emit identical data) and consumed by the funnel when it
+ * assembles a detected trap's structured message: flat triples of
+ * (code, teaching-or-NULL, remediation-or-NULL), one per runtime trap code
+ * (SC4013–SC4019 family) the profile declares text for; _len counts
+ * triples. A declared teaching replaces the baseline human line as field 0;
+ * a declared remediation becomes the optional fourth field. */
+extern const char *const scr_library_trap_overlays[];
+extern const size_t scr_library_trap_overlays_len;
+
 /* 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 */
+/* trap_msg is the wrapper's compiler-assembled host-contract trap message
+ * (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 */
 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);
 
@@ -287,6 +344,10 @@ void *scr_classobj_retain_v(void *c);
 void scr_classobj_release_v(void *c);
 /* `X.name` (+1 — a no-op retain on the interned immortal). */
 ScrStr *scr_classobj_name(ScrClassObj *c);
+/* The keyed-write miss on a fixed-shape record: throws the catchable
+ * TypeError naming the key (JS would add the property — the documented
+ * monomorphic-struct divergence). scr_object.c. */
+void scr_record_key_miss(ScrStr *k);
 
 /* ── error objects (scr_error.c) ──────────────────────────────────────
  * `Error` and its lib subclasses (TypeError/RangeError/SyntaxError) are a
@@ -417,6 +478,9 @@ void scr_undef_global_read(ScrStr *name);
 void scr_error_set_code(ScrError *e, const char *code);
 ScrStr *scr_error_code(ScrError *e);
 void scr_throw_error_msg_code(int kind, const char *message, size_t len, const char *code);
+/* The compiler-resolved Node-parity throw (error.nodeThrow): builtin
+ * error of `kind`, `code` stamped when non-empty. Borrows both. */
+void scr_throw_node_coded(double kind, const ScrStr *code, const ScrStr *msg);
 
 /* ── string methods ─────────────────────────────────────────────────
  * ECMA-262 observable semantics (UTF-16 code units) computed over the
@@ -1520,6 +1584,13 @@ bool scr_stream_push_dyn(ScrStream *s, const ScrDyn *d);       /* borrows d; tag
 bool scr_stream_write_dyn(ScrStream *s, const ScrDyn *d, ScrClosure *cb); /* cb moves */
 ScrPromise *scr_stream_next_chunk(ScrStream *s);
 ScrPromise *scr_stream_next_chunk_dyn(ScrStream *s);
+/* node:stream/promises — the promise forms over the finished/pipeline
+ * machinery above: a pending void promise the terminal watcher settles
+ * (fulfilled on a clean finish, rejected with the finish status
+ * otherwise — the stream's error or ERR_STREAM_PREMATURE_CLOSE).
+ * Streams borrowed; +1 promises. */
+ScrPromise *scr_sp_finished(ScrStream *s);
+ScrPromise *scr_sp_pipeline(double n, ScrStream **streams);
 /* 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. */
@@ -2640,6 +2711,13 @@ ScrDyn *scr_dyn_obj_get(const ScrDyn *d, const char *key, size_t key_len);
  * member nodes. null/undefined receivers throw Node's catchable
  * TypeError. */
 ScrDyn *scr_dyn_obj_keys(const ScrDyn *v);
+/* Object.hasOwn over a DOM receiver: OBJ member presence, ARR index
+ * bounds ("length" included); nullish receivers throw Node's ToObject
+ * TypeError; every other kind answers false. */
+bool scr_dyn_has_own(const ScrDyn *v, const ScrStr *key);
+/* Object.assign over DOM values (+1 target back; ToObject TypeError on a
+ * nullish target). */
+ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src);
 ScrDyn *scr_dyn_obj_values(const ScrDyn *v);
 ScrDyn *scr_dyn_obj_entries(const ScrDyn *v);
 
@@ -2667,6 +2745,14 @@ ScrDyn *scr_dyn_new_buffer_copy(const ScrBytes *b);
  * extraction (`u as Uint8Array`). */
 ScrBytes *scr_dyn_bytes_copy_out(const ScrDyn *d);
 void scr_dyn_arr_push(ScrDyn *arr, ScrDyn *item);
+/* Spread completion for a runtime-arity argument list (`f(...xs)` in the
+ * checked-dynamic tier): flattens `src` into `arr` per JS's spread over the
+ * DOM's iterable kinds — arrays element-by-element (retained), strings by
+ * code POINT (the string iterator), bytes by byte — and throws V8's exact
+ * SPREAD-CALL TypeError for every other kind (pending; callers check):
+ * nullish sources spell the spread expression (`what`), everything else is
+ * the generic "Spread syntax requires ..." text. Borrows src. */
+void scr_dyn_arr_push_spread(ScrDyn *arr, const ScrDyn *src, const char *what);
 void scr_dyn_obj_set(ScrDyn *obj, const char *key, size_t key_len, ScrDyn *value);
 /* The checked-dynamic keyed WRITE (`h.k = v` on a dyn receiver): OBJ sets
  * the member (JS: later writes win, insertion order); undefined/null and
@@ -2683,6 +2769,10 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc);
 /* JS String() over the DOM kind (units render "null"/"undefined" where
  * scr_dyn_to_string throws) — the web globals' WebIDL ToString. +1. */
 ScrStr *scr_dyn_string_coerce(const ScrDyn *d);
+/* JS ToString WITH the object protocol (user toString/valueOf members
+ * 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);
 
 /* `d instanceof TypeError` (and the other builtin error classes) on a
  * checked-dynamic value: the from_error cache resolves the DOM encoding
@@ -2753,6 +2843,10 @@ ScrDyn *scr_dyn_new_func(ScrClosure *clo, ScrDynThunk thunk, uint32_t arity, con
  * boxed thunk (per-arg checks live there). `args` entries are BORROWED;
  * the result is owned (+1), or NULL with the exception pending. */
 ScrDyn *scr_dyn_call(const ScrDyn *d, ScrDyn *const *args, size_t argc, const char *what);
+/* scr_dyn_call over a DOM ARRAY's elements (the spread-application form —
+ * `f(...args)` after the emitted argument array is built): argv IS the
+ * array's items. Borrows both; result owned (+1), or NULL pending. */
+ScrDyn *scr_dyn_apply(const ScrDyn *d, const ScrDyn *args, const char *what);
 
 /* Path spine for dynCheck error messages — a compile-time-shaped linked
  * list the emitted builders stack-allocate per recursion level: `key`
@@ -2893,6 +2987,9 @@ void scr_dyn_check_listener(const ScrDyn *cb, const char *argname);
  * generic ERR_INVALID_ARG_TYPE thrower over it (`expected` is the whole
  * "of type ..." clause). The handle dispatchers' per-arg gates. */
 const char *scr_dyn_specific_type(const ScrDyn *v, char *buf, size_t cap);
+/* ERR_INVALID_ARG_TYPE with the runtime-rendered Received tail (the
+ * error.argTypeThrow libCall). Borrows all three; always throws. */
+void scr_throw_arg_type(const ScrStr *argname, const ScrStr *expected, const ScrDyn *got);
 void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrDyn *got);
 /* Listener-closure builders for the handle dispatchers' .on(...) paths:
  * a runtime-built ScrClosure whose capture is the boxed dyn listener and
@@ -3681,6 +3778,13 @@ ScrJsval *scr_jsval_call_method(ScrJsval *o, const ScrStr *name, int argc, ScrJs
  * anything else calls with this = o (non-callables throw in the engine). */
 ScrJsval *scr_jsval_opt_call_method(ScrJsval *o, const ScrStr *name, int argc, ScrJsval **argv);
 ScrJsval *scr_jsval_call(ScrJsval *f, int argc, ScrJsval **argv);
+/* Spread application on an island callee — `f(...pre, ...spread)` through
+ * the prelude helper's REAL spread syntax (iterator protocols are the
+ * engine's own; the guards front-run V8's exact spread-call TypeError
+ * texts). `pre` is the engine array of leading fixed arguments; `what` the
+ * spread expression's source spelling (the nullish text spells it).
+ * Borrows everything; +1 out, or NULL with the exception bridged. */
+ScrJsval *scr_jsval_call_spread(ScrJsval *f, ScrJsval *pre, ScrJsval *spread, const ScrStr *what);
 /* `new X(...)` on an island callee (jsOp construct) — JS_CallConstructor.
  * Borrows everything; +1 out, or NULL with the exception bridged. */
 ScrJsval *scr_jsval_construct(ScrJsval *f, int argc, ScrJsval **argv);
@@ -3765,6 +3869,16 @@ ScrPromise *scr_jsval_bridge_promise(ScrJsval *v, int payload);
  * marshaled strings) or an array from elements. Borrow argv; +1 out.
  * Cannot fail (allocation failure aborts, like every runtime OOM). */
 ScrJsval *scr_jsval_obj_lit(int npairs, ScrJsval **kv);
+/* Getter completion for an island literal: defines `key` on `obj` as an
+ * engine getter invoking `fn`; answers the object retained (+1). */
+ScrJsval *scr_jsval_define_getter(ScrJsval *obj, ScrJsval *key, ScrJsval *fn);
+/* The engine TemplateStringsArray for an island tag call: n cooked then n
+ * raw strings; the result array carries `.raw` (+1). */
+ScrJsval *scr_jsval_tpl_strings(int n, ScrJsval **kv);
+/* Spread completion for an island literal: engine CopyDataProperties of
+ * `src` onto `obj`; answers the target (+1), NULL + pending on a getter
+ * throw. */
+ScrJsval *scr_jsval_obj_spread(ScrJsval *obj, ScrJsval *src);
 ScrJsval *scr_jsval_arr_lit(int n, ScrJsval **elems);
 
 /* Marshal out (island → static): validated, STRICT extraction — a
@@ -3818,6 +3932,12 @@ void scr_jsval_cast_fail(ScrJsval *v, const ScrStr *target);
  */
 size_t scr_f64_to_str(double x, char *buf);
 
+/* The Ryū digit core (scr_number.c), shared with the Intl en-US number
+ * formatter: the shortest round-tripping digits of a POSITIVE finite
+ * double — value = 0.digits × 10^n, no trailing zeros, NUL-terminated.
+ * Returns k, the digit count (≤ 17). */
+int scr_f64_digits(double x, char digits[18], int *n_out);
+
 /* ToString for template literals / string coercion. Returns +1. */
 ScrStr *scr_f64_to_scrstr(double x);
 ScrStr *scr_bool_to_scrstr(bool b); /* interned "true"/"false" */
@@ -3849,6 +3969,18 @@ bool scr_num_is_safe_integer(double x);
 ScrStr *scr_num_to_exponential(double x);
 ScrStr *scr_num_to_fixed0(double x);
 
+/* Object.is over two numbers — the spec's SameValue on doubles: NaN
+ * equals NaN, +0 differs from -0, everything else is ==. Never throws. */
+bool scr_num_same_value(double a, double b);
+
+/* Intl.NumberFormat("en-US").format(x) / x.toLocaleString("en-US") with
+ * default options: decimal notation, 0–3 fraction digits rounded half-up
+ * on the shortest round-tripping decimal (ICU's rounding input — NOT
+ * toFixed's exact-value rounding), "," grouping every three integer
+ * digits, "∞"/"NaN" texts, "-0" for negative inputs rounding to zero.
+ * 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. */
@@ -4003,6 +4135,14 @@ typedef enum ScrDataViewGet {
 } ScrDataViewGet;
 double scr_dataview_get(const ScrBytes *b, double byte_off, ScrDataViewGet kind, bool le);
 
+/* DataView setters (the integer/float kinds only — the BIG kinds never
+ * lower: bigint arguments have no representation). Values coerce
+ * JS-exactly: the integer kinds by modular truncation (ToUint32's residue
+ * — the narrower widths store its low bytes, the same 2^width residue),
+ * F32 by double→float round-to-nearest-even. Offsets go through ToIndex
+ * with the getters' one RangeError. */
+void scr_dataview_set(ScrBytes *b, double byte_off, double value, ScrDataViewGet kind, bool le);
+
 /* Element read/write. Any invalid index — negative, fractional, NaN, or
  * out of bounds — TRAPS like the array runtime (SEMANTICS.md documents
  * the divergence from JS's undefined-read/ignored-write). Writes coerce
@@ -4073,6 +4213,32 @@ bool scr_bytes_is_encoding(const ScrStr *s);
 bool scr_bytes_equals(const ScrBytes *a, const ScrBytes *b);
 double scr_bytes_compare(const ScrBytes *src, const ScrBytes *target, double nargs,
                          double ts, double te, double ss, double se);
+/* Node's validateOffset ladder (buffer.js): non-integers (±Infinity and
+ * NaN included) throw the 'an integer' ERR_OUT_OF_RANGE RangeError, the
+ * rest the '>= 0 && <= max' render; max < 0 drops the upper bound.
+ * Returns false after arming the pending throw. */
+bool scr_bytes_validate_off(const char *name, double value, double max);
+/* The checked-dynamic compare/equals validators (scr_bytes_io.c): Node's
+ * argument ladder over DOM-boxed arguments — a non-bytes value throws
+ * ERR_INVALID_ARG_TYPE with the API's own argument name ("buf1"/"buf2",
+ * "otherBuffer", "target"), non-number offsets ERR_INVALID_ARG_TYPE
+ * "of type number", out-of-range numbers the validateOffset RangeError;
+ * an undefined offset takes its Node default. All arguments BORROWED. */
+double scr_buffer_compare_chk(const ScrDyn *a, const ScrDyn *b);
+bool scr_bytes_equals_chk(const ScrBytes *recv, const ScrDyn *other);
+double scr_bytes_compare_chk(const ScrBytes *src, const ScrDyn *target,
+                             const ScrDyn *ts, const ScrDyn *te,
+                             const ScrDyn *ss, const ScrDyn *se);
+/* new Buffer(number, encoding)'s string-arm type error (always throws;
+ * borrowed). */
+ScrBytes *scr_buffer_new_string_fail(const ScrDyn *got);
+/* fs._toUnixTimestamp over a DOM time value: numeric strings and finite
+ * numbers coerce (negatives answer now/1000), the rest throw Node's
+ * ERR_INVALID_ARG_TYPE. Borrowed. */
+double scr_fs_to_unix_timestamp(const ScrDyn *t);
+/* The checked-dynamic max-listeners ladders (scr_events_emitter.c). */
+ScrEmitter *scr_emitter_set_max_chk(ScrEmitter *em, const ScrDyn *n);
+void scr_emitter_set_default_max_chk(const ScrDyn *n, const ScrStr *name);
 double scr_bytes_index_of(const ScrBytes *b, const ScrBytes *needle, double off, double align, bool fwd);
 double scr_bytes_index_of_num(const ScrBytes *b, double v, double off, bool fwd);
 ScrBytes *scr_bytes_fill(ScrBytes *b, const ScrBytes *pattern, double nargs, double offset, double end);

package/src/scr_stream.c

@@ -683,7 +683,9 @@ static void *scr_stream_read_n(ScrStream *s, double size) {
       st->r.hwm = h;
     }
   }
-  if (!absent && n != 0) st->r.emitted_readable = false;
+  /* Node's read(): `if (n !== 0) state.emittedReadable = false` — the
+   * absent form is NaN there, which also clears; only read(0) keeps it. */
+  if (absent || n != 0) st->r.emitted_readable = false;
   if (!absent && n == 0 && st->r.need_readable &&
       (st->r.length >= st->r.hwm || st->r.ended)) {
     if (st->r.length == 0 && st->r.ended) scr_stream_end_readable(s);
@@ -2148,6 +2150,49 @@ ScrStream *scr_stream_pipeline(double n_d, ScrStream **streams /*borrowed*/,
   return scr_stream_retain(streams[n - 1]);
 }
 
+/* ── node:stream/promises ─────────────────────────────────────────────
+ * The promise forms ride the callback machinery above with a settling
+ * watcher: caps[0] boxes the pending promise; the terminal status
+ * fulfills (NULL) or rejects (the error moves through the exception
+ * cell, the reject-pending pattern). */
+
+static void scr_sp_settle_inv(ScrClosure *cb, ScrStream *s, ScrError *err) {
+  (void)s;
+  ScrPromise *p = scr_box_get_ref(cb->caps[0]); /* +1 */
+  if (err != NULL) {
+    scr_throw_obj(scr_error_retain(err), &scr_error_retain_v, &scr_error_release_v,
+                  scr_error_trace_arg());
+    scr_promise_reject_pending(p);
+  } else {
+    scr_promise_fulfill_void(p);
+  }
+  scr_promise_release(p);
+}
+
+static ScrClosure *scr_sp_watcher(ScrPromise *p /*borrowed*/) {
+  ScrClosure *w = scr_closure_new((void *)&scr_sp_settle_inv, 1);
+  w->caps[0] = scr_box_new_obj(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v);
+  scr_box_set_ref(w->caps[0], scr_promise_retain(p));
+  return w;
+}
+
+ScrPromise *scr_sp_finished(ScrStream *s) {
+  ScrPromise *p = scr_promise_new();
+  /* The cleanup closure is the callback form's return value; the promise
+   * form exposes no unhook, so it drops here (the watcher stays parked —
+   * scr_stream_finished retained it into the stream's list). */
+  ScrClosure *cleanup = scr_stream_finished(s, scr_sp_watcher(p), &scr_sp_settle_inv);
+  scr_closure_release(cleanup);
+  return p;
+}
+
+ScrPromise *scr_sp_pipeline(double n, ScrStream **streams) {
+  ScrPromise *p = scr_promise_new();
+  ScrStream *dst = scr_stream_pipeline(n, streams, scr_sp_watcher(p), &scr_sp_settle_inv);
+  scr_stream_release(dst);
+  return p;
+}
+
 /* ── the readable surface ─────────────────────────────────────────────── */
 
 bool scr_stream_push(ScrStream *s, ScrBytes *chunk) {
@@ -2664,10 +2709,12 @@ double scr_stream_prop(ScrStream *s, const char *name) {
  * arrives outside a _read call). */
 static void scr_stream_emit_readable_now(ScrStream *s) {
   ScrStreamState *st = s->st;
-  st->r.emitted_readable = false;
+  /* Node's emitReadable_ clears emittedReadable AFTER the emit (a
+   * 'readable' listener observes true) and only when it really fired. */
   if (!st->destroyed && !st->errored && (st->r.length > 0 || st->r.ended)) {
     scr_stream_emit0(s, "readable");
     if (scr_exc_pending()) return;
+    st->r.emitted_readable = false;
   }
   st->r.need_readable = st->r.flowing != 1 && !st->r.ended &&
                         st->r.length <= st->r.hwm;