@scriptc/runtime 0.0.10 → 0.0.12

package/src/scr_dyn_invoke.c

@@ -1,10 +1,10 @@
 /* Prototype-method dispatch on checked-dynamic receivers (scr_dyn_invoke)
- * and its companions: JS String() over the DOM (scr_dyn_display — join
+ * and its companions: JS String() over the checked-dynamic tree (scr_dyn_display — join
  * and the error texts need it standalone) and Object.defineProperties
- * over DOM values (scr_dyn_define_props). Linked only when the IR
+ * over dyn values (scr_dyn_define_props). Linked only when the IR
  * carries dynInvoke nodes or dyn.defineProps calls (cc.ts gates on
  * moduleUsesDynInvoke — the scr_assert.c precedent), so dispatch-free
- * binaries keep their exact size class. The DOM itself lives in
+ * binaries keep their exact size class. The checked-dynamic tree itself lives in
  * scr_json.c; this unit uses only its public surface plus ScrJsonBuf.
  */
 #include "scr_runtime.h"
@@ -16,8 +16,8 @@
 
 /* ── checked-dynamic METHOD DISPATCH (scr_dyn_invoke) ──────────────────
  *
- * `recv.m(args)` where recv is a DOM value and `m` is a name a
- * DOM-representable prototype declares (Array/String/Function shared
+ * `recv.m(args)` where recv is a dyn value and `m` is a name a
+ * dyn-representable prototype declares (Array/String/Function shared
  * names — push, slice, forEach, apply, ...): a stored-member read would
  * silently mis-answer real methods, so the dispatch runs HERE, over the
  * receiver's runtime kind. test/common's mustCall internals are the
@@ -38,10 +38,10 @@
  * recv/args are BORROWED; the result is owned (+1). MAY THROW (returns
  * NULL with the exception pending). */
 
