@scriptc/runtime 0.0.11 → 0.0.13

package/src/scr_runtime.h

@@ -397,7 +397,7 @@ enum {
 
 extern ScrVt scr_error_vts[5]; /* indexed by SCR_ERR_*; main() stamps pre/post */
 
-struct ScrDyn; /* full declaration below (the DOM section) */
+struct ScrDyn; /* full declaration below (the checked-dynamic tree section) */
 
 /* DOMException: the ScrError prefix (identical member order — an upcast is
  * a pointer reinterpret) plus the WebIDL slots. The extra slots are HIDDEN
@@ -415,11 +415,11 @@ typedef struct ScrDomException {
   struct ScrDyn *cause; /* owned; NULL when has_cause is false */
 } ScrDomException;
 
-/* new DOMException(message?, nameOrOptions?) — both DOM args borrowed,
- * NULL-tolerant (NULL = absent = the DOM undefined). Returns +1. Never
- * throws (DOM ToString is total). Lives in scr_json.c (the args are DOM
+/* new DOMException(message?, nameOrOptions?) — both dyn args borrowed,
+ * NULL-tolerant (NULL = absent = the dyn undefined). Returns +1. Never
+ * throws (dyn ToString is total). Lives in scr_json.c (the args are dyn
  * values); the dyn-free half below stays in scr_error.c so the error
- * unit links without the DOM. */
+ * unit links without the checked-dynamic tree. */
 ScrError *scr_domex_new(const struct ScrDyn *message, const struct ScrDyn *name_or_options);
 /* scr_error.c's dyn-free DOMException half: the blank allocation the
  * constructors fill, the WebIDL name→legacy-code table, and the cause
@@ -429,7 +429,7 @@ double scr_domex_code_of(const ScrStr *name);
 void scr_domex_install_cause_drop(void (*fn)(void *obj));
 double scr_domex_code(ScrError *e);           /* borrowed receiver */
 bool scr_domex_has_cause(ScrError *e);        /* borrowed receiver */
-struct ScrDyn *scr_domex_cause(ScrError *e);  /* +1 (DOM undefined when absent) */
+struct ScrDyn *scr_domex_cause(ScrError *e);  /* +1 (dyn undefined when absent) */
 /* structuredClone of a DOMException: WebIDL serialization — name/message
  * copy, the code re-derives, cause does not serialize. Borrowed receiver
  * and options (validated; throws on bad options / non-empty transfer).
@@ -672,9 +672,9 @@ 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);
 
-/* querystring.stringify — Node's stringify over a borrowed DOM value (the
+/* 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 DOMs answer "" like Node; object keys iterate in
+ * through). Non-object dyn values answer "" like Node; object keys iterate in
  * JS own-key order (scr_dyn_obj_keys — array-index keys ascending first,
  * then insertion order, Node's ObjectKeys). Values serialize per Node's
  * encodeStringified: strings escape, finite numbers render shortest-
@@ -692,8 +692,8 @@ ScrStr *scr_qs_stringify(const struct ScrDyn *obj, const ScrStr *sep,
  * well-formed-UTF-8 invariant. Borrows s; result +1. */
 ScrStr *scr_encode_uri(ScrStr *s);
 /* atob/btoa — the WHATWG base64 globals (Node globals since v16). The
- * argument is a borrowed DOM value: WebIDL ToString runs here over the
- * DOM kind (Node's atob(null) decodes "null"). scr_atob decodes
+ * argument is a borrowed dyn value: WebIDL ToString runs here over the
+ * dyn kind (Node's atob(null) decodes "null"). scr_atob decodes
  * forgiving-base64 (ASCII whitespace stripped, %4==0 strips up to two
  * '=', %4==1 refuses, leftover bits discarded) into the latin1 code
  * points as a UTF-8 string; malformed input THROWS the catchable
@@ -1558,7 +1558,7 @@ void scr_stream_st_trace(ScrStreamState *st, ScrTraceVisit visit, void *ctx);
 /* The dyn-flavored completion-callback glues (the JS lane's implicitly-
  * any option callbacks / underscore methods): the emitted invoke thunks
  * mint a callable dyn (scr_dyn_new_func) over a 1-cap closure boxing the
- * retained stream, with the kind's glue — arguments arrive as DOM
+ * retained stream, with the kind's glue — arguments arrive as dyn
  * values (error: null/undefined, a {message} object, or a string;
  * transform/flush data: bytes, a string, or absent). */
 typedef struct ScrDyn ScrDyn; /* full declaration below (C11 repeat) */
@@ -1613,7 +1613,7 @@ ScrPromise *scr_sp_pipeline(double n, ScrStream **streams);
  * 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
+ * result is a +1 dyn 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. */
@@ -1809,7 +1809,7 @@ ScrStr *scr_caught_to_string(const ScrCaught *c);
  * checks. */
 void *scr_caught_check_obj(const ScrCaught *c, size_t pre, size_t post,
                             const char *cls);
-/* The snapshot as a DOM value (scr_json.c): identity-preserving for dyn
+/* The snapshot as a dyn value (scr_json.c): identity-preserving for dyn
  * payloads and %Error instances, scalars by value, the type-erased empty
  * object for the rest (SEMANTICS.md 67). Borrows the box; +1. */
 typedef struct ScrDyn ScrDyn; /* full definition below (C11 repeat) */
@@ -2062,7 +2062,7 @@ ScrPromise *scr_tp_set_immediate(void);
  * A process-global name→channel registry; channel handles are 1-based
  * f64 indexes into it (Node's channels are process-lived too, its
  * WeakRef machinery aside — the registry tears down atexit before the
- * RC audit). Subscribers are DOM FUNCTION values, identity-matched by
+ * RC audit). Subscribers are dyn FUNCTION values, identity-matched by
  * unsubscribe (the underlying closure, so re-boxings of one function
  * still match — JS has ONE function object). publish calls each
  * subscriber of a SNAPSHOT with (message, name); a subscriber's throw
@@ -2086,8 +2086,8 @@ ScrStr *scr_dc_chan_name(double handle);
  * handlers object's five event keys (truthy slots route to the per-channel
  * add/remove — a non-function slot throws there, Node's order);
  * unsubscribe answers Node's all-found conjunction. traceSync/traceCallback
- * mirror Node's publish choreography over the DOM: ctx must be an OBJ (the
- * lowering builds the default `{}`), fn/thisArg/args are DOM values (args
+ * mirror Node's publish choreography over the checked-dynamic tree: ctx must be an OBJ (the
+ * lowering builds the default `{}`), fn/thisArg/args are dyn values (args
  * an ARR of the call arguments); the traced call binds thisArg as the
  * ambient receiver; result/error stamp onto ctx before end/error publish;
  * a traced throw and a subscriber throw both propagate (MAY THROW). All
@@ -2553,15 +2553,15 @@ double scr_os_ifaddrs_scopeid(const ScrIfaddrs *s, size_t i);
 void scr_os_ifaddrs_free(ScrIfaddrs *s);
 
 /* ── JSON + dynamic values (scr_json.c) ─────────────────────────────
- * A dyn value — the compiled form of `unknown` — is a refcounted JSON DOM
+ * A dyn value — the compiled form of `unknown` — is a refcounted JSON dyn
  * tree: the result of JSON.parse, inert until a CHECKED CAST validates it
  * against a static type. The compiler emits the validation walkers
  * (sc_dc_* builders / sc_dm_* match predicates) and the type-directed
  * stringify serializers (sc_jw_*) per program; this runtime slice provides
- * the DOM itself, the RFC 8259 parser, the shared failure path
+ * the checked-dynamic tree itself, the RFC 8259 parser, the shared failure path
  * (scr_dyn_check_fail), and the output buffer the serializers append to.
  *
- * Ownership: the DOM owns its children (strings, items, entry keys+values);
+ * Ownership: the checked-dynamic tree owns its children (strings, items, entry keys+values);
  * releasing the root releases the tree recursively. scr_json_parse borrows
  * the text and returns +1 — or THROWS a catchable string shaped like Node's
  * V8 messages ("Unexpected end of JSON input"; approximate fidelity, see
@@ -2577,15 +2577,15 @@ typedef enum {
   SCR_DYN_ARR,
   SCR_DYN_OBJ,
   /* The undefined VALUE. Never produced by the parser (JSON text has no
-   * undefined) — it enters the DOM through index-signature overflow reads
+   * undefined) — it enters the checked-dynamic tree through index-signature overflow reads
    * (a missing key), optional-chain unit paths on dyn results, and the
-   * compiler's static→DOM converters (an undefined-armed union's unit
+   * compiler's static→dyn converters (an undefined-armed union's unit
    * arm). One immortal instance (scr_dyn_undefined); JSON serialization
    * drops object members holding it and prints null for array slots,
    * exactly Node. dynCheck matches it against exactly the undefined arm. */
   SCR_DYN_UNDEF,
   /* A Uint8Array/Buffer VALUE. Never produced by the parser — it enters
-   * the DOM through the compiler's static→DOM converters (a bytes<u8>
+   * the checked-dynamic tree through the compiler's static→dyn converters (a bytes<u8>
    * value flowing into an `unknown` slot: stdin chunks passed to
    * unknown-typed helpers). Owns a ScrBytes payload (a COPY of the static
    * source — the boundary's aliasing stance). typeof answers "object"
@@ -2594,13 +2594,13 @@ typedef enum {
    * object form ({"0":1}), and dynCheck extracts a fresh copy against a
    * Uint8Array target. */
   SCR_DYN_BYTES,
-  /* A FUNCTION value. Never produced by the parser — it enters the DOM
-   * through the compiler's static→DOM converters (a typed closure flowing
+  /* A FUNCTION value. Never produced by the parser — it enters the checked-dynamic tree
+   * through the compiler's static→dyn converters (a typed closure flowing
    * into an `unknown` slot: `mustCall(fn)`-style untyped JS helpers). Owns
    * a ScrClosure plus a compiler-emitted CALL THUNK that validates dyn
    * arguments into the closure's declared parameter types (per-arg
    * dynCheck — JS arity semantics: extra args ignored, missing args are
-   * the undefined DOM value) and converts the result back to a DOM value.
+   * the undefined dyn value) and converts the result back to a dyn value.
    * `sig` is the compiler's interned signature key: dynCheck against an
    * IDENTICAL function type unwraps the closure directly; any other
    * (adaptable) function target wraps the box in a per-target adapter
@@ -2612,7 +2612,7 @@ typedef enum {
   /* A NATIVE HANDLE value (httpReq/httpRes/netSocket crossing the checked-
    * dynamic boundary — `server.on('request', mustCall((req, res) => ...))`
    * makes the listener dyn, so the event tuple must box). Never produced
-   * by the parser — it enters the DOM through the compiler's static→DOM
+   * by the parser — it enters the checked-dynamic tree through the compiler's static→dyn
    * converters and the per-target function adapters. Boxes by REFERENCE
    * (a retained pointer + a handle-type tag): handles are stateful I/O
    * objects, so identity is the HANDLE, not the box — strict equality
@@ -2627,12 +2627,12 @@ typedef enum {
    * "[object Object]" (Object.prototype.toString — Node's answer for
    * these classes), JSON serialization and util.inspect fence loudly. */
   SCR_DYN_HANDLE,
-  /* A PROMISE value. Never produced by the parser — it enters the DOM
-   * through the compiler's static→DOM converters (a promise flowing into
+  /* A PROMISE value. Never produced by the parser — it enters the checked-dynamic tree
+   * through the compiler's static→dyn converters (a promise flowing into
    * an `any`/`unknown` slot: the traced-function boundary of
    * dc.tracingChannel.tracePromise, a dyn-boxed async closure's return).
    * Boxes by REFERENCE (a retained ScrPromise + the boundary contract
-   * that a DOM-crossing promise settles with a DOM payload: promise<dyn>
+   * that a dyn-crossing promise settles with a dyn payload: promise<dyn>
    * boxes its ScrPromise directly, other inner types box an ADAPTER
    * promise whose emitted settle callback converts the payload — see
    * scr_dyn_new_promise_adapting). Identity is the PROMISE, not the box
@@ -2646,31 +2646,31 @@ 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
+  /* An ISLAND (engine-held) value — the jsval→dyn crossing. Never
+   * produced by the parser — it enters the checked-dynamic tree 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
+   * to the native dyn 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
+   * kinds the checked-dynamic tree 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
+   * per use (scr_dyn_jsval_ops); every dyn 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
+   * collector (the dyn→closure stance): a cycle dyn → cell → engine
+   * object → host closure → dyn 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
+/* The handle-type tags the checked-dynamic tree can carry. The set is deliberately the
  * HANDLE kinds whose member surfaces already have complete static
  * lowerings (the http/net receiver surface); new kinds join by adding a
  * tag + an ops registration in their owning unit. */
@@ -2681,6 +2681,8 @@ typedef enum {
   SCR_DYNH_NET_SERVER, /* ScrNetServer — net.Server (http.Server rides the same handle) */
   SCR_DYNH_H2_SESSION, /* ScrH2Session — Http2Session (client & server) */
   SCR_DYNH_H2_STREAM,  /* ScrH2Stream — Http2Stream (client & server) */
+  SCR_DYNH_HTTP_CLIENT, /* ScrHttpClientReq — http.ClientRequest */
+  SCR_DYNH_HTTP_AGENT,  /* ScrHttpAgent — http.Agent / https.Agent */
   SCR_DYNH_COUNT,
 } ScrDynHandleTag;
 
@@ -2688,7 +2690,7 @@ 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
+                                   * always-linked dyn core never touches
                                    * its engine value — only the gated ops
                                    * installed by scr_dyn_from_jsval do) */
 
@@ -2696,7 +2698,7 @@ typedef struct ScrJsval ScrJsval; /* opaque island cell (C11 repeat; the
  * dyn arguments against the boxed closure's declared parameter types (a
  * mismatch throws the catchable path-annotated TypeError and returns NULL
  * with the exception pending), calls through the closure, and returns the
- * result as an owned (+1) DOM value. `args` entries are BORROWED. */
+ * result as an owned (+1) dyn value. `args` entries are BORROWED. */
 typedef ScrDyn *(*ScrDynThunk)(ScrClosure *clo, ScrDyn *const *args, size_t argc);
 
 /* Object member. Keys are malloc'd UTF-8 bytes (NUL-terminated for
@@ -2717,7 +2719,7 @@ struct ScrDyn {
    * 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
+   * object with NO prototype. Method dispatch needs nothing (the checked-dynamic tree'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
@@ -2748,7 +2750,7 @@ struct ScrDyn {
      * settle — the settle-releases-listeners story. */
     struct { void *ptr; ScrDynHandleTag tag; } handle;
     /* SCR_DYN_PROMISE: the retained promise. The boundary contract: it
-     * settles with a DOM payload (SCR_EXC_REF ScrDyn fulfillment or a
+     * settles with a dyn payload (SCR_EXC_REF ScrDyn fulfillment or a
      * void fulfillment awaiters read as the undefined value) — the
      * emitted converters guarantee it (direct box for promise<dyn>,
      * adapter promise otherwise). */
@@ -2776,22 +2778,22 @@ ScrDyn *scr_json_parse(ScrStr *text);
 /* BORROWED member lookup on a SCR_DYN_OBJ; NULL when the key is absent. */
 ScrDyn *scr_dyn_obj_get(const ScrDyn *d, const char *key, size_t key_len);
 
-/* Object.keys/values/entries over the DOM: JS own-key order (array-index
- * keys ascending first), DOM-array results (+1); values/entries RETAIN
+/* Object.keys/values/entries over the checked-dynamic tree: JS own-key order (array-index
+ * keys ascending first), dyn-array results (+1); values/entries RETAIN
  * 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
+/* Object.hasOwn over a dyn 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
+/* Object.assign over dyn values (+1 target back; ToObject TypeError on a
  * 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
+ * every source into one fresh dyn 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
@@ -2807,8 +2809,8 @@ 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);
 
-/* DOM construction — the compiler-emitted static→dyn converters (sc_td_*)
- * and index-signature overflow machinery build DOM values directly.
+/* dyn construction — the compiler-emitted static→dyn converters (sc_td_*)
+ * and index-signature overflow machinery build dyn values directly.
  * Constructors return +1; _new_str RETAINS the string into the node.
  * arr_push and obj_set take OWNERSHIP of the value (+1 moves in); obj_set
  * COPIES the key bytes and replaces a duplicate key's value (later wins,
@@ -2836,25 +2838,35 @@ 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
+ * dyn'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);
-/* Destructuring pack over a DOM source: iterable kinds (arrays, strings by
+/* Destructuring pack over a dyn 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);
+/* The for-of-over-dyn pack accessors (the emitted index loop drives them
+ * over a scr_dyn_iter_pack result, which is ARR by construction).
+ * scr_dyn_arr_len answers 0 for non-ARR kinds; scr_dyn_arr_at answers the
+ * undefined singleton past the end (both never throw). scr_dyn_arr_at is
+ * +1. */
+double scr_dyn_arr_len(const ScrDyn *d);
+ScrDyn *scr_dyn_arr_at(const ScrDyn *d, double i);
 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
  * non-object kinds throw Node's catchable TypeErrors (strict-mode
  * wording). All three operands BORROWED (the value is retained in). */
 void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value);
-/* Bare `typeof v` on a dyn value: the DOM kind's JS answer (+1 string;
+/* `key in v` with a runtime key — the dynHasKey fold per value (OBJ own
+ * members, ARR length/valid indices, false elsewhere). Never throws. */
+bool scr_dyn_has_key(const ScrDyn *v, const ScrStr *key);
+/* Bare `typeof v` on a dyn value: the dyn kind's JS answer (+1 string;
  * null answers "object"). Never throws. */
 ScrStr *scr_dyn_typeof(const ScrDyn *d);
 /* Receiver-kind-dispatched toString() (Buffer-flavored bytes decode per
@@ -2865,7 +2877,7 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc);
  * 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
+/* JS String() over the dyn 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
@@ -2874,14 +2886,14 @@ ScrStr *scr_dyn_string_coerce(const ScrDyn *d);
 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
+ * checked-dynamic value: the from_error cache resolves the dyn encoding
  * back to its runtime error and the class's stamped preorder interval
- * answers. A DOM value that never came from an error answers false. */
+ * answers. A dyn value that never came from an error answers false. */
 bool scr_dyn_err_instanceof(const ScrDyn *d, double kind);
 
-/* structuredClone over the DOM: JSON-safe data + bytes deep-copy;
+/* structuredClone over the checked-dynamic tree: JSON-safe data + bytes deep-copy;
  * functions/handles throw the spec's catchable DataCloneError; cycles
- * throw the scriptc fence (the DOM cannot represent them). Option
+ * throw the scriptc fence (the checked-dynamic tree cannot represent them). Option
  * validation (shared with scr_domex_clone) throws Node's exact
  * TypeErrors; any non-empty transfer list throws DataCloneError. The
  * _missing form is the zero-argument call: always throws Node's
@@ -2889,13 +2901,13 @@ bool scr_dyn_err_instanceof(const ScrDyn *d, double kind);
 ScrDyn *scr_structured_clone(const ScrDyn *value, const ScrDyn *options);
 ScrDyn *scr_structured_clone_missing(void);
 ScrDyn *scr_structured_clone_transfer_fail(void); /* always throws DataCloneError */
-/* Validates a structuredClone options DOM value (throws on failure —
+/* Validates a structuredClone options dyn value (throws on failure —
  * callers must check scr_exc_pending). Borrowed, NULL-tolerant. */
 void scr_sc_validate_options(const ScrDyn *options);
-/* An %Error as the boundary's DOM shape ({name, message[, code]}).
+/* An %Error as the boundary's dyn shape ({name, message[, code]}).
  * Borrows; +1. */
 ScrDyn *scr_dyn_from_error(const ScrError *e);
-/* The reverse extraction, riding the same identity cache: a DOM error
+/* The reverse extraction, riding the same identity cache: a dyn error
  * that came from a runtime ScrError answers THAT instance (+1;
  * out-and-back crossings compare reference-equal); alien %error objects
  * rebuild once and enter the cache. Borrows d. */
@@ -2904,16 +2916,16 @@ ScrError *scr_error_from_dyn(const ScrDyn *d); /* scr_async_dyn.c (gated) */
  * the gated extraction reads/writes through these). */
 ScrError *scr_errdyn_err_of(const ScrDyn *d); /* +1 or NULL */
 void scr_errdyn_put(ScrError *e, ScrDyn *d);  /* retains both sides */
-/* ToBoolean over the DOM kind (JS-exact); borrowed, never throws. */
+/* ToBoolean over the dyn kind (JS-exact); borrowed, never throws. */
 bool scr_dyn_truthy(const ScrDyn *d);
-/* JS String() over a DOM value (arrays join, [object Object], the error
+/* JS String() over a dyn value (arrays join, [object Object], the error
  * encoding renders "name: message"); borrowed, result +1, never throws. */
 ScrStr *scr_dyn_display(const ScrDyn *d);
-/* JS === over two DOM values: scalars by value, units by kind, everything
+/* JS === over two dyn values: scalars by value, units by kind, everything
  * reference-shaped by node identity. Borrowed; never throws. */
 bool scr_dyn_strict_eq(const ScrDyn *a, const ScrDyn *b);
 /* Prototype-method dispatch on a dyn receiver (`recv.m(...)` where `m` is
- * a name a DOM-representable prototype declares — push/slice/forEach/
+ * a name a dyn-representable prototype declares — push/slice/forEach/
  * apply/...): implemented (kind, name) pairs run JS-exact semantics; a
  * real-but-unimplemented method throws a LOUD "not supported yet" Error;
  * a name the kind's prototype lacks throws Node's "<what> is not a
@@ -2925,14 +2937,14 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
  * for anonymous) and "length" (the boxed arity). Returns +1, or NULL when
  * the key answers nothing (the caller's undefined). Never throws. */
 ScrDyn *scr_dyn_fn_get(const ScrDyn *d, const char *key, size_t key_len);
-/* Object.defineProperties over DOM values (targets: OBJ and FUNC): each
+/* Object.defineProperties over dyn values (targets: OBJ and FUNC): each
  * descriptor's `value` becomes a plain own property — writable/enumerable/
- * configurable are accepted and IGNORED (DOM properties are plain data
+ * configurable are accepted and IGNORED (dyn properties are plain data
  * properties; SEMANTICS.md), get/set throw the loud unsupported Error.
  * Returns the target (+1, JS's return), or NULL with a pending catchable
  * TypeError (non-object target/descriptor — Node's messages). */
 ScrDyn *scr_dyn_define_props(ScrDyn *target, ScrDyn *descs);
-/* Boxes a closure as a callable DOM value. Ownership of `clo` MOVES in
+/* Boxes a closure as a callable dyn value. Ownership of `clo` MOVES in
  * (callers retain first when they keep their own reference); `sig`/`name`
  * must be static literals (the box never frees them; name may be NULL). */
 ScrDyn *scr_dyn_new_func(ScrClosure *clo, ScrDynThunk thunk, uint32_t arity, const char *sig, const char *name);
@@ -2942,7 +2954,7 @@ 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 —
+/* scr_dyn_call over a dyn 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);
@@ -2964,7 +2976,7 @@ typedef struct ScrDynPath {
  * scriptc-specific behavior — JS `as` never checks (SEMANTICS.md). */
 void scr_dyn_check_fail(const ScrDynPath *path, const char *want, const ScrDyn *got);
 
-/* ── native handles in the DOM (SCR_DYN_HANDLE) ────────────────────────
+/* ── native handles in the checked-dynamic tree (SCR_DYN_HANDLE) ────────────────────────
  * Per-tag dispatch ops, registered by the handle's owning unit
  * (scr_http_dyn_install / scr_net_dyn_install — emitted main() calls
  * them exactly when the unit is linked, the scr_net_install story), so
@@ -2983,7 +2995,7 @@ typedef struct ScrDynHandleOps {
   ScrDyn *(*invoke)(void *h, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, const char *what);
   /* Property READ with a static equivalent (req.url, res.statusCode):
    * +1 boxed value; NULL = no such modeled property (the caller answers
-   * the undefined singleton — the DOM's own-property stance); may throw
+   * the undefined singleton — the checked-dynamic tree's own-property stance); may throw
    * the loud ladder for real-but-unmodeled names (NULL + pending). */
   ScrDyn *(*get)(void *h, const char *key, size_t key_len);
   /* Property WRITE with a static equivalent (res.statusCode = 200):
@@ -3019,13 +3031,13 @@ ScrDyn *scr_dyn_new_handle(void *h, ScrDynHandleTag tag);
 void *scr_dyn_handle_unbox(const ScrDyn *d, ScrDynHandleTag tag, const ScrDynPath *path, const char *want);
 /* Keyed read on a HANDLE box (the emitted sc_dyn_key_get's arm): the
  * tag's modeled properties answer boxed values; everything else answers
- * the undefined singleton (the DOM's own-property stance — SEMANTICS.md)
+ * the undefined singleton (the checked-dynamic tree's own-property stance — SEMANTICS.md)
  * unless the ops fence it loudly. +1, or NULL with a pending exception. */
 ScrDyn *scr_dyn_handle_key_get(const ScrDyn *d, const ScrStr *k);
 
-/* ── promises in the DOM (SCR_DYN_PROMISE) ────────────────────────────
+/* ── promises in the checked-dynamic tree (SCR_DYN_PROMISE) ────────────────────────────
  * Boxes by REFERENCE (+1 box; retains p). The boundary contract: p
- * settles with a DOM payload — promise<dyn> boxes directly; other inner
+ * settles with a dyn payload — promise<dyn> boxes directly; other inner
  * types go through scr_dyn_new_promise_adapting, which parks an emitted
  * payload-converting adapter (the Promise.race cb-waiter machinery) on
  * `src` and boxes the fresh destination promise instead. Rejections copy
@@ -3042,7 +3054,7 @@ 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) ─────────────────────────
+/* ── island values in the checked-dynamic tree (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
@@ -3062,7 +3074,7 @@ typedef struct ScrDynJsvalOps {
   /* ── 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
+   * cells unwrap by reference, dyn data deep-copies, dyn 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. */
@@ -3077,19 +3089,28 @@ typedef struct ScrDynJsvalOps {
   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. */
+  /* Object.keys/values/entries (mode 0/1/2) as a NATIVE dyn array (+1):
+   * keys are dyn strings, values wrap per element, entries are native
+   * dyn 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
+   * member semantics (a wrapped src spreads by reference; dyn 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);
+  /* Drain the ENGINE's own iterator protocol into a fresh dyn array
+   * (elements wrap back scalar-normalized) — the for-of/destructuring/
+   * spread arm over a wrapped value. The guard's TypeError wording on a
+   * non-iterable: spread true takes V8's spread-call text; otherwise the
+   * compile-time spelling `spell` verbatim when non-NULL (the named-
+   * source form), else the kind wording. An iterating getter/next throw
+   * bridges with the ENGINE's message. +1, or NULL with the exception
+   * pending. */
+  ScrDyn *(*iter_drain)(ScrJsval *cell, bool spread, const ScrStr *spell);
 } ScrDynJsvalOps;
 
 /* The allocator view the gated constructor uses (installs the ops);
@@ -3115,7 +3136,7 @@ bool scr_dyn_isl_fence(const ScrDyn *d, const char *what);
  * 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
+/* The `??`/optional-chain nullish test over a dyn 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. */
@@ -3141,7 +3162,7 @@ bool scr_dyn_is_nullish(const ScrDyn *d);
 void scr_dyn_this_push(void *h, ScrDynHandleTag tag); /* h BORROWED (the firing site holds it); NULL binds undefined */
 void scr_dyn_this_push_dyn(const ScrDyn *v);          /* retained for the window */
 void scr_dyn_this_pop(void);
-/* The innermost binding as a DOM value (+1): a boxed handle, the pushed
+/* The innermost binding as a dyn value (+1): a boxed handle, the pushed
  * dyn value, or the undefined singleton (empty stack, NULL handle, or a
  * handle whose tag has no installed ops — a unit that fires without its
  * dyn half never binds). */
@@ -3153,7 +3174,7 @@ ScrDyn *scr_dyn_this_get(void);
 void scr_dyn_chunk_enc(bool utf8);
 ScrDyn *scr_dyn_new_chunk(const ScrBytes *b);
 
-/* util.format's %j over a DOM value: the JSON.stringify text (+1),
+/* util.format's %j over a dyn value: the JSON.stringify text (+1),
  * "undefined" when the root drops (undefined/function), or NULL with a
  * pending exception (a runtime handle inside the tree fences loudly). */
 ScrStr *scr_dyn_format_j(const ScrDyn *d);
@@ -3191,7 +3212,7 @@ void scr_throw_lowering_fence(const ScrStr *msg);
 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
+ * whose invoke boxes the event tuple back into the checked-dynamic tree and calls through
  * the checked-dynamic machinery. The matching fn-pointer shapes are the
  * per-event thunk types the registration entries take (fire0's zero-arg
  * convention / ScrNetDataFn / ScrChildErrFn). cb borrowed; result +1. */
@@ -3250,7 +3271,7 @@ void scr_jb_edge_idx(ScrJsonBuf *b, size_t i);
 
 /* Circular guard for the compiler-emitted typed→dyn converters (sc_td_*
  * over cycle-capable containers): enter TRAPS on a value already being
- * converted (a cyclic value has no finite DOM copy — Node shares the
+ * converted (a cyclic value has no finite dyn copy — Node shares the
  * reference instead; SEMANTICS.md), else pushes. */
 void scr_dyn_from_enter(const void *v);
 void scr_dyn_from_leave(void);
@@ -3269,7 +3290,7 @@ void scr_jb_put_json_str(ScrJsonBuf *b, const ScrStr *s);
  * 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
+/* JSON-serialize a dyn 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). */
 void scr_jb_put_dyn(ScrJsonBuf *b, const ScrDyn *d);
@@ -3313,23 +3334,23 @@ bool scr_await_bool(ScrPromise *p);
 ScrStr *scr_await_str(ScrPromise *p); /* +1 */
 void *scr_await_ref(ScrPromise *p);   /* +1 via the stored retain */
 void scr_await_void(ScrPromise *p);
-/* The DOM-crossing await (SCR_DYN_PROMISE's boundary contract): the
- * payload as a DOM value (+1; void fulfillments answer the undefined
+/* The checked-dynamic tree-crossing await (SCR_DYN_PROMISE's boundary contract): the
+ * payload as a dyn value (+1; void fulfillments answer the undefined
  * value), or NULL with the rejection re-thrown into the awaiter. */
 ScrDyn *scr_await_dyn(ScrPromise *p);
-/* `await v` over a checked-dynamic VALUE: DOM promises adopt, everything
+/* `await v` over a checked-dynamic VALUE: dyn promises adopt, everything
  * else takes JS's one-hop non-thenable await and answers itself (+1). */
 ScrDyn *scr_await_dyn_value(ScrDyn *v);
-/* .then/.catch/.finally over a DOM promise (scr_dyn_invoke's promise arm
+/* .then/.catch/.finally over a dyn promise (scr_dyn_invoke's promise arm
  * and the compiled dyn-receiver path): one reaction fiber per
- * registration — awaits src, runs the DOM handler (non-callable handlers
- * pass the settlement through; a returned DOM promise is adopted), and
+ * registration — awaits src, runs the checked-dynamic tree handler (non-callable handlers
+ * pass the settlement through; a returned dyn promise is adopted), and
  * settles a fresh result promise, answered BOXED (+1). Microtask-exact
  * ordering rides the fiber machinery. */
 ScrDyn *scr_dyn_promise_then(ScrPromise *src, ScrDyn *onf, ScrDyn *onr, ScrDyn *onfin);
 /* ── AsyncLocalStorage (node:async_hooks — scr_async.c) ───────────────
  * Stores are process-lived f64 handles; the CONTEXT is an immutable
- * refcounted snapshot of (store → DOM value) entries riding the fiber
+ * refcounted snapshot of (store → dyn value) entries riding the fiber
  * machinery: one active-slot pointer (the exc-cell pattern) swapped at
  * every fiber switch, inherited by spawned fibers (Node's init-time
  * capture). enter answers the PREVIOUS snapshot (owned) for restore —
@@ -3357,30 +3378,51 @@ ScrAlsCtx *scr_als_enter_absent(double id);         /* exit()'s cleared arm */
 void scr_als_restore(ScrAlsCtx *prev);              /* moves prev back in */
 void scr_als_enter_with(double id, ScrDyn *value);  /* no restore point (enterWith) */
 void scr_als_disable(double id);
-/* run/exit: enter (or clear), call the DOM function with the forwarded
+/* run/exit: enter (or clear), call the dyn function with the forwarded
  * argument vector, restore (the finally). Result +1 or NULL pending. */
 ScrDyn *scr_als_run(double id, ScrDyn *value, ScrDyn *fn, ScrDyn *args);
 ScrDyn *scr_als_exit_run(double id, ScrDyn *fn, ScrDyn *args);
 
-/* process.on('unhandledRejection', fn): DOM listeners dispatched per
- * never-observed rejection at loop end — (reason, promise), suppressing
- * the default report and the exit-1 (Node's handled-event contract; the
- * end-of-turn vs loop-end timing is a SEMANTICS.md divergence). Throws
- * Node's ERR_INVALID_ARG_TYPE on a non-function. */
-void scr_process_on_unhandled_rejection(ScrDyn *fn);
+/* process.on/once('unhandledRejection', fn): dyn listeners dispatched
+ * per never-observed rejection at loop end — (reason, promise),
+ * suppressing the default report and the exit-1 (Node's handled-event
+ * contract; the end-of-turn vs loop-end timing is a SEMANTICS.md
+ * divergence). `once` auto-removes after one delivery; off removes by
+ * closure identity (the warning registry's story). Throws Node's
+ * ERR_INVALID_ARG_TYPE on a non-function. */
+void scr_process_on_unhandled_rejection(ScrDyn *fn, bool once);
+void scr_process_off_unhandled_rejection(ScrDyn *fn);
+/* process.on/once/off('rejectionHandled', fn): the sibling registry.
+ * Under the loop-exhaustion model the event's ONE firing window is a
+ * handler attached DURING an unhandledRejection listener (a rejection
+ * handled any earlier never enters the report at all — the same
+ * documented divergence); dispatch is synchronous at the attach, with
+ * the promise, Node's payload. */
+void scr_process_on_rejection_handled(ScrDyn *fn, bool once);
+void scr_process_off_rejection_handled(ScrDyn *fn);
 /* The loop-end delivery hook the registration above installs
  * (scr_async_dyn.c → scr_report_unhandled_rejections; NULL = default
  * report). Runtime-internal. */
 extern bool (*scr_urj_deliver_fn)(ScrPromise *p);
-/* A rejected promise's reason as a DOM value (identity-preserving for
+/* The late-handled hook (scr_async_dyn.c installs it when a
+ * 'rejectionHandled' listener registers): scr_async.c calls it when a
+ * promise the report already delivered as unhandled gains a handler.
+ * Runtime-internal. */
+extern void (*scr_rjh_notify_fn)(ScrPromise *p);
+/* The attach-time handled mark (a dyn then/catch carrying a rejection
+ * handler): marks an already-rejected source observed — Node's attach
+ * moment — firing the late-handled hook when the report already
+ * delivered it. Runtime-internal. */
+void scr_promise_mark_handled(ScrPromise *p);
+/* A rejected promise's reason as a dyn value (identity-preserving for
  * dyn payloads and %Error instances). +1. */
 ScrDyn *scr_promise_reason_dyn(const ScrPromise *p);
 /* process warnings (scr_lib.c — always linked so any unit can emit a
- * deprecation): DOM listeners plus Node's default stderr report
+ * deprecation): dyn listeners plus Node's default stderr report
  * ("(node:pid) [CODE] Name: message" and a detail second line). Emission
  * is SYNCHRONOUS at the call (Node defers a tick — SEMANTICS.md 138's
  * precedent). scr_process_emit_warning takes the ARGUMENT VECTOR as one
- * DOM array and applies Node's full grammar/TypeErrors; scr_emit_warning
+ * dyn array and applies Node's full grammar/TypeErrors; scr_emit_warning
  * is the C-side deprecation entry. */
 void scr_process_on_warning(ScrDyn *fn);
 void scr_process_off_warning(ScrDyn *fn);
@@ -3460,7 +3502,7 @@ void scr_set_timeout(ScrClosure *cb, double ms); /* cb ownership moves in */
  * works). An unknown handle is a no-op, like Node. */
 double scr_set_interval(ScrClosure *cb, double ms); /* cb ownership moves in */
 /* `new Promise(setImmediate)`: a fresh promise an armed immediate
- * fulfills with the undefined DOM value (+1). */
+ * fulfills with the undefined dyn value (+1). */
 ScrPromise *scr_immediate_promise(void);
 void scr_clear_interval(double handle);
 /* The island timer bridge (scr_web.c): a one-shot entry WITH a clear
@@ -3497,7 +3539,7 @@ double scr_set_immediate(ScrClosure *cb); /* cb ownership moves in */
  * synchronously on a non-function; borrowed. */
 void scr_queue_microtask(ScrClosure *cb);
 void scr_queue_microtask_dyn(const ScrDyn *cb);
-/* setImmediate AS A DOM VALUE (the traceCallback shape): a minted dyn
+/* setImmediate AS A dyn VALUE (the traceCallback shape): a minted dyn
  * callable that schedules args[0](args[1..]) on the immediate queue and
  * answers undefined; a non-function first argument throws Node's
  * ERR_INVALID_ARG_TYPE. Result +1. */
@@ -3947,24 +3989,24 @@ 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 for data
+/* A CHECKED-DYNAMIC (dyn) 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
+ * the checked-dynamic tree 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
+ * shim wraps engine arguments as dyn values (scalar-normalizing), calls
+ * the thunk, and converts the dyn 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
+/* The jsval→dyn 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
+ * strings/booleans/null/undefined convert to the native dyn 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
+ * edge). Installs the checked-dynamic tree'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);
 
@@ -4058,6 +4100,11 @@ enum {
   SCR_ISLP_BOOL = 2,
   SCR_ISLP_STR = 3,
   SCR_ISLP_JSVAL = 4,
+  /* Promise<any[]> — the fulfillment is a native array of engine cells
+   * (the jsval-element-array spelling): it re-enters the engine as a
+   * fresh engine array whose ELEMENTS are the same engine values (the
+   * loadPlugins shape: identity crosses, the spine is a copy). */
+  SCR_ISLP_JSVAL_ARR = 5,
 };
 
 /* Wrap a scriptc promise as an ENGINE promise (async callbacks crossing
@@ -4118,6 +4165,11 @@ ScrStr *scr_jsval_exit_str(ScrJsval *v);
 /* Uint8Array exit (engine Buffers pass — they ARE Uint8Arrays): a fresh
  * u8 COPY (+1), the boundary's aliasing stance; NULL = thrown. */
 ScrBytes *scr_jsval_exit_bytes(ScrJsval *v);
+/* `any[]`-declared slot exit (the jsval-element-array spelling):
+ * Array.isArray-gated, elements BY REFERENCE into a native array of
+ * engine cells (identity crosses, the spine is a snapshot copy). +1;
+ * NULL = thrown. */
+ScrArr *scr_jsval_exit_jsval_arr(ScrJsval *v);
 ScrStr *scr_jsval_to_json(ScrJsval *v);
 
 /* The import boundary (libCall island.import): loads an embedded module —
@@ -4457,7 +4509,7 @@ double scr_bytes_compare(const ScrBytes *src, const ScrBytes *target, double nar
  * 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
+ * argument ladder over dyn-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;
@@ -4470,12 +4522,12 @@ double scr_bytes_compare_chk(const ScrBytes *src, const ScrDyn *target,
 /* 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
+/* fs._toUnixTimestamp over a dyn 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 fs argument-validation ladders (the fs.*Chk libCalls): Node-order
- * validation over DOM values with Node's exact typed errors; a pass
+ * validation over dyn 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. */
@@ -4536,7 +4588,7 @@ ScrStr *scr_insp_buffer(ScrBytes *b);  /* <Buffer aa bb ...>, 50-byte cap */
  * depth when a code makes it composite. */
 ScrStr *scr_insp_error(ScrError *e, double recurse, double depth);
 /* The checked-dynamic tree: shape lives in the value, so the whole
- * traversal is here. dyn-boxed bytes render in the DOM's documented
+ * traversal is here. dyn-boxed bytes render in the checked-dynamic tree's documented
  * Uint8Array identity. */
 ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth);
 /* format's %s / rest-args twin: dyn strings pass verbatim. */
@@ -4597,7 +4649,7 @@ double scr_bytes_write_var(ScrBytes *b, double value, double offset, double byte
  * Buffer forms of scr_lib.c's utf8 pair, byte-exact and NUL-safe.
  * Failures THROW catchably (scr_fs_throw, Node-shaped messages). */
 ScrBytes *scr_fs_read_file_bytes(ScrStr *path); /* +1 */
-/* readFileSync's runtime-encoding form (scr_bytes_io.c's note): +1 DOM
+/* readFileSync's runtime-encoding form (scr_bytes_io.c's note): +1 dyn
  * value — a Buffer box for undefined/null, a string for utf8 — or NULL
  * with the exception pending. */
 ScrDyn *scr_fs_read_file_sync_dyn(ScrStr *path, const ScrDyn *enc);
@@ -4793,6 +4845,22 @@ void scr_net_sock_end_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/);
 void scr_net_sock_write_dynv(ScrNetSocket *s, const ScrDyn *d /*borrowed*/);
 void scr_net_sock_end_dynv(ScrNetSocket *s, const ScrDyn *d /*borrowed*/);
 void scr_net_sock_destroy(ScrNetSocket *s);
+/* Flow control (pause/resume — see the struct's flag comments), the
+ * FIN-flushed destroy (destroySoon), TCP_NODELAY, the deferred write/
+ * finish callbacks (write(chunk, cb) / end(cb) — sweep-fired), and the
+ * counters/flags the compat surface reads. */
+ScrNetSocket *scr_net_sock_pause(ScrNetSocket *s);            /* +1: chaining */
+ScrNetSocket *scr_net_sock_resume(ScrNetSocket *s);           /* +1: chaining */
+ScrNetSocket *scr_net_sock_set_nodelay(ScrNetSocket *s, bool enable); /* +1: chaining */
+void scr_net_sock_destroy_soon(ScrNetSocket *s);
+void scr_net_sock_on_finish(ScrNetSocket *s, ScrClosure *cb /*moves*/);
+void scr_net_sock_on_write_flush(ScrNetSocket *s, ScrClosure *cb /*moves*/);
+double scr_net_sock_bytes_written(ScrNetSocket *s);
+bool scr_net_sock_readable(ScrNetSocket *s);
+/* The deferred dial (the http agent's maxSockets queue): the socket
+ * registers "connecting" and buffers writes; dial_start runs the dial. */
+ScrNetSocket *scr_net_connect_deferred(double port, ScrStr *host /*borrowed, nullable*/); /* +1 */
+void scr_net_sock_dial_start(ScrNetSocket *s);
 void scr_net_sock_set_timeout(ScrNetSocket *s, double ms);
 void scr_net_sock_on_timeout(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once);
 ScrStr *scr_net_sock_remote_address(ScrNetSocket *s); /* +1 or NULL (undefined arm) */
@@ -4819,6 +4887,7 @@ void scr_net_sock_unshift_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/);
 void scr_net_server_emit_connection(ScrNetServer *srv, ScrNetSocket *sock /*borrowed*/);
 void scr_net_data_thunk0(ScrClosure *cb, ScrBytes *chunk);
 void scr_net_data_thunk_bytes(ScrClosure *cb, ScrBytes *chunk);
+void scr_net_data_thunk_str(ScrClosure *cb, ScrBytes *chunk);
 /* The dynCheck-adapted listener's flavor: boxes the chunk as a
  * Buffer-flavored dyn (toString decodes utf8, Node's 'data' payload). */
 void scr_net_data_thunk_dyn(ScrClosure *cb, ScrBytes *chunk);
@@ -4827,7 +4896,7 @@ void scr_net_conn_thunk_sock(ScrClosure *cb, ScrNetSocket *sock);
 void scr_net_install(void);
 /* Registers the netSocket handle-dispatch ops (SCR_DYNH_NET_SOCKET) —
  * emitted main() calls this alongside scr_net_install exactly when the
- * net unit is linked, so the always-linked DOM core never references
+ * net unit is linked, so the always-linked dyn core never references
  * this unit's entry points. */
 void scr_net_dyn_install(void);
 #ifdef SCR_RC_AUDIT
@@ -4922,7 +4991,7 @@ ScrNetServer *scr_tls_create_server(const char *cert, size_t cert_len, const cha
  * drop exactly like Node drops them). cert/key values are PEM strings,
  * Buffers, or one-element arrays of those; `ca` (client side)
  * concatenates array entries into one trust-anchor bundle. The *_dyn
- * creators walk a DOM options record (the checked-dynamic JS lane's
+ * creators walk a dyn options record (the checked-dynamic JS lane's
  * shape) and mint the same servers the literal path mints; NULL returns
  * carry a pending exception. scr_tls_pem_from_dyn is the literal path's
  * runtime-valued cert/key extraction (`what` names the fence). */
@@ -4999,6 +5068,29 @@ void scr_tls_sni_answer(ScrClosure *self, bool has_err, ScrSecureCtx *ctx /*move
 long scr_secure_ctx_live_count(void);
 #endif
 
+/* ── node:tls, the CA-store introspection slice (scr_tls_ca.c — its own
+ * unit and link gate; plain PEM-block bookkeeping, NO mbedTLS, so a
+ * getCACertificates-only binary never builds the archive; cc.ts also
+ * compiles it whenever scr_tls.c does). The HOST bundle (the
+ * /etc/ssl/cert.pem probe order scr_tls.c documents) stands in for both
+ * Node's compiled-in Mozilla roots ('bundled', rootCertificates) and the
+ * platform store ('system') — the established SEMANTICS divergence,
+ * extended to introspection; 'extra' reads NODE_EXTRA_CA_CERTS. Arrays
+ * are cached per type (+1 retained answers each call — Node's own
+ * caching, and the identity the suite pins with strictEqual). */
+ScrArr *scr_tls_ca_get(ScrStr *type); /* +1; throws ERR_INVALID_ARG_VALUE on unknown types */
+ScrArr *scr_tls_ca_root(void);        /* +1; === getCACertificates("bundled") */
+/* Replaces the 'default' set: entries filter to their PEM certificate
+ * blocks (deduped byte-exactly — Node dedupes by X509 identity); a
+ * non-empty array yielding no blocks throws Node's
+ * ERR_CRYPTO_OPERATION_FAILED and leaves the set unchanged. Borrows. */
+void scr_tls_ca_set_default(ScrArr *certs);
+/* scr_tls.c's anchor consult: true iff setDefaultCACertificates ran;
+ * *pem/*len then carry the concatenated NUL-terminated blocks (len 0 =
+ * the empty set — verification fails, Node's own consequence), and *gen
+ * a counter that bumps per set so the parsed chain re-parses on change. */
+bool scr_tls_ca_default_override(const char **pem, size_t *len, uint64_t *gen);
+
 /* ── node:http, the server slice (scr_http.c — compiled only when the
  * program uses it; rides scr_net.c wholesale, design note atop the
  * file). http.createServer returns an ORDINARY ScrNetServer (listen/
@@ -5154,6 +5246,23 @@ void scr_http_upgrade_thunk3(ScrClosure *cb, ScrHttpReq *req, ScrNetSocket *sock
 double scr_http_req_status(ScrHttpReq *r); /* < 0 = the undefined arm (server request) */
 ScrNetSocket *scr_http_req_socket(ScrHttpReq *r); /* +1 */
 void scr_http_req_resume(ScrHttpReq *r);
+/* pause()/resume() hold and drain 'data'/'end' delivery (the parser keeps
+ * consuming; the drain rides the emit queue); setTimeout delegates to the
+ * socket's idle timer; the flags back req.destroyed/req.readable. */
+void scr_http_req_pause(ScrHttpReq *r);
+void scr_http_req_set_timeout(ScrHttpReq *r, double ms, ScrClosure *cb /*moves, nullable*/);
+bool scr_http_req_destroyed_flag(ScrHttpReq *r);
+bool scr_http_req_readable(ScrHttpReq *r);
+/* flushHeaders/cork/uncork/writableCorked, the res.req backref, the
+ * socket-delegated setTimeout, and write(chunk, cb)'s deferred callback. */
+void scr_http_res_flush_headers(ScrHttpRes *r);
+void scr_http_res_cork(ScrHttpRes *r);
+void scr_http_res_uncork(ScrHttpRes *r);
+double scr_http_res_writable_corked(ScrHttpRes *r);
+bool scr_http_res_destroyed_flag(ScrHttpRes *r);
+void scr_http_res_set_req(ScrHttpRes *r, ScrHttpReq *req /*borrowed, nullable*/);
+void scr_http_res_set_timeout(ScrHttpRes *r, double ms, ScrClosure *cb /*moves, nullable*/);
+void scr_http_res_on_write_flush(ScrHttpRes *r, ScrClosure *cb /*moves*/);
 /* req.setEncoding(enc) — the socket twin's contract; may throw. */
 void scr_http_req_set_encoding(ScrHttpReq *r, ScrStr *enc /*borrowed*/);
 void scr_http_req_destroy(ScrHttpReq *r);
@@ -5218,6 +5327,30 @@ ScrHttpClientReq *scr_http_request_ex(ScrStr *host /*borrowed*/, double port,
 ScrHttpClientReq *scr_http_request_url(ScrStr *url /*borrowed*/, ScrStr *method /*borrowed*/,
                                         bool auto_end, ScrClosure *cb /*moves, nullable*/,
                                         ScrHttpRespFn fn); /* +1 */
+/* ── the http Agent (new http.Agent(opts) — option surface, getName, and
+ * the maxSockets queue over one-dial-per-request connections; keep-alive
+ * POOLING is not modeled: keepAlive: true fences at construction).
+ * agent_new answers the SCR_DYNH_HTTP_AGENT handle (+1 dyn) or throws.
+ * max_sockets/max_free arrive < 0 for "unset" (Infinity / 256);
+ * timeout_ms < 0 = no idle timer. request_agent_ex threads the agent dyn
+ * (undefined/null = the default path; false = one-shot with Connection:
+ * close; an Agent handle = queue accounting); port < 0 means "no port
+ * option" — the agent's (settable) defaultPort, then the scheme's. */
+ScrDyn *scr_http_agent_new(bool secure, bool keep_alive, double ka_msecs,
+                            double max_sockets, double max_free, double timeout_ms,
+                            double port /* < 0 = unset: the option-merge default */); /* +1 */
+ScrHttpClientReq *scr_http_request_agent_ex(ScrStr *host /*borrowed*/, double port,
+                                             ScrStr *path /*borrowed*/, ScrStr *method /*borrowed*/,
+                                             double timeout_ms, ScrArr *header_pairs /*borrowed*/,
+                                             bool auto_end, const ScrDyn *agent /*borrowed*/,
+                                             ScrClosure *cb /*moves, nullable*/,
+                                             ScrHttpRespFn fn, int default_port,
+                                             void (*wrap)(ScrNetSocket *, void *), void *wrap_ctx); /* +1 */
+ScrHttpClientReq *scr_http_request_agent(ScrStr *host /*borrowed*/, double port,
+                                          ScrStr *path /*borrowed*/, ScrStr *method /*borrowed*/,
+                                          double timeout_ms, ScrArr *header_pairs /*borrowed*/,
+                                          bool auto_end, const ScrDyn *agent /*borrowed*/,
+                                          ScrClosure *cb /*moves, nullable*/, ScrHttpRespFn fn); /* +1 */
 #ifdef SCR_RC_AUDIT
 long scr_http_live_count(void);
 #endif
@@ -5262,6 +5395,19 @@ ScrNetServer *scr_http2_create_server_req(ScrClosure *handler /*moves*/, ScrHttp
  * the same session machinery behind an mbedTLS handshake whose ALPN
  * advertises h2 alone — protocol-identical after establishment. */
 ScrNetServer *scr_http2_create_secure_server(const char *cert, size_t cert_len, const char *key, size_t key_len); /* +1 */
+/* createSecureServer(options, handler): the eager COMPAT handler as the
+ * first 'request' listener over the ALPN=h2 server (the createServerReq
+ * route, secured). */
+ScrNetServer *scr_http2_create_secure_server_req(const char *cert, size_t cert_len, const char *key, size_t key_len, ScrClosure *handler /*moves, nullable*/, ScrHttpReqFn fn); /* +1 */
+/* createSecureServer with a RUNTIME options record (the divergence-66
+ * stance): allowHTTP1 picks the flavor at runtime, cert/key ride the
+ * shared TLS server walk (out-of-bounds members throw the catchable
+ * fence), h2 session-tuning keys drop like the literal walk ignores
+ * them. +1, or NULL with the exception pending. */
+ScrNetServer *scr_http2_create_secure_server_dyn(const struct ScrDyn *opts /*borrowed*/, ScrClosure *handler /*moves, nullable*/, ScrHttpReqFn fn);
+/* The TLS server-options walk (scr_tls.c) — runtime-internal, shared
+ * with scr_http2.c's createSecureServerDyn. */
+bool scr_tls_srv_opts_walk(const struct ScrDyn *opts, const char *api, ScrBytes **cert_out, ScrBytes **key_out);
 void scr_http2_server_on_stream(ScrNetServer *s, ScrClosure *cb /*moves*/, ScrH2StreamFn fn, bool once);
 void scr_http2_server_on_session(ScrNetServer *s, ScrClosure *cb /*moves*/, ScrH2SessionFn fn, bool once);
 
@@ -5349,7 +5495,7 @@ void scr_http2_goaway_thunk0(ScrClosure *cb, double code, double last);
 
 void scr_net_sock_set_native_established(ScrNetSocket *s, ScrNetNativeEventFn fn);
 
-/* Registers the h2 session/stream DOM handle ops (the emitted main()
+/* Registers the h2 session/stream dyn handle ops (the emitted main()
  * calls it when the unit is linked — the scr_net_dyn_install story). */
 void scr_http2_dyn_install(void);
 
@@ -5368,6 +5514,14 @@ ScrHttpClientReq *scr_https_request(ScrStr *host /*borrowed*/, double port,
                                      bool auto_end, bool reject_unauthorized,
                                      const char *ca /*borrowed, len 0 = none*/, size_t ca_len,
                                      ScrClosure *cb /*moves, nullable*/, ScrHttpRespFn fn); /* +1 */
+/* The agent-threaded twin (the scr_http_request_agent story over TLS). */
+ScrHttpClientReq *scr_https_request_agent(ScrStr *host /*borrowed*/, double port,
+                                           ScrStr *path /*borrowed*/, ScrStr *method /*borrowed*/,
+                                           double timeout_ms, ScrArr *header_pairs /*borrowed*/,
+                                           bool auto_end, bool reject_unauthorized,
+                                           const char *ca /*borrowed, len 0 = none*/, size_t ca_len,
+                                           const struct ScrDyn *agent /*borrowed*/,
+                                           ScrClosure *cb /*moves, nullable*/, ScrHttpRespFn fn); /* +1 */
 /* The fetch unit's https leg (defined in scr_tls.c): a client transport
  * context (SNI/verify against the URL hostname — the DIALED address may
  * be a resolved IP) plus the wrap hook scr_http_request_ex installs on
@@ -5412,7 +5566,7 @@ 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
+/* The send argument-validation ladder over dyn 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. */
@@ -5576,14 +5730,14 @@ void scr_assert_neq_fail(const char *insp, size_t ilen, bool deep,
                          ScrStr *msg, bool has_msg);
 /* strictEqual/notStrictEqual/deepStrictEqual/notDeepStrictEqual where
  * either operand is a checked-dynamic value (the frontend boxes a static
- * side into the DOM first). Strict pair: SameValue over the DOM kinds —
+ * side into the checked-dynamic tree first). Strict pair: SameValue over the dyn kinds —
  * Object.is numbers, byte-equal strings, units by kind, node identity
  * for arrays/objects/bytes, BOXED-CLOSURE identity for functions. Deep
- * pair: the structural DOM walk (per-element arrays, key-set objects,
+ * pair: the structural dyn walk (per-element arrays, key-set objects,
  * brand-aware bytes via the buffer flavor bit, closure identity for
  * functions). Generated messages reproduce assertion_error.js — the
  * scalar simple/stacked forms byte-exactly, composite values rendered
- * compact:false/sorted through the DOM and diffed with the real myers
+ * compact:false/sorted through the checked-dynamic tree and diffed with the real myers
  * line printer (the design note atop scr_assert.c's dyn section lists
  * the divergences). Borrows everything; throws on the failing verdict. */
 void scr_assert_eq_dyn(ScrDyn *a, ScrDyn *b, bool negated, bool deep,
@@ -5592,7 +5746,7 @@ void scr_assert_eq_dyn(ScrDyn *a, ScrDyn *b, bool negated, bool deep,
  * promise fulfilled): "Missing expected exception|rejection" with Node's
  * details — ` (${expected.name})` when the expected class/shape carries a
  * name (has_ename), then `: message` or `.`. */
-/* Node's expectsError over an error-INSTANCE expected: the expected DOM
+/* Node's expectsError over an error-INSTANCE expected: the expected dyn
  * error's keys (minus the %error marker) each deep-compare against the
  * caught value's; mismatches throw the deep-equal AssertionError. */
 void scr_assert_expects_err_dyn(ScrDyn *actual, ScrDyn *expected, ScrStr *msg, bool has_msg);
@@ -5630,7 +5784,7 @@ void scr_assert_iferror_err(ScrError *err);
 void scr_assert_iferror_f64(double x);
 void scr_assert_iferror_str(ScrStr *s);
 void scr_assert_iferror_bool(bool b);
-/* The checked-dynamic argument: DOM-kind dispatch — units pass quietly,
+/* The checked-dynamic argument: dyn-kind dispatch — units pass quietly,
  * %error-marked objects throw with the error's message, everything else
  * with the inspection. */
 void scr_assert_iferror_dyn(const ScrDyn *v);