@scriptc/runtime 0.0.9 → 0.0.11

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. */
@@ -2617,6 +2646,28 @@ typedef enum {
    * (the dyn→closure stance): a cycle THROUGH a dyn-boxed promise is
    * merely never collected. */
   SCR_DYN_PROMISE,
+  /* An ISLAND (engine-held) value — the jsval→DOM crossing. Never
+   * produced by the parser — it enters the DOM through the gated
+   * constructor scr_dyn_from_jsval (scr_island.c): an 'any'-typed value
+   * flowing into an 'unknown'/'object'/JS-residue slot. Boxes by
+   * REFERENCE (a retained ScrJsval cell). The constructor SCALAR-
+   * NORMALIZES: engine numbers/strings/booleans/null/undefined convert
+   * to the native DOM kinds at wrap time, so JSVAL nodes only ever hold
+   * engine objects, arrays, and functions (plus the symbol/bigint edge —
+   * kinds the DOM cannot represent at all). Identity is the CELL's
+   * engine value: strict equality routes to the engine's === (two wraps
+   * of one engine value compare equal), and scr_jsval_from_dyn unwraps
+   * the SAME cell back (+1) — the boundary is identity-preserving for
+   * engine-born values. typeof/truthiness/String() route to the engine
+   * per use (scr_dyn_jsval_ops); every DOM walk without an armed route
+   * (JSON, structuredClone, deepStrictEqual, inspect, keyed access,
+   * calls, iteration) throws the LOUD "not supported yet" ladder — never
+   * a silent wrong answer. The dyn→cell edge is NOT visible to the cycle
+   * collector (the dyn→closure stance): a cycle DOM → cell → engine
+   * object → host closure → DOM is merely never collected (the
+   * documented cross-boundary-cycle divergence). Enum position: LAST —
+   * the LLVM backend hardcodes the preceding kind numbers. */
+  SCR_DYN_JSVAL,
 } ScrDynKind;
 
 /* The handle-type tags the DOM can carry. The set is deliberately the
@@ -2636,6 +2687,10 @@ typedef enum {
 typedef struct ScrDyn ScrDyn;
 typedef struct ScrBytes ScrBytes; /* full definition below (C11 repeat) */
 typedef struct ScrClosure ScrClosure; /* full definition below (C11 repeat) */
+typedef struct ScrJsval ScrJsval; /* opaque island cell (C11 repeat; the
+                                   * always-linked DOM core never touches
+                                   * its engine value — only the gated ops
+                                   * installed by scr_dyn_from_jsval do) */
 
 /* The compiler-emitted call glue carried by a SCR_DYN_FUNC box: checks the
  * dyn arguments against the boxed closure's declared parameter types (a
@@ -2661,6 +2716,16 @@ struct ScrDyn {
    * coercion and toString() decode utf8, where a plain Uint8Array joins
    * its elements ("1,2,3"). Everything else ignores it. */
   bool buffer;
+  /* SCR_DYN_OBJ flavor: true for Object.create(null)'s dictionary — an
+   * object with NO prototype. Method dispatch needs nothing (the DOM's
+   * OBJ dispatch is already own-member-only, which IS Node's null-proto
+   * answer); util.inspect prefixes "[Object: null prototype]", and
+   * deepStrictEqual separates it from plain objects (Node compares
+   * prototypes — the bytes `buffer` gate's stance). Keyed reads/writes,
+   * Object.keys/entries/assign, JSON, and typeof are flag-blind, and
+   * fresh copies (structuredClone) DROP the flag — Node's serialization
+   * answers a plain object too. */
+  bool null_proto;
   union {
     bool b;
     double num;
@@ -2688,6 +2753,11 @@ struct ScrDyn {
      * emitted converters guarantee it (direct box for promise<dyn>,
      * adapter promise otherwise). */
     ScrPromise *promise;
+    /* SCR_DYN_JSVAL: the retained island cell (engine objects/arrays/
+     * functions only — the constructor scalar-normalizes; see the kind's
+     * comment). Released through the installed ops so this always-linked
+     * core never references the gated island unit. */
+    struct { ScrJsval *cell; } jsval;
   } v;
 };
 