-/* JS String() over a DOM value, runtime-side (join needs it standalone —
+/* JS String() over a dyn value, runtime-side (join needs it standalone —
  * the emitted sc_ds walker exists only in programs that spell
  * String(unknown) themselves). Same rules: arrays join with "," and
- * null/undefined elements print empty, the DOM's error encoding renders
+ * null/undefined elements print empty, the checked-dynamic tree's error encoding renders
  * "name: message", functions render the native-code form, plain objects
  * are [object Object]. */
 static void scr_dyn_display_buf(ScrJsonBuf *b, const ScrDyn *d) {
@@ -192,7 +192,7 @@ static bool dyn_cb_check(ScrDyn *const *args, size_t argc) {
   ScrDyn *cb = argc > 0 ? args[0] : scr_dyn_undefined();
   if (cb->kind == SCR_DYN_FUNC) return true;
   /* An ENGINE function is callable — scr_dyn_call's JSVAL arm routes it
-   * (the loops below call through scr_dyn_call, which converts the DOM
+   * (the loops below call through scr_dyn_call, which converts the checked-dynamic tree
    * element arguments per the uniform crossing). A wrapped NON-function
    * falls through to the display path: String(cb) renders through the
    * engine, exactly Node's message. */
@@ -215,7 +215,7 @@ static ScrDyn *scr_dynh_dispatch(ScrDyn *recv, const char *method, ScrDyn *const
   return ops->invoke(recv->v.handle.ptr, recv, method, args, argc, what);
 }
 
-/* JS Array.prototype.sort over a DOM array: the spec's snapshot-sort —
+/* JS Array.prototype.sort over a dyn array: the spec's snapshot-sort —
  * elements copy (retained) into a work list, a stable merge sort orders
  * it (undefined elements sink to the end before any comparator runs),
  * and the ordered list writes back index by index, so a comparator that
@@ -339,7 +339,7 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
   /* Island-held receivers: the ENGINE runs its own prototypes (JS-exact
    * flatMap/map/forEach/filter — Array.prototype is the engine's) through
    * scr_jsval_call_method; arguments cross per the uniform conversion
-   * (wrapped cells by reference, DOM data deep-copied, FUNC boxes through
+   * (wrapped cells by reference, dyn data deep-copied, FUNC boxes through
    * the host shim), a missing member throws the engine's own TypeError,
    * and the result wraps back scalar-normalized. `what` is unused — the
    * engine's message names the failure. */
@@ -352,7 +352,7 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
   if (recv->kind == SCR_DYN_OBJ) {
     ScrDyn *m = scr_dyn_obj_get(recv, method, strlen(method));
     if (m && (m->kind == SCR_DYN_FUNC ||
-              /* a WRAPPED engine function stored as a DOM member: the
+              /* a WRAPPED engine function stored as a dyn member: the
                * routed call (scr_dyn_call's JSVAL arm) runs it. */
               (m->kind == SCR_DYN_JSVAL && scr_dyn_isl_typeof_is(m, "function")))) {
       /* JS binds the receiver for the call (`obj.method()` — this === obj):
@@ -584,8 +584,8 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
       return scr_dyn_retain(scr_dyn_undefined()); /* forEach */
     }
     if (dyn_name_is(method, "flatMap")) {
-      /* JS Array.prototype.flatMap over a DOM array: map + a depth-1
-       * flatten. Native DOM-array results flatten element-by-element; a
+      /* JS Array.prototype.flatMap over a dyn array: map + a depth-1
+       * flatten. Native dyn-array results flatten element-by-element; a
        * WRAPPED engine array flattens through the routed keyed reads
        * (elements wrap back scalar-normalized); everything else pushes
        * as a single element (JS keeps non-array callback results whole).
@@ -682,9 +682,9 @@ ScrDyn *scr_dyn_invoke(ScrDyn *recv, const char *method, ScrDyn *const *args, si
   return NULL;
 }
 
-/* Object.defineProperties over DOM values (see scr_runtime.h). Value
+/* Object.defineProperties over dyn values (see scr_runtime.h). Value
  * descriptors only: writable/enumerable/configurable accepted and IGNORED
- * (DOM properties are plain data properties — SEMANTICS.md); get/set
+ * (dyn properties are plain data properties — SEMANTICS.md); get/set
  * throw the loud unsupported Error, never a silent drop. */
 ScrDyn *scr_dyn_define_props(ScrDyn *target, ScrDyn *descs) {
   /* Island-held operands ARE objects to Node — the non-object TypeError

package/src/scr_error.c

@@ -44,9 +44,9 @@ static void scr_error_gcfree(void *obj) {
   scr_cyc_free(e);
 }
 
-/* DOMException teardown: the ScrError fields plus the owned cause DOM
+/* DOMException teardown: the ScrError fields plus the owned cause dyn
  * value. The cause is a ScrDyn — scr_json.c territory — and this file
- * must stay linkable WITHOUT the DOM (the runtime C-unit tests link
+ * must stay linkable WITHOUT the checked-dynamic tree (the runtime C-unit tests link
  * subsets), so the drop goes through a hook scr_json.c installs before
  * any cause can exist (scr_domex_new is the only producer). */
 static void (*scr_domex_cause_drop)(void *obj) = NULL;
@@ -273,7 +273,7 @@ void scr_undef_global_read(ScrStr *name) {
 /* ── DOMException ─────────────────────────────────────────────────────
  * The web-standard error shape (a Node global since v17): the ScrError
  * prefix plus the WebIDL slots (legacy numeric code, the options form's
- * cause). Construction resolves WebIDL's optionality over borrowed DOM
+ * cause). Construction resolves WebIDL's optionality over borrowed dyn
  * arguments — one place, shared by the compiled `new DOMException(...)`
  * and the runtime's own throw sites (atob/btoa). */
 

package/src/scr_events_emitter.c

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

package/src/scr_http.c

@@ -2774,7 +2774,7 @@ void scr_http_resp_thunk_res(ScrClosure *cb, ScrHttpReq *res) {
  *
  * The receiver surface behind `server.on('request', mustCall((req, res)
  * => ...))`: the mustCall wrapper makes the listener dyn, req/res box
- * into the DOM as HANDLE values, and member uses inside the listener
+ * into the checked-dynamic tree as HANDLE values, and member uses inside the listener
  * body dispatch HERE — onto the very entry points the static lowerings
  * use, with per-argument gates shaped like Node's (the libCall signature
  * table in validate.ts is the modeled surface; this dispatcher mirrors
@@ -2785,7 +2785,7 @@ void scr_http_resp_thunk_res(ScrClosure *cb, ScrHttpReq *res) {
  *   - a member the class HAS but this table does not model: a LOUD
  *     "not supported yet" Error — never a silent wrong answer;
  *   - anything else: Node's "<spelling> is not a function" for calls,
- *     the undefined singleton for reads (the DOM's own-property answer;
+ *     the undefined singleton for reads (the checked-dynamic tree's own-property answer;
  *     SEMANTICS.md documents the remainder).
  *
  * Ownership: invoke/get/set receive BORROWED handles/args and answer
@@ -3009,7 +3009,7 @@ static ScrDyn *scr_http_dynh_req_get(void *h, const char *key, size_t key_len) {
     double st = scr_http_req_status(r);
     /* Node's IncomingMessage constructor sets statusCode = null; only a
      * client response assigns a number (the static lane's typed surface
-     * spells this number|undefined — the DOM can afford Node's null). */
+     * spells this number|undefined — the checked-dynamic tree can afford Node's null). */
     return st < 0 ? scr_dyn_new_null() : scr_dyn_new_num(st);
   }
   if (strcmp(key, "statusMessage") == 0) {
@@ -3049,7 +3049,7 @@ static bool scr_http_dynh_req_set(void *h, const char *key, size_t key_len, cons
 
 /* ── ServerResponse (SCR_DYNH_HTTP_RES) ──────────────────────────────── */
 
-/* writeHead's header-object form over a DOM OBJ: flatten into the
+/* writeHead's header-object form over a dyn OBJ: flatten into the
  * [k0, v0, k1, v1, ...] pairs the static lowering feeds
  * scr_http_res_write_head_pairs (repeats append — array values expand to
  * consecutive same-name pairs). Numbers format through String(n). NULL =

package/src/scr_http2.c

@@ -2589,7 +2589,7 @@ void scr_http2_settings_thunk0(ScrClosure *cb, ScrDyn *settings) {
 }
 
 /* The typed lane's DYN spellings (session receivers with mustCall-style
- * callbacks): the raw DOM function crosses the lib boundary and fires
+ * callbacks): the raw dyn function crosses the lib boundary and fires
  * through the same runtime-built listener closures the dyn handle ops
  * use — Node's exact payload shapes. */
 static void scr_h2_dyn_fire_settings(ScrClosure *cb, ScrDyn *settings /*+1*/);
@@ -2689,7 +2689,7 @@ void scr_http2_goaway_thunk0(ScrClosure *cb, double code, double last) {
  * parameter, or a handle stored in an untyped binding) dispatch their
  * members here, the scr_http.c req/res ops precedent: `.on(...)` wires a
  * runtime-built listener closure over the dyn callback, header events
- * build a DOM headers object from the pairs, method calls decode dyn
+ * build a dyn headers object from the pairs, method calls decode dyn
  * args onto the static entry points, and property reads box the scalar
  * answers. Real-but-unmodeled members throw the loud ladder; names the
  * surface never had throw Node's "<x> is not a function". */
@@ -2791,7 +2791,7 @@ static void scr_h2_dyn_fire_goaway(ScrClosure *cb, double code, double last) {
   scr_dyn_release(fn);
 }
 
-/* Flatten a DOM headers object into the flat pairs array (numbers via
+/* Flatten a dyn headers object into the flat pairs array (numbers via
  * String(n); the :status/:method/... pseudo-headers pass through). */
 static ScrArr *scr_h2_dom_to_pairs(const ScrDyn *headers) {
   ScrArr *pairs = scr_arr_new(SCR_ELEM_STR, headers->v.obj.len * 2);

package/src/scr_inspect.c

@@ -700,7 +700,7 @@ ScrStr *scr_insp_error(ScrError *e, double recurse, double depth) {
   return out;
 }
 
-/* ── dyn values (the checked-dynamic JSON DOM) ───────────────────────── */
+/* ── dyn values (the checked-dynamic JSON dyn) ───────────────────────── */
 
 /* Property-name rendering: bare when the key matches Node's keyStrRegExp
  * (/^[a-zA-Z_][a-zA-Z_0-9]*$/, '__proto__' excepted), quoted otherwise. */
@@ -735,7 +735,7 @@ ScrStr *scr_insp_key(ScrStr *k) {
 /* The full inspect over a dyn tree — the one runtime type whose SHAPE
  * lives in the value, so the traversal lives here instead of a
  * synthesized helper. Same engine, same defaults. dyn-boxed bytes render
- * in the DOM's documented Uint8Array identity (SEMANTICS.md). */
+ * in the checked-dynamic tree's documented Uint8Array identity (SEMANTICS.md). */
 ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) {
   switch (d->kind) {
     case SCR_DYN_NULL:
@@ -837,7 +837,7 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) {
       return scr_str_new("", 0);
     }
     case SCR_DYN_JSVAL: {
-      /* An island value inside the DOM: Node prints the engine object's
+      /* An island value inside the checked-dynamic tree: Node prints the engine object's
        * property dump — fence loudly, naming the engine typeof (the
        * scr_insp_jsval wording for bare 'any' composites). */
       ScrStr *t = scr_dyn_typeof(d); /* routes to the engine; +1 */

package/src/scr_island.c

@@ -383,6 +383,7 @@ enum {
   ISL_H_OBJWALK,
   ISL_H_HASOWN,
   ISL_H_ASSIGN,
+  ISL_H_ITERDRAIN,
   ISL_H_COUNT,
 };
 
@@ -437,7 +438,22 @@ static const char isl_prelude[] =
      * semantics (own-key order, getters running, ToObject refusals). */
     "(o,m)=>m===0?Object.keys(o):m===1?Object.values(o):Object.entries(o),"
     "(o,k)=>Object.hasOwn(o,k),"
-    "(t,s)=>Object.assign(t,s)]";
+    "(t,s)=>Object.assign(t,s),"
+    /* ISL_H_ITERDRAIN: the ENGINE's own iterator protocol drained into a
+     * fresh array (for-of/destructuring/spread over a wrapped value —
+     * generators, Maps, Sets, Symbol.iterator implementations all step
+     * exactly as Node runs them). The guard front-runs the not-iterable
+     * TypeError in the CALLER's wording: m=1 is V8's spread-call text,
+     * s (when defined) the compile-time source spelling verbatim, else
+     * the kind wording (iterN's). */
+    "(v,m,s)=>{if(v===undefined||v===null||typeof v[Symbol.iterator]!==\"function\"){"
+    "if(m===1)throw new TypeError(\"Spread syntax requires ...iterable[Symbol.iterator] to be a function\");"
+    "if(s!==undefined)throw new TypeError(s);"
+    "let d;if(v===undefined)d=\"undefined\";else if(v===null)d=\"object null\";"
+    "else if(typeof v===\"number\")d=\"number \"+v;else if(typeof v===\"boolean\")d=\"boolean \"+v;"
+    "else if(typeof v===\"function\")d=\"function\";else d=\"object\";"
+    "throw new TypeError(d+\" is not iterable (cannot read property Symbol(Symbol.iterator))\")}"
+    "const o=[];for(const x of v)o.push(x);return o}]";
 
 static void isl_free_boot(void);
 static void isl_prom_wraps_teardown(void);
@@ -963,11 +979,11 @@ ScrJsval *scr_jsval_from_json(const ScrStr *json) {
   return isl_cell_new(v);
 }
 
-/* ── marshal in: a CHECKED-DYNAMIC (DOM) value ────────────────────────
+/* ── marshal in: a CHECKED-DYNAMIC (dyn) value ────────────────────────
  * `unknown` flowing into 'any'-typed code (`const cfg = isJson ?
- * JSON.parse(text) : islandParser(text)`): the DOM tree rebuilds as
+ * JSON.parse(text) : islandParser(text)`): the dyn tree rebuilds as
  * engine values — a DEEP COPY, the jsMarshal aliasing stance. Data kinds
- * only: a DOM carrying a boxed function, a native handle, or a promise
+ * only: a dyn carrying a boxed function, a native handle, or a promise
  * throws the catchable TypeError naming the kind (the box's thunk calls
  * STATIC code the engine cannot re-enter through a data copy). */
 static const char *isl_dyn_unmarshalable(const ScrDyn *d) {
@@ -996,14 +1012,14 @@ static const char *isl_dyn_unmarshalable(const ScrDyn *d) {
   }
 }
 
-static JSValue isl_dynfn_new(const ScrDyn *d); /* the DOM-function shim, below */
+static JSValue isl_dynfn_new(const ScrDyn *d); /* the checked-dynamic tree-function shim, below */
 
 static JSValue isl_from_dyn(const ScrDyn *d) {
   switch (d->kind) {
   case SCR_DYN_FUNC:
-    /* A boxed DOM function enters as ONE generic host-function shim over
-     * its uniform call thunk (ScrDynThunk): engine args wrap as DOM
-     * values, the thunk runs, the DOM result converts back. Each
+    /* A boxed dyn function enters as ONE generic host-function shim over
+     * its uniform call thunk (ScrDynThunk): engine args wrap as dyn
+     * values, the thunk runs, the dyn result converts back. Each
      * crossing mints a fresh engine function (documented). */
     return isl_dynfn_new(d);
   case SCR_DYN_UNDEF:
@@ -1017,7 +1033,7 @@ static JSValue isl_from_dyn(const ScrDyn *d) {
   case SCR_DYN_STR:
     return JS_NewStringLen(isl_ctx, d->v.str->data, d->v.str->len);
   case SCR_DYN_BYTES:
-    /* Only u8 payloads reach the DOM today (scr_json.c's stringify note). */
+    /* Only u8 payloads reach the checked-dynamic tree today (scr_json.c's stringify note). */
     return JS_NewUint8ArrayCopy(isl_ctx, d->v.bytes->data, d->v.bytes->len);
   case SCR_DYN_ARR: {
     JSValue arr = JS_NewArray(isl_ctx);
@@ -1047,7 +1063,7 @@ static JSValue isl_from_dyn(const ScrDyn *d) {
     return obj;
   }
   case SCR_DYN_JSVAL:
-    /* An engine value riding inside DOM data: embed the SAME engine
+    /* An engine value riding inside dyn data: embed the SAME engine
      * value by reference — the identity round trip, member position. */
     return JS_DupValue(isl_ctx, d->v.jsval.cell->v);
   default:
@@ -1057,7 +1073,7 @@ static JSValue isl_from_dyn(const ScrDyn *d) {
 }
 
 ScrJsval *scr_jsval_from_dyn(const ScrDyn *d) {
-  /* The identity round trip: an engine value that crossed into the DOM
+  /* The identity round trip: an engine value that crossed into the checked-dynamic tree
    * (scr_dyn_from_jsval) and back is the SAME engine value, by reference
    * — the one direction that used to throw (SEMANTICS.md supersedes the
    * "one unbridgeable mix"). */
@@ -1079,10 +1095,10 @@ ScrJsval *scr_jsval_from_dyn(const ScrDyn *d) {
   return isl_cell_new(v);
 }
 
-/* ── the jsval→DOM crossing (SCR_DYN_JSVAL's constructor + ops) ───────
+/* ── the jsval→dyn crossing (SCR_DYN_JSVAL's constructor + ops) ───────
  * The reverse direction: an 'any'-typed engine value flowing into an
- * 'unknown'/'object'/JS-residue slot wraps BY REFERENCE as the DOM's
- * island kind. The DOM core (scr_json.c) stays island-free — it routes
+ * 'unknown'/'object'/JS-residue slot wraps BY REFERENCE as the checked-dynamic tree's
+ * island kind. The dyn core (scr_json.c) stays island-free — it routes
  * the armed operations (typeof/truthy/String()/===, the narrowing
  * tests) through these installed ops; everything un-armed there keeps
  * the loud "not supported yet" ladder. */
@@ -1101,7 +1117,7 @@ static bool isl_dynjs_is_error(ScrJsval *cell) { return JS_IsError(cell->v); }
 
 static const ScrDynJsvalOps isl_dynjs_ops;
 
-/* The jsval→DOM wrap over a RAW engine value (BORROWED) — the scalar
+/* The jsval→dyn wrap over a RAW engine value (BORROWED) — the scalar
  * normalization the cell constructor applies, shared by the routed-op
  * result conversions (which hold a JSValue, not a cell). Composites mint
  * a fresh cell over the SAME engine value (identity is the value — the
@@ -1249,7 +1265,7 @@ static ScrDyn *isl_dynjs_obj_walk(ScrJsval *cell, int mode) {
     isl_bridge_exception();
     return NULL;
   }
-  /* The engine array unpacks into a NATIVE DOM array (keys are DOM
+  /* The engine array unpacks into a NATIVE dyn array (keys are dyn
    * strings, values wrap per element, entries become native pairs) so
    * the results iterate/index/measure at native speed. */
   int64_t len = 0;
@@ -1309,6 +1325,36 @@ static bool isl_dynjs_assign(ScrJsval *cell, const ScrDyn *src) {
 
 static ScrStr *isl_dynjs_to_json(ScrJsval *cell) { return scr_jsval_to_json(cell); }
 
+static ScrDyn *isl_dynjs_iter_drain(ScrJsval *cell, bool spread, const ScrStr *spell) {
+  isl_entry();
+  JSValue m = JS_NewInt32(isl_ctx, spread ? 1 : 0);
+  JSValue s = spell && spell->len > 0
+    ? JS_NewStringLen(isl_ctx, spell->data, spell->len)
+    : JS_UNDEFINED;
+  JSValue argv[3] = {cell->v, m, s};
+  JSValue r = JS_Call(isl_ctx, isl_helpers[ISL_H_ITERDRAIN], JS_UNDEFINED, 3, argv);
+  JS_FreeValue(isl_ctx, s);
+  if (JS_IsException(r)) {
+    isl_bridge_exception();
+    return NULL;
+  }
+  /* The drained engine array unpacks into a fresh dyn array — elements
+   * wrap back scalar-normalized (composites stay engine values by
+   * reference), exactly the obj_walk unpack. */
+  int64_t len = 0;
+  JSValue lv = JS_GetPropertyStr(isl_ctx, r, "length");
+  JS_ToInt64(isl_ctx, &len, lv);
+  JS_FreeValue(isl_ctx, lv);
+  ScrDyn *out = scr_dyn_new_arr();
+  for (int64_t i = 0; i < len; i++) {
+    JSValue e = JS_GetPropertyUint32(isl_ctx, r, (uint32_t)i);
+    scr_dyn_arr_push(out, isl_dyn_from_value(e));
+    JS_FreeValue(isl_ctx, e);
+  }
+  JS_FreeValue(isl_ctx, r);
+  return out;
+}
+
 static const ScrDynJsvalOps isl_dynjs_ops = {
   isl_dynjs_release,
   isl_dynjs_typeof,
@@ -1326,14 +1372,15 @@ static const ScrDynJsvalOps isl_dynjs_ops = {
   isl_dynjs_has_own,
   isl_dynjs_assign,
   isl_dynjs_to_json,
+  isl_dynjs_iter_drain,
 };
 
 ScrDyn *scr_dyn_from_jsval(ScrJsval *cell) {
   isl_entry();
   JSValue v = cell->v;
-  /* Scalar normalization: engine-reported scalars become the NATIVE DOM
+  /* Scalar normalization: engine-reported scalars become the NATIVE dyn
    * kinds at wrap time (the strict exits cannot fail on them), so every
-   * scalar path in the DOM core — ===, typeof tests, JSON of leaves —
+   * scalar path in the dyn core — ===, typeof tests, JSON of leaves —
    * stays untouched and the JSVAL kind never competes with them. */
   if (JS_IsUndefined(v)) return scr_dyn_retain(scr_dyn_undefined());
   if (JS_IsNull(v)) return scr_dyn_new_null();
@@ -1653,7 +1700,7 @@ static const JSClassDef isl_hostfn_class = {
     .finalizer = isl_hostfn_finalizer,
 };
 
-static JSClassID isl_dynfn_class_id;      /* the DOM-function shim, below */
+static JSClassID isl_dynfn_class_id;      /* the checked-dynamic tree-function shim, below */
 static const JSClassDef isl_dynfn_class;
 
 static void isl_register_hostfn_class(void) {
@@ -1818,13 +1865,13 @@ ScrJsval *scr_jsval_from_closure(ScrClosure *c, int arity,
   return isl_cell_new(fn);
 }
 
-/* ── the generic DOM-function shim (a boxed SCR_DYN_FUNC entering the
+/* ── the generic dyn-function shim (a boxed SCR_DYN_FUNC entering the
  * island) ─────────────────────────────────────────────────────────────
  * ONE shim serves every boxed function because the box's call thunk is a
- * single uniform C signature (ScrDynThunk): engine arguments wrap as DOM
- * values (scalar-normalizing — the jsval→DOM constructor's stance), the
+ * single uniform C signature (ScrDynThunk): engine arguments wrap as dyn
+ * values (scalar-normalizing — the jsval→dyn constructor's stance), the
  * thunk validates them against the closure's declared parameter types
- * and runs it, and the DOM result converts back through the from_dyn
+ * and runs it, and the dyn result converts back through the from_dyn
  * rules (wrapped cells by reference, data as a deep copy, nested
  * functions through this same shim). OWNERSHIP: the engine function's
  * opaque box owns ONE reference on the whole ScrDyn FUNC node (closure
@@ -1875,7 +1922,7 @@ static JSValue isl_dynfn_invoke(JSContext *ctx, JSValueConst this_val, int argc,
     return isl_throw_pending(ctx);
   }
   if (!r) return JS_UNDEFINED;
-  /* The thunk's DOM result converts back per the from_dyn rules; a kind
+  /* The thunk's dyn result converts back per the from_dyn rules; a kind
    * with no crossing (a handle, a promise) throws the same catchable
    * TypeError from_dyn would. */
   const char *bad = isl_dyn_unmarshalable(r);
@@ -1888,7 +1935,7 @@ static JSValue isl_dynfn_invoke(JSContext *ctx, JSValueConst this_val, int argc,
   return out; /* JS_EXCEPTION passes through as the engine throw */
 }
 
-/* A fresh engine function over a boxed DOM function (borrows d — the
+/* A fresh engine function over a boxed dyn function (borrows d — the
  * opaque box retains it). */
 static JSValue isl_dynfn_new(const ScrDyn *d) {
   JSValue boxv = JS_NewObjectClass(isl_ctx, isl_dynfn_class_id);
@@ -1959,11 +2006,13 @@ static void isl_prom_wrap_entry(ScrFiber *self, void *arg) {
   bool b = false;
   ScrStr *s = NULL;
   ScrJsval *j = NULL;
+  ScrArr *ja = NULL;
   switch (w->payload) {
   case SCR_ISLP_F64: f = scr_await_f64(w->p); break;
   case SCR_ISLP_BOOL: b = scr_await_bool(w->p); break;
   case SCR_ISLP_STR: s = scr_await_str(w->p); break;
   case SCR_ISLP_JSVAL: j = (ScrJsval *)scr_await_ref(w->p); break;
+  case SCR_ISLP_JSVAL_ARR: ja = (ScrArr *)scr_await_ref(w->p); break;
   default: scr_await_void(w->p); break;
   }
   bool rejected = scr_exc_pending();
@@ -1977,11 +2026,26 @@ static void isl_prom_wrap_entry(ScrFiber *self, void *arg) {
     case SCR_ISLP_BOOL: v = JS_NewBool(isl_ctx, b); break;
     case SCR_ISLP_STR: v = s ? JS_NewStringLen(isl_ctx, s->data, s->len) : JS_UNDEFINED; break;
     case SCR_ISLP_JSVAL: v = j ? JS_DupValue(isl_ctx, j->v) : JS_UNDEFINED; break;
+    case SCR_ISLP_JSVAL_ARR:
+      /* A native array of engine cells fulfills: a fresh engine array
+       * over the SAME engine values (identity crosses, spine a copy). */
+      if (ja) {
+        v = JS_NewArray(isl_ctx);
+        for (size_t i = 0; i < ja->len; i++) {
+          ScrJsval *cell = (ScrJsval *)scr_arr_get_ref(ja, (double)i); /* +1 */
+          JS_SetPropertyUint32(isl_ctx, v, (uint32_t)i, JS_DupValue(isl_ctx, cell->v));
+          scr_jsval_release(cell);
+        }
+      } else {
+        v = JS_UNDEFINED;
+      }
+      break;
     default: v = JS_UNDEFINED; break;
     }
   }
   if (s) scr_str_release(s);
   if (j) scr_jsval_release(j);
+  if (ja) scr_arr_release(ja);
   JSValue r = JS_Call(isl_ctx, rejected ? w->reject : w->resolve, JS_UNDEFINED, 1, &v);
   JS_FreeValue(isl_ctx, v);
   if (JS_IsException(r)) {
@@ -2095,6 +2159,20 @@ static JSValue isl_bridge_settle(JSContext *ctx, JSValueConst this_val, int argc
       /* fulfill_ref takes the +1 cell; awaiters retain their own out. */
       scr_promise_fulfill_ref(b->p, isl_cell_new(JS_DupValue(ctx, v)),
                                scr_jsval_retain_v, scr_jsval_release_v, NULL);
+    } else if (b->payload == SCR_ISLP_JSVAL_ARR) {
+      /* An `any[]`-declared fulfillment (the inferred loadPlugins return):
+       * the engine array exits Array.isArray-gated, elements BY REFERENCE
+       * (the jsval-element-array exit). A lying fulfillment (non-array)
+       * REJECTS the static promise with the boundary TypeError —
+       * trust-but-verify at the settle, like every dyn→static edge. */
+      ScrJsval *cell = isl_cell_new(JS_DupValue(ctx, v));
+      ScrArr *arr = scr_jsval_exit_jsval_arr(cell);
+      scr_jsval_release(cell);
+      if (!arr) {
+        scr_promise_reject_pending(b->p);
+      } else {
+        scr_promise_fulfill_ref(b->p, arr, scr_arr_retain_v, scr_arr_release_v, NULL);
+      }
     } else {
       scr_promise_fulfill_void(b->p);
     }
@@ -9567,6 +9645,37 @@ ScrBytes *scr_jsval_exit_bytes(ScrJsval *v) {
   return b;
 }
 
+/* Validated exit of an engine value into an `any[]`-declared slot (the
+ * jsval-element-array spelling — withPlugins' `loadPlugins(plugins)`
+ * boundary): the engine's Array.isArray gates (a non-array refuses with
+ * the catchable boundary TypeError), then elements copy BY REFERENCE
+ * into a native array of engine cells — identity preserved, length a
+ * snapshot (the exit's aliasing stance: element IDENTITY crosses, the
+ * spine is a copy). +1, or NULL with the exception pending. */
+ScrArr *scr_jsval_exit_jsval_arr(ScrJsval *v) {
+  isl_entry();
+  if (JS_IsArray(v->v) <= 0) {
+    isl_exit_fail("an array", v);
+    return NULL;
+  }
+  JSValue lv = JS_GetPropertyStr(isl_ctx, v->v, "length");
+  int64_t len = 0;
+  JS_ToInt64(isl_ctx, &len, lv);
+  JS_FreeValue(isl_ctx, lv);
+  ScrArr *out = scr_arr_new_ref(&scr_jsval_retain_v, &scr_jsval_release_v, NULL,
+                                len > 0 ? (size_t)len : 0);
+  for (int64_t i = 0; i < len; i++) {
+    JSValue e = JS_GetPropertyUint32(isl_ctx, v->v, (uint32_t)i); /* getters run */
+    if (JS_IsException(e)) {
+      isl_bridge_exception();
+      scr_arr_release(out);
+      return NULL;
+    }
+    scr_arr_push_ref(out, isl_cell_new(e)); /* ownership moves in */
+  }
+  return out;
+}
+
 /* Composite exit: engine JSON.stringify, feeding the existing
  * json.parse + dynCheck walker pipeline on the static side. A value
  * JSON cannot represent (function, undefined, symbol at the top) comes