@@ -2716,8 +2786,24 @@ ScrDyn *scr_dyn_obj_keys(const ScrDyn *v);
  * 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). */
+ * nullish target). Sources copy their own enumerable keys exactly as
+ * Object.keys lists them: OBJ members, ARR/STR/BYTES index keys; nullish
+ * and scalar/function/handle sources copy nothing. */
 ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src);
+/* Variadic Object.assign (the spread-source form): the compiler packs
+ * every source into one fresh DOM array — pack_push retains a plain
+ * source in (BORROWED), pack_push_spread flattens a spread source through
+ * the spread-call walk (V8's exact TypeError texts, `what` spelling the
+ * spread expression; MAY THROW pending) — then assign_all copies each
+ * pack element's own members onto the target left to right and answers
+ * the target retained (+1; ToObject TypeError on a nullish target). */
+void scr_dyn_pack_push(ScrDyn *pack, ScrDyn *v);
+void scr_dyn_pack_push_spread(ScrDyn *pack, const ScrDyn *src, const ScrStr *what);
+/* The iterated-path twin — a spread that is NOT the single last argument
+ * takes V8's iterator-protocol failure texts, which describe the VALUE
+ * ("object null", "number 5", ...) instead of spelling the expression. */
+void scr_dyn_pack_push_spread_iter(ScrDyn *pack, const ScrDyn *src);
+ScrDyn *scr_dyn_assign_all(ScrDyn *target, const ScrDyn *sources);
 ScrDyn *scr_dyn_obj_values(const ScrDyn *v);
 ScrDyn *scr_dyn_obj_entries(const ScrDyn *v);
 
@@ -2735,6 +2821,9 @@ ScrDyn *scr_dyn_new_num(double n);
 ScrDyn *scr_dyn_new_str(ScrStr *s);
 ScrDyn *scr_dyn_new_arr(void);
 ScrDyn *scr_dyn_new_obj(void);
+/* Object.create(null): the fresh null-prototype dictionary (see the
+ * null_proto flavor flag above). */
+ScrDyn *scr_dyn_new_obj_null_proto(void);
 /* Wraps a fresh COPY of the u8 payload (the static→dyn boundary copies —
  * DataView-backed sources copy their aliased window). Borrows b. */
 ScrDyn *scr_dyn_new_bytes_copy(const ScrBytes *b);
@@ -2753,6 +2842,12 @@ void scr_dyn_arr_push(ScrDyn *arr, ScrDyn *item);
  * 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);
+/* Destructuring pack over a DOM source: iterable kinds (arrays, strings by
+ * code point, bytes) collect into a fresh array (+1); every other kind
+ * throws V8's destructuring TypeError — `msg` verbatim when non-empty (the
+ * compile-time source spelling), else the runtime kind wording. Borrows
+ * both; NULL with the exception pending on the throw. */
+ScrDyn *scr_dyn_iter_pack(const ScrDyn *src, const ScrStr *msg);
 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
@@ -2766,6 +2861,10 @@ ScrStr *scr_dyn_typeof(const ScrDyn *d);
  * enc — utf8 default; strings/numbers/booleans/arrays/objects answer
  * JS-exactly; undefined/null throw the catchable TypeError). Borrows; +1. */
 ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc);
+/* The method-call spelling `d.toString(enc?)`: identical, except a
+ * null-prototype dictionary throws "<what> is not a function" — its
+ * prototype chain has no toString (Node's answer). */
+ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what);
 /* 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);
@@ -2943,6 +3042,87 @@ ScrDyn *scr_dyn_new_promise_adapting(ScrPromise *src,
 /* BORROWED peek at the boxed promise; NULL when d is not a promise box. */
 ScrPromise *scr_dyn_promise_of(const ScrDyn *d);
 
+/* ── island values in the DOM (SCR_DYN_JSVAL) ─────────────────────────
+ * Engine routing ops for JSVAL nodes, installed by the gated constructor
+ * (scr_dyn_from_jsval, scr_island.c — the scr_dyn_alloc_promise hook
+ * story: JSVAL nodes exist only after the constructor ran, so the ops
+ * are always installed when a dispatch arm meets the kind, and a
+ * dynamic-free link never references engine symbols). Contracts mirror
+ * the scr_jsval_* entries they route to. */
+typedef struct ScrDynJsvalOps {
+  void (*release)(ScrJsval *cell);
+  ScrStr *(*type_of)(ScrJsval *cell); /* engine typeof; +1, never throws */
+  bool (*truthy)(ScrJsval *cell);     /* engine ToBoolean; never throws */
+  /* String(v) in the engine (the full ToString protocol — user toString
+   * runs, its throw bridges): +1, or NULL with the exception pending. */
+  ScrStr *(*to_str)(ScrJsval *cell);
+  bool (*strict_eq)(ScrJsval *a, ScrJsval *b); /* engine ===; never throws */
+  bool (*is_array)(ScrJsval *cell);   /* Array.isArray, engine-side */
+  bool (*is_error)(ScrJsval *cell);   /* native Error instance, engine-side */
+  /* ── the routed operation set (lane dyn-routing-ops) ────────────────
+   * Each routes to the engine at the moment of use and converts at the
+   * boundary: dyn ARGUMENTS cross through scr_jsval_from_dyn (wrapped
+   * cells unwrap by reference, DOM data deep-copies, DOM FUNC boxes
+   * cross through the generic host-function shim), engine RESULTS come
+   * back through scr_dyn_from_jsval (scalar-normalizing). Fallible ops
+   * bridge the ENGINE's exception catchably and answer NULL/false/-1. */
+  ScrDyn *(*key_get)(ScrJsval *cell, const ScrStr *k); /* o[k]; +1 or NULL pending */
+  bool (*key_set)(ScrJsval *cell, const ScrStr *k, const ScrDyn *v); /* false = pending */
+  ScrDyn *(*call)(ScrJsval *cell, ScrDyn *const *args, size_t argc); /* f(...); +1 or NULL pending */
+  /* o.m(...) — the ENGINE's own prototypes run (JS-exact flatMap/map/
+   * forEach/...). A missing or non-callable member throws Node's
+   * "<what> is not a function" (the call site's spelling — V8's text,
+   * front-run before the engine's terser claim). */
+  ScrDyn *(*invoke)(ScrJsval *cell, const char *method, ScrDyn *const *args, size_t argc, const char *what);
+  bool (*is_nullish)(ScrJsval *cell); /* engine undefined/null; never throws
+                                       * (always false today — the wrap
+                                       * constructor scalar-normalizes) */
+  /* Object.keys/values/entries (mode 0/1/2) as a NATIVE DOM array (+1):
+   * keys are DOM strings, values wrap per element, entries are native
+   * DOM pairs. NULL with the engine's exception pending on refusal. */
+  ScrDyn *(*obj_walk)(ScrJsval *cell, int mode);
+  int (*has_own)(ScrJsval *cell, const ScrStr *k); /* 0/1; -1 = pending */
+  /* Object.assign(target, src) with the ENGINE target: src converts per
+   * member semantics (a wrapped src spreads by reference; DOM data
+   * enters as the usual deep copy). false = pending. */
+  bool (*assign)(ScrJsval *cell, const ScrDyn *src);
+  /* JSON.stringify text of the engine value (+1) — the engine's own
+   * stringify (toJSON protocols, cycle TypeErrors). NULL + pending when
+   * not JSON-representable. */
+  ScrStr *(*to_json)(ScrJsval *cell);
+} ScrDynJsvalOps;
+
+/* The allocator view the gated constructor uses (installs the ops);
+ * ownership of `cell` MOVES in (the caller retains first). */
+ScrDyn *scr_dyn_alloc_jsval(ScrJsval *cell, const ScrDynJsvalOps *ops);
+/* The installed ops (traps on a missing install — impossible unless a
+ * JSVAL node was forged without the constructor). */
+const ScrDynJsvalOps *scr_dyn_jsval_ops(void);
+/* dynTest arms that need the ENGINE's answer on a JSVAL node. Each
+ * answers false for every other kind (callers test unconditionally —
+ * the emitted narrowing tests stay branch-free). Never throw. */
+bool scr_dyn_isl_typeof_is(const ScrDyn *d, const char *name);
+bool scr_dyn_isl_is_array(const ScrDyn *d);
+bool scr_dyn_isl_is_error(const ScrDyn *d);
+/* The JSVAL honesty ladder: when d is a JSVAL node, THROWS the catchable
+ * "<what> on an island value held in 'unknown' is not supported yet"
+ * Error and returns false; every other kind returns false untouched.
+ * Callers gate un-armed operations with it — never a silent wrong
+ * answer (the retired fence-box bug). */
+bool scr_dyn_isl_fence(const ScrDyn *d, const char *what);
+/* The emitted keyed READ's JSVAL arm (sc_dyn_key_get): routes o[k] to the
+ * engine through the installed ops and wraps the result back (+1, scalars
+ * normalized) — the retired `.length -> fence` row. d MUST be a JSVAL
+ * node; NULL with the engine's exception bridged catchably. */
+ScrDyn *scr_dyn_isl_key_get(const ScrDyn *d, const ScrStr *k);
+/* The `??`/optional-chain nullish test over a DOM value: UNDEF/NULL
+ * native, JSVAL through the engine's own test (defensively — the wrap
+ * constructor scalar-normalizes engine null/undefined away), every other
+ * kind false. Never throws. */
+bool scr_dyn_is_nullish(const ScrDyn *d);
+/* scr_dyn_isl_tostr_buf (the display walkers' JSVAL arm) is declared
+ * with the ScrJsonBuf surface below. */
+
 /* ── the ambient receiver (JS `this` inside listener/callback bodies) ──
  * Node calls a handle's listeners with `this` bound to the emitting
  * handle (server.listen(0, function() { this.address().port })), and a
@@ -2991,6 +3171,24 @@ const char *scr_dyn_specific_type(const ScrDyn *v, char *buf, size_t cap);
  * 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);
+/* The property flavor ("The \"options.x\" property must be ...") — the
+ * option-bag validators' gate (error.propTypeThrow). Always throws. */
+void scr_throw_prop_type(const ScrStr *name, const ScrStr *expected, const ScrDyn *got);
+void scr_dyn_prop_type_fail(const char *name, const char *expected, const ScrDyn *got);
+/* Node's ERR_INVALID_ARG_VALUE ("The argument 'encoding' is invalid
+ * encoding. Received 'no'") — reason NULL renders "is invalid".
+ * TypeError; always throws catchably. */
+void scr_dyn_arg_value_fail(const char *name, const char *reason, const ScrDyn *got);
+/* The ERR_INVALID_ARG_VALUE/%j "Received" renderer (inspect-lite:
+ * strings quote, scalars print plain, deep shapes sketch). */
+const char *scr_dyn_inspect_lite(const ScrDyn *v, char *buf, size_t cap);
+/* A ladder's post-validation refuse: throws the compiler-rendered SC2020
+ * statement-fence text verbatim (Node's validation errors run first). */
+void scr_throw_lowering_fence(const ScrStr *msg);
+/* ERR_OUT_OF_RANGE's "Received" number rendering (Node's
+ * addNumericalSeparator underscores past 2^32) — scr_bytes.c's renderer,
+ * shared by the fs/net/tls option-ladder validators. */
+size_t scr_num_received(double v, char out[48]);
 /* Listener-closure builders for the handle dispatchers' .on(...) paths:
  * a runtime-built ScrClosure whose capture is the boxed dyn listener and
  * whose invoke boxes the event tuple back into the DOM and calls through
@@ -3065,6 +3263,12 @@ void scr_jb_put_f64(ScrJsonBuf *b, double v);
  * as \u00XX, everything else (UTF-8 included) verbatim — exactly the JS
  * JSON.stringify escape set for well-formed strings. */
 void scr_jb_put_json_str(ScrJsonBuf *b, const ScrStr *s);
+/* String(v) of a JSVAL node appended into b (the emitted sc_ds display
+ * walkers' arm; scr_dyn_display/to_string route here too): the engine's
+ * ToString. A bridged failure (throwing user toString, a symbol) leaves
+ * the exception PENDING and appends nothing — the loud path, never a
+ * fabricated rendering. */
+void scr_dyn_isl_tostr_buf(ScrJsonBuf *b, const ScrDyn *d);
 /* JSON-serialize a DOM value into the buffer — the sc_jw_* walker for the
  * dyn leaves the compiler cannot type: object members holding undefined
  * DROP, array slots holding undefined print null (exactly Node). */
@@ -3312,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
@@ -3738,11 +3947,27 @@ ScrJsval *scr_jsval_from_f64(double v);
 ScrJsval *scr_jsval_from_bool(bool v);
 ScrJsval *scr_jsval_from_str(const ScrStr *s);
 ScrJsval *scr_jsval_from_json(const ScrStr *json);
-/* A CHECKED-DYNAMIC (DOM) value entering the island — deep copy, data
- * kinds only (a boxed function/handle/promise throws the catchable
- * TypeError). NULL with a pending exception on failure. Borrows d. */
+/* A CHECKED-DYNAMIC (DOM) value entering the island — deep copy for data
+ * kinds (a boxed handle/promise throws the catchable TypeError). A JSVAL
+ * node unwraps to its OWN cell (+1) — an engine value that crossed into
+ * the DOM and back is the SAME engine value, by reference (nested JSVAL
+ * members embed their engine values directly). A boxed FUNCTION crosses
+ * as one generic host-function shim over its uniform ScrDynThunk: the
+ * shim wraps engine arguments as DOM values (scalar-normalizing), calls
+ * the thunk, and converts the DOM result back — each crossing mints a
+ * fresh engine function (identity is not preserved for re-crossings;
+ * SEMANTICS.md). NULL with a pending exception on failure. Borrows d. */
 ScrJsval *scr_jsval_from_dyn(const ScrDyn *d);
 
+/* The jsval→DOM crossing (the IR's dynFromJsval): wraps an island value
+ * as a SCR_DYN_JSVAL node, SCALAR-NORMALIZING first — engine numbers/
+ * strings/booleans/null/undefined convert to the native DOM kinds (the
+ * strict exits cannot fail on engine-reported scalars), so JSVAL nodes
+ * only ever hold engine objects/arrays/functions (and the symbol/bigint
+ * edge). Installs the DOM's engine-routing ops on first use. Borrows
+ * the cell (retains it into the node); +1 out; never throws. */
+ScrDyn *scr_dyn_from_jsval(ScrJsval *cell);
+
 /* Engine operations. Arithmetic yields a fresh cell (NULL = bridged);
  * comparisons yield 0/1 (-1 = bridged); truthy/not never fail. */
 ScrJsval *scr_jsval_binop(int op, ScrJsval *a, ScrJsval *b);
@@ -4016,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
@@ -4045,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;
 
@@ -4153,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"
@@ -4236,6 +4474,23 @@ ScrBytes *scr_buffer_new_string_fail(const ScrDyn *got);
  * 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 fs argument-validation ladders (the fs.*Chk libCalls): Node-order
+ * validation over DOM values with Node's exact typed errors; a pass
+ * meets the real operation where one exists (mkdtempSync, macOS
+ * lchmodSync) or the compiler-rendered fence. All borrowed; the Chk
+ * forms without results always leave an exception pending. */
+ScrDyn *scr_fs_exists_async(const ScrDyn *path, const ScrDyn *cb);
+void scr_fs_mkdtemp_chk(const ScrDyn *prefix, const ScrDyn *cb, const ScrStr *fence);
+ScrStr *scr_fs_mkdtemp_sync_chk(const ScrDyn *prefix, const ScrDyn *opts, const ScrStr *fence);
+void scr_fs_read_file_chk(const ScrDyn *path, const ScrDyn *opts, const ScrDyn *cb, const ScrStr *fence);
+void scr_fs_opendir_chk(const ScrDyn *path, const ScrDyn *opts, const ScrStr *fence);
+void scr_fs_watch_file_chk(const ScrDyn *path, const ScrDyn *listener, const ScrStr *fence);
+void scr_fs_lchmod_chk(const ScrDyn *path, const ScrDyn *mode, const ScrDyn *cb, const ScrStr *fence);
+ScrDyn *scr_fs_lchmod_sync_chk(const ScrDyn *path, const ScrDyn *mode);
+ScrPromise *scr_fsp_lchmod_chk(const ScrDyn *path, const ScrDyn *mode);
+void scr_fs_read_chk(const ScrDyn *fd, const ScrDyn *buffer, const ScrDyn *offset,
+                     const ScrDyn *length, const ScrDyn *position, const ScrStr *fence);
+void scr_fs_stream_opts_chk(const ScrDyn *path, const ScrDyn *opts, const ScrStr *fence);
 /* 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);
@@ -4503,6 +4758,16 @@ void scr_net_server_on_connection(ScrNetServer *s, ScrClosure *cb /*moves*/, Scr
  * server never fires it, like Node). */
 void scr_net_server_on_secure_connection(ScrNetServer *s, ScrClosure *cb /*moves*/, ScrNetConnFn fn, bool once);
 ScrNetSocket *scr_net_connect(double port, ScrStr *host /*borrowed, nullable*/, ScrClosure *cb /*moves, nullable*/); /* +1 */
+/* connect with a validated autoSelectFamilyAttemptTimeout option: the
+ * budget runs Node's validateInt32-from-1 ladder (ERR_OUT_OF_RANGE /
+ * ERR_INVALID_ARG_TYPE) and is then inert — the single dial has nothing
+ * to time. +1, or NULL with the throw pending. */
+ScrNetSocket *scr_net_connect_attempt(double port, ScrStr *host /*borrowed*/, const ScrDyn *t /*borrowed*/);
+/* net.connect/createConnection over a RUNTIME option bag (computed
+ * keys): Node-order validation (objectMode trio, port, host,
+ * autoSelectFamily, attempt budget), then the compiler-rendered fence —
+ * always leaves an exception pending. Borrowed. */
+void scr_net_connect_opts_chk(const ScrDyn *opts, const ScrStr *fence);
 /* connect with a caller lookup (net.connect({ ..., lookup })): invokes
  * lookup(hostname, options, answer-closure) synchronously; answer_fn is
  * the emitted per-shape thunk that decodes the answer down to
@@ -4717,6 +4982,13 @@ void scr_tls_h2_client_wrap(ScrNetSocket *sock, ScrStr *host /*borrowed*/, bool
  * the default pair, exactly Node. */
 typedef struct ScrSecureCtx ScrSecureCtx;
 ScrSecureCtx *scr_tls_create_secure_context(const char *cert, size_t cert_len, const char *key, size_t key_len); /* +1 */
+/* createSecureContext over a RUNTIME options record: Node's typed option
+ * validations first, then the pem walk (+1, or NULL with the exception
+ * pending). Borrowed. */
+ScrSecureCtx *scr_tls_create_secure_context_dyn(const ScrDyn *opts);
+/* tls.getCACertificates(type): validateString + the documented name set,
+ * then the compiler-rendered fence — always leaves an exception pending. */
+void scr_tls_ca_certs_chk(const ScrDyn *type, const ScrStr *fence);
 ScrSecureCtx *scr_secure_ctx_retain(ScrSecureCtx *c);
 void scr_secure_ctx_release(ScrSecureCtx *c);
 void *scr_secure_ctx_retain_v(void *p);
@@ -5140,6 +5412,13 @@ void scr_dgram_bind(ScrDgramSocket *s, double port, ScrStr *host /*borrowed*/, S
 void scr_dgram_connect(ScrDgramSocket *s, double port, ScrStr *host /*borrowed*/, ScrClosure *cb /*moves, nullable*/);
 void scr_dgram_send_str(ScrDgramSocket *s, ScrStr *data /*borrowed*/, double port, ScrStr *host /*borrowed*/);
 void scr_dgram_send_bytes(ScrDgramSocket *s, ScrBytes *data /*borrowed*/, double port, ScrStr *host /*borrowed*/);
+/* The send argument-validation ladder over DOM arguments (Node's
+ * signature shuffle, slice bounds, list/type contracts, port/address
+ * validation, and the connected-state errors); a fully-validated
+ * unconnected single-payload send RUNS, the rest meet the fence. */
+void scr_dgram_send_chk(ScrDgramSocket *s, const ScrDyn *buffer, const ScrDyn *a1,
+                        const ScrDyn *a2, const ScrDyn *a3, const ScrDyn *a4,
+                        const ScrStr *fence);
 /* address() parts: ip THROWS "Not running" before bind/connect (+1
  * otherwise); family/port are only called after ip succeeded. */
 ScrStr *scr_dgram_addr_ip(ScrDgramSocket *s);     /* +1, may throw */