@scriptc/runtime 0.0.8 → 0.0.10

package/src/scr_json.c

@@ -328,6 +328,7 @@ static ScrDyn *scr_dyn_alloc(ScrDynKind kind) {
     d->rc = 1;
     d->kind = kind;
     d->buffer = false;
+    d->null_proto = false;
     if (kind == SCR_DYN_ARR) {
       d->v.arr.len = 0; /* cap/items preserved from the node's last life */
     } else if (kind == SCR_DYN_OBJ) {
@@ -381,6 +382,11 @@ void scr_dyn_release(ScrDyn *d) {
      * scr_json.c without the fiber machinery) never references it. */
     scr_dyn_promise_release_fn(d->v.promise);
     break;
+  case SCR_DYN_JSVAL:
+    /* Installed by scr_dyn_alloc_jsval (the gated constructor is the
+     * only producer) — same story as the promise arm. */
+    scr_dyn_jsval_ops()->release(d->v.jsval.cell);
+    break;
   default:
     break; /* null/bool/num have no children */
   }
@@ -424,6 +430,107 @@ void scr_dyn_arr_push(ScrDyn *arr, ScrDyn *item) {
   arr->v.arr.items[arr->v.arr.len++] = item; /* ownership moves in */
 }
 
+/* Spread completion for a runtime-arity argument list (`f(...xs)` in the
+ * checked-dynamic tier): JS's spread over the DOM's iterable kinds —
+ * arrays element-by-element (retained), strings by code POINT (the string
+ * iterator; astral chars arrive unsplit), bytes by byte; every other kind
+ * throws V8's exact SPREAD-CALL TypeError (catchable, pending — callers
+ * check): nullish sources spell the spread expression (`what`) — "v is
+ * not iterable (cannot read property undefined)" — and everything else is
+ * the generic "Spread syntax requires ...iterable[Symbol.iterator] to be
+ * a function". Borrows src. */
+void scr_dyn_arr_push_spread(ScrDyn *arr, const ScrDyn *src, const char *what) {
+  if (src->kind == SCR_DYN_ARR) {
+    for (size_t i = 0; i < src->v.arr.len; i++) {
+      scr_dyn_arr_push(arr, scr_dyn_retain(src->v.arr.items[i]));
+    }
+    return;
+  }
+  if (src->kind == SCR_DYN_BYTES) {
+    for (size_t i = 0; i < src->v.bytes->len; i++) {
+      scr_dyn_arr_push(arr, scr_dyn_new_num((double)src->v.bytes->data[i]));
+    }
+    return;
+  }
+  if (src->kind == SCR_DYN_STR) {
+    double len = scr_str_utf16_len(src->v.str);
+    for (double at = 0; at < len;) {
+      ScrStr *cp = scr_str_cp_at(src->v.str, at);
+      at += scr_str_utf16_len(cp);
+      scr_dyn_arr_push(arr, scr_dyn_new_str(cp));
+      scr_str_release(cp);
+    }
+    return;
+  }
+  if (src->kind == SCR_DYN_UNDEF || src->kind == SCR_DYN_NULL) {
+    ScrJsonBuf b;
+    scr_jb_init(&b);
+    scr_jb_puts(&b, what);
+    scr_jb_puts(&b, " is not iterable (cannot read property ");
+    scr_jb_puts(&b, src->kind == SCR_DYN_UNDEF ? "undefined" : "null");
+    scr_jb_puts(&b, ")");
+    scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));
+    return;
+  }
+  if (src->kind == SCR_DYN_JSVAL) {
+    /* An engine array IS iterable — the generic not-iterable TypeError
+     * would be a wrong claim. Loud fence (lane dyn-routing-ops). */
+    scr_dyn_isl_fence(src, "spread");
+    return;
+  }
+  static const char msg[] = "Spread syntax requires ...iterable[Symbol.iterator] to be a function";
+  scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+}
+
+/* Destructuring pack over a DOM source (`const [a, b] = d`, a destructured
+ * dyn callback param): the spread walk's iterable kinds collect into a
+ * FRESH array — arrays element-by-element (retained), strings by code
+ * point, bytes by byte — and every other kind throws V8's DESTRUCTURING
+ * TypeError: `msg` verbatim when non-empty (the compile-time spelling —
+ * "v is not iterable" for identifier sources, "f is not a function or its
+ * return value is not iterable" for identifier-callee calls), else the
+ * runtime kind wording ("number 5 is not iterable (cannot read property
+ * Symbol(Symbol.iterator))"; objects and functions carry no value text,
+ * undefined no kind prefix, null V8's "object null"). Borrows both; +1 or
+ * NULL with the TypeError pending. */
+ScrDyn *scr_dyn_iter_pack(const ScrDyn *src, const ScrStr *msg) {
+  if (src->kind == SCR_DYN_ARR || src->kind == SCR_DYN_BYTES || src->kind == SCR_DYN_STR) {
+    ScrDyn *out = scr_dyn_new_arr();
+    scr_dyn_arr_push_spread(out, src, ""); /* iterable kinds never consult `what` */
+    return out;
+  }
+  /* An engine-held value may well BE iterable — claiming "not iterable"
+   * would be a wrong answer. The routing lane owns iteration; until it
+   * arms this, the island fence names the operation loudly. */
+  if (src->kind == SCR_DYN_JSVAL) {
+    scr_dyn_isl_fence(src, "destructuring");
+    return NULL;
+  }
+  if (msg != NULL && msg->len > 0) {
+    scr_throw_error(SCR_ERR_TYPE, scr_str_new(msg->data, msg->len));
+    return NULL;
+  }
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  switch (src->kind) {
+  case SCR_DYN_UNDEF: scr_jb_puts(&b, "undefined"); break;
+  case SCR_DYN_NULL: scr_jb_puts(&b, "object null"); break;
+  case SCR_DYN_BOOL: scr_jb_puts(&b, src->v.b ? "boolean true" : "boolean false"); break;
+  case SCR_DYN_NUM: {
+    char buf[32];
+    scr_jb_puts(&b, "number ");
+    size_t n = scr_f64_to_str(src->v.num, buf);
+    scr_jb_write(&b, buf, n);
+    break;
+  }
+  case SCR_DYN_FUNC: scr_jb_puts(&b, "function"); break;
+  default: scr_jb_puts(&b, "object"); break;
+  }
+  scr_jb_puts(&b, " is not iterable (cannot read property Symbol(Symbol.iterator))");
+  scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));
+  return NULL;
+}
+
 /* Takes ownership of key (malloc'd) and value. Duplicate keys: the LATER
  * value wins (like JS JSON.parse) — the old value is released and the new
  * key buffer freed (the surviving entry keeps its original, equal key). */
@@ -481,6 +588,11 @@ ScrDyn *scr_dyn_new_str(ScrStr *s) {
 
 ScrDyn *scr_dyn_new_arr(void) { return scr_dyn_alloc(SCR_DYN_ARR); }
 ScrDyn *scr_dyn_new_obj(void) { return scr_dyn_alloc(SCR_DYN_OBJ); }
+ScrDyn *scr_dyn_new_obj_null_proto(void) {
+  ScrDyn *d = scr_dyn_alloc(SCR_DYN_OBJ);
+  d->null_proto = true;
+  return d;
+}
 
 ScrDyn *scr_dyn_new_bytes_copy(const ScrBytes *b) {
   ScrDyn *d = scr_dyn_alloc(SCR_DYN_BYTES);
@@ -540,6 +652,15 @@ ScrDyn *scr_dyn_new_func(ScrClosure *clo, ScrDynThunk thunk, uint32_t arity, con
  * compiled per signature). Args borrowed; result owned (+1) or NULL with
  * the exception pending. */
 ScrDyn *scr_dyn_call(const ScrDyn *d, ScrDyn *const *args, size_t argc, const char *what) {
+  if (d->kind == SCR_DYN_JSVAL) {
+    /* An ENGINE callee: the call routes through scr_jsval_call with the
+     * uniform argument conversion (wrapped cells by reference, DOM data
+     * deep-copied, FUNC boxes through the host shim); a non-callable
+     * engine value throws the ENGINE's own TypeError, bridged catchably.
+     * `what` is unused — the engine's message names the failure. */
+    (void)what;
+    return scr_dyn_jsval_ops()->call(d->v.jsval.cell, args, argc);
+  }
   if (d->kind != SCR_DYN_FUNC) {
     ScrJsonBuf b;
     scr_jb_init(&b);
@@ -551,6 +672,13 @@ ScrDyn *scr_dyn_call(const ScrDyn *d, ScrDyn *const *args, size_t argc, const ch
   return d->v.fn.thunk(d->v.fn.clo, args, argc);
 }
 
+/* scr_dyn_call over a DOM ARRAY's elements — the spread-application form
+ * (`f(...args)` after the emitted argument array is built). Borrows both;
+ * result owned (+1), or NULL with the exception pending. */
+ScrDyn *scr_dyn_apply(const ScrDyn *d, const ScrDyn *args, const char *what) {
+  return scr_dyn_call(d, args->v.arr.items, args->v.arr.len, what);
+}
+
 /* ── native handles in the DOM (SCR_DYN_HANDLE) ───────────────────────
  * Per-tag ops stamped by the owning units at main() (scr_http_dyn_install
  * / scr_net_dyn_install — the scr_net_install hook story), so this
@@ -582,6 +710,160 @@ const ScrDynHandleOps *scr_dyn_handle_ops_of(const ScrDyn *d) {
   return scr_dyn_handle_ops(d->v.handle.tag);
 }
 
+/* errors.js's determineSpecificType over a DOM value — the "Received
+ * ..." tail of Node's ERR_INVALID_ARG_TYPE messages. Renders into buf
+ * when the shape needs a payload; returns the text either way. Lives
+ * beside the DOM core (not the gated handle unit) because the always-
+ * linked argument validators (bytes, fs) render through it too. */
+const char *scr_dyn_specific_type(const ScrDyn *cb, char *detail, size_t cap) {
+  const char *d = detail;
+  switch (cb->kind) {
+  case SCR_DYN_NULL: d = "null"; break;
+  case SCR_DYN_UNDEF: d = "undefined"; break;
+  case SCR_DYN_OBJ: d = "an instance of Object"; break;
+  case SCR_DYN_ARR: d = "an instance of Array"; break;
+  case SCR_DYN_BYTES: d = "an instance of Uint8Array"; break;
+  case SCR_DYN_FUNC:
+    /* determineSpecificType: `function ${value.name}` — anonymous
+     * functions keep Node's trailing space. */
+    snprintf(detail, cap, "function %s", cb->v.fn.name != NULL ? cb->v.fn.name : "");
+    break;
+  case SCR_DYN_HANDLE:
+    snprintf(detail, cap, "an instance of %s", scr_dyn_handle_cls(cb));
+    break;
+  case SCR_DYN_PROMISE: d = "an instance of Promise"; break;
+  case SCR_DYN_JSVAL:
+    /* Engine-held: only objects/arrays/functions survive wrap-time scalar
+     * normalization — pick by the engine's typeof. */
+    d = scr_dyn_isl_typeof_is(cb, "function") ? "function" : "an instance of Object";
+    break;
+  case SCR_DYN_BOOL:
+    snprintf(detail, cap, "type boolean (%s)", cb->v.b ? "true" : "false");
+    break;
+  case SCR_DYN_NUM: {
+    char num[32];
+    size_t n = scr_f64_to_str(cb->v.num, num);
+    snprintf(detail, cap, "type number (%.*s)", (int)n, num);
+    break;
+  }
+  case SCR_DYN_STR: {
+    const ScrStr *sv = cb->v.str;
+    char insp[32];
+    size_t n = 0;
+    insp[n++] = '\'';
+    for (size_t i = 0; i < sv->len && n < 28; i++) insp[n++] = sv->data[i];
+    if (sv->len + 2 > 28) {
+      n = 25;
+      memcpy(insp + n, "...", 3);
+      n += 3;
+    } else {
+      insp[n++] = '\'';
+    }
+    snprintf(detail, cap, "type string (%.*s)", (int)n, insp);
+    break;
+  }
+  default: d = "an instance of Object"; break;
+  }
+  return d;
+}
+
+/* Node's ERR_INVALID_ARG_TYPE thrower ("The \"chunk\" argument must be
+ * of type string or an instance of Buffer or Uint8Array. Received type
+ * number (5)") — the handle dispatchers' and argument validators'
+ * per-arg gates. `expected` is the full "of type ..."/"an instance of
+ * ..." clause. */
+/* The compiler-resolved ERR_INVALID_ARG_TYPE throw with a RUNTIME-
+ * rendered Received tail (error.argTypeThrow — the always-throwing
+ * lowered arms whose offending value is not a literal). Borrows all
+ * three; always throws catchably. */
+void scr_throw_arg_type(const ScrStr *argname, const ScrStr *expected, const ScrDyn *got) {
+  scr_dyn_arg_type_fail(argname->data, expected->data, got);
+}
+
+void scr_dyn_arg_type_fail(const char *argname, const char *expected, const ScrDyn *got) {
+  char detail[64];
+  const char *d = scr_dyn_specific_type(got, detail, sizeof detail);
+  char msg[224];
+  int len = snprintf(msg, sizeof msg,
+                     "The \"%s\" argument must be %s. Received %s", argname, expected, d);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_TYPE");
+}
+
+/* The property flavor of the same ladder — Node renders option-bag
+ * members as "The \"options.x\" property must be ..." (errors.js keys the
+ * wording on the name, but every property-path caller here knows it is
+ * one). Same runtime-rendered Received tail; always throws catchably. */
+void scr_dyn_prop_type_fail(const char *name, const char *expected, const ScrDyn *got) {
+  char detail[64];
+  const char *d = scr_dyn_specific_type(got, detail, sizeof detail);
+  char msg[224];
+  int len = snprintf(msg, sizeof msg,
+                     "The \"%s\" property must be %s. Received %s", name, expected, d);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_TYPE");
+}
+
+/* The compiler-resolved property-typed throw (error.propTypeThrow —
+ * argTypeThrow's option-bag sibling). Borrows all three; always throws. */
+void scr_throw_prop_type(const ScrStr *name, const ScrStr *expected, const ScrDyn *got) {
+  scr_dyn_prop_type_fail(name->data, expected->data, got);
+}
+
+/* ERR_INVALID_ARG_VALUE's "Received" tail — util.inspect where ARG_TYPE
+ * renders determineSpecificType: strings quote, scalars print plain.
+ * Deep shapes render their bracket sketch (enough for the validators'
+ * ladders; nothing observable pins the deep forms). */
+const char *scr_dyn_inspect_lite(const ScrDyn *v, char *buf, size_t cap) {
+  switch (v->kind) {
+  case SCR_DYN_NULL: return "null";
+  case SCR_DYN_UNDEF: return "undefined";
+  case SCR_DYN_BOOL: return v->v.b ? "true" : "false";
+  case SCR_DYN_NUM: {
+    scr_f64_to_str(v->v.num, buf);
+    return buf;
+  }
+  case SCR_DYN_STR: {
+    const ScrStr *s = v->v.str;
+    size_t n = 0;
+    buf[n++] = '\'';
+    for (size_t i = 0; i < s->len && n + 5 < cap; i++) buf[n++] = s->data[i];
+    if (s->len + 2 + 5 > cap) {
+      memcpy(buf + n, "...", 3);
+      n += 3;
+    }
+    buf[n++] = '\'';
+    buf[n] = 0;
+    return buf;
+  }
+  case SCR_DYN_ARR: return "[ ... ]";
+  case SCR_DYN_OBJ: return "{ ... }";
+  case SCR_DYN_BYTES: return "<Buffer ...>";
+  default: return "[object]";
+  }
+}
+
+/* Node's ERR_INVALID_ARG_VALUE thrower: "The <argument|property> '<name>'
+ * <reason>. Received <inspected>" — the argument/property choice follows
+ * errors.js (a dotted name is a property path). `reason` defaults to
+ * "is invalid" when NULL. TypeError, like Node's default. */
+void scr_dyn_arg_value_fail(const char *name, const char *reason, const ScrDyn *got) {
+  char insp[64];
+  const char *d = scr_dyn_inspect_lite(got, insp, sizeof insp);
+  char msg[256];
+  int len = snprintf(msg, sizeof msg, "The %s '%s' %s. Received %s",
+                     strchr(name, '.') != NULL ? "property" : "argument", name,
+                     reason != NULL ? reason : "is invalid", d);
+  scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)len, "ERR_INVALID_ARG_VALUE");
+}
+
+/* The deferred JS lowering fence, thrown from a ladder's post-validation
+ * tail: the compiler renders the message (the statement fence's own text,
+ * "[SC2020 at file:line]" included) and the ladder throws it verbatim
+ * AFTER its Node-order validations pass — Node's validation errors come
+ * first, the honest refuse second. Borrowed; always throws catchably. */
+void scr_throw_lowering_fence(const ScrStr *msg) {
+  scr_throw_error_msg_code(SCR_ERR_ERROR, msg->data, msg->len, "SC2020");
+}
+
 static void scr_dyn_handle_release(void *h, ScrDynHandleTag tag) {
   scr_dyn_handle_ops(tag)->release(h);
 }
@@ -604,6 +886,78 @@ ScrDyn *scr_dyn_alloc_promise(void (*release_fn)(ScrPromise *p)) {
   return scr_dyn_alloc(SCR_DYN_PROMISE);
 }
 
+/* ── island values in the DOM (SCR_DYN_JSVAL) ─────────────────────────
+ * The gated constructor (scr_dyn_from_jsval, scr_island.c) builds through
+ * this allocator view and installs the engine-routing ops — the
+ * scr_dyn_alloc_promise story: a dynamic-free link never references
+ * engine symbols, and JSVAL nodes exist only after an install. */
+static const ScrDynJsvalOps *scr_dynjs_ops = NULL;
+
+ScrDyn *scr_dyn_alloc_jsval(ScrJsval *cell, const ScrDynJsvalOps *ops) {
+  scr_dynjs_ops = ops;
+  ScrDyn *d = scr_dyn_alloc(SCR_DYN_JSVAL);
+  d->v.jsval.cell = cell; /* ownership moves in */
+  return d;
+}
+
+const ScrDynJsvalOps *scr_dyn_jsval_ops(void) {
+  if (!scr_dynjs_ops) {
+    scr_trap("scriptc: internal error: dyn jsval ops not installed\n");
+  }
+  return scr_dynjs_ops;
+}
+
+bool scr_dyn_isl_typeof_is(const ScrDyn *d, const char *name) {
+  if (d->kind != SCR_DYN_JSVAL) return false;
+  ScrStr *t = scr_dyn_jsval_ops()->type_of(d->v.jsval.cell);
+  size_t n = strlen(name);
+  bool r = t->len == n && memcmp(t->data, name, n) == 0;
+  scr_str_release(t);
+  return r;
+}
+
+bool scr_dyn_isl_is_array(const ScrDyn *d) {
+  return d->kind == SCR_DYN_JSVAL && scr_dyn_jsval_ops()->is_array(d->v.jsval.cell);
+}
+
+bool scr_dyn_isl_is_error(const ScrDyn *d) {
+  return d->kind == SCR_DYN_JSVAL && scr_dyn_jsval_ops()->is_error(d->v.jsval.cell);
+}
+
+bool scr_dyn_isl_fence(const ScrDyn *d, const char *what) {
+  if (d->kind != SCR_DYN_JSVAL) return false;
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  scr_jb_puts(&b, what);
+  scr_jb_puts(&b, " on an island value held in 'unknown' is not supported yet");
+  scr_throw_error(SCR_ERR_ERROR, scr_jb_finish(&b));
+  return false;
+}
+
+ScrDyn *scr_dyn_isl_key_get(const ScrDyn *d, const ScrStr *k) {
+  /* The emitted keyed read's JSVAL arm: o[k] runs in the ENGINE (getters
+   * included, their throws bridged) and the result wraps back scalar-
+   * normalized — the retired `.length -> fence` row (and before that,
+   * the fence box's silent `.length -> 0`). */
+  return scr_dyn_jsval_ops()->key_get(d->v.jsval.cell, k);
+}
+
+bool scr_dyn_is_nullish(const ScrDyn *d) {
+  if (d->kind == SCR_DYN_UNDEF || d->kind == SCR_DYN_NULL) return true;
+  /* JSVAL defensively routes to the engine's own test — the wrap
+   * constructor scalar-normalizes engine null/undefined away, so this
+   * arm answers false unless a producer bypassed it. */
+  if (d->kind == SCR_DYN_JSVAL) return scr_dyn_jsval_ops()->is_nullish(d->v.jsval.cell);
+  return false;
+}
+
+void scr_dyn_isl_tostr_buf(ScrJsonBuf *b, const ScrDyn *d) {
+  ScrStr *s = scr_dyn_jsval_ops()->to_str(d->v.jsval.cell);
+  if (!s) return; /* bridged — the exception is pending, append nothing */
+  for (size_t i = 0; i < s->len; i++) scr_jb_putc(b, s->data[i]);
+  scr_str_release(s);
+}
+
 void *scr_dyn_handle_unbox(const ScrDyn *d, ScrDynHandleTag tag, const ScrDynPath *path, const char *want) {
   if (d->kind != SCR_DYN_HANDLE || d->v.handle.tag != tag) {
     scr_dyn_check_fail(path, want, d);
@@ -727,6 +1081,10 @@ bool scr_dyn_truthy(const ScrDyn *d) {
   case SCR_DYN_FUNC:
   case SCR_DYN_HANDLE:
   case SCR_DYN_PROMISE: return true;
+  case SCR_DYN_JSVAL:
+    /* Route to the engine's ToBoolean: objects/arrays/functions are
+     * true, but the symbol/bigint edge (0n is falsy) needs the engine. */
+    return scr_dyn_jsval_ops()->truthy(d->v.jsval.cell);
   default: return false; /* undefined, null */
   }
 }
@@ -735,6 +1093,10 @@ bool scr_dyn_truthy(const ScrDyn *d) {
  * null answers "object" — JS's oldest wart, preserved. */
 ScrStr *scr_dyn_typeof(const ScrDyn *d) {
   const char *s;
+  /* An island value answers the ENGINE's typeof — "object" for the
+   * wrapped objects/arrays, "function" for engine functions (row 1 of
+   * the jsval→DOM op table; scalars normalized away at wrap time). */
+  if (d->kind == SCR_DYN_JSVAL) return scr_dyn_jsval_ops()->type_of(d->v.jsval.cell);
   switch (d->kind) {
   case SCR_DYN_UNDEF: s = "undefined"; break;
   case SCR_DYN_NULL:
@@ -826,6 +1188,17 @@ static bool scr_dyn_json_write(ScrJsonBuf *b, const ScrDyn *d) {
     /* No own enumerable properties — Node stringifies a promise as {}. */
     scr_jb_puts(b, "{}");
     return true;
+  case SCR_DYN_JSVAL: {
+    /* The ENGINE's own JSON.stringify text splices in (toJSON protocols,
+     * cycle TypeErrors — the engine's, bridged catchably). An engine
+     * FUNCTION is absent under stringify, like the DOM's FUNC kind. */
+    if (scr_dyn_isl_typeof_is(d, "function")) return false;
+    ScrStr *j = scr_dyn_jsval_ops()->to_json(d->v.jsval.cell);
+    if (!j) return true; /* pending exception; caller checks */
+    scr_jb_write(b, j->data, j->len);
+    scr_str_release(j);
+    return true;
+  }
   case SCR_DYN_HANDLE:
   default: {
     const char *msg = "JSON.stringify of a runtime handle is not supported yet";
@@ -1043,6 +1416,14 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) {
     static const char f[] = "function () { [native code] }";
     return scr_str_new(f, sizeof f - 1);
   }
+  case SCR_DYN_JSVAL: {
+    /* The engine's own ToString (row 2 of the jsval→DOM op table): the
+     * real prototype chain runs — user toString included, its throw
+     * bridging. A bridged failure follows this function's existing
+     * throw shape (pending exception + the empty-string dummy). */
+    ScrStr *s = scr_dyn_jsval_ops()->to_str(d->v.jsval.cell);
+    return s ? s : scr_str_new("", 0);
+  }
   case SCR_DYN_UNDEF:
   case SCR_DYN_NULL:
   default: {
@@ -1055,6 +1436,23 @@ ScrStr *scr_dyn_to_string(const ScrDyn *d, const ScrStr *enc) {
   }
 }
 
+/* The METHOD-CALL spelling `d.toString(enc?)` — scr_dyn_to_string with
+ * the one receiver whose prototype LACKS the method carved out: a
+ * null-prototype dictionary (Object.create(null)) has no toString at
+ * all, so Node throws "<spelling> is not a function" where every other
+ * OBJ answers "[object Object]". `what` carries the source spelling. */
+ScrStr *scr_dyn_to_string_method(const ScrDyn *d, const ScrStr *enc, const ScrStr *what) {
+  if (d->kind == SCR_DYN_OBJ && d->null_proto) {
+    ScrJsonBuf b;
+    scr_jb_init(&b);
+    for (size_t i = 0; i < what->len; i++) scr_jb_putc(&b, what->data[i]);
+    scr_jb_puts(&b, " is not a function");
+    scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));
+    return scr_str_new("", 0);
+  }
+  return scr_dyn_to_string(d, enc);
+}
+
 /* JS String() over the DOM kind — the WebIDL ToString the web globals
  * (atob/btoa, DOMException's name resolution) run on their arguments:
  * the unit kinds RENDER ("null"/"undefined") where the .toString() twin
@@ -1066,6 +1464,39 @@ ScrStr *scr_dyn_string_coerce(const ScrDyn *d) {
   return scr_dyn_to_string(d, NULL);
 }
 
+/* JS ToString over a DOM value WITH the object protocol (the WHATWG
+ * USVString conversions — URLSearchParams names/values): an OBJ whose
+ * own 'toString' member is callable is invoked with zero arguments (its
+ * throw propagates, catchably); a non-primitive answer falls through to
+ * 'valueOf' (ToPrimitive's string hint); exhaustion is the spec's
+ * "Cannot convert object to primitive value" TypeError. Every other
+ * kind matches scr_dyn_string_coerce (units RENDER — ToString(null) is
+ * "null"). Borrows; +1, or NULL with the exception pending. */
+ScrStr *scr_dyn_string_coerce_js(const ScrDyn *d) {
+  if (d->kind == SCR_DYN_OBJ) {
+    static const char *const hint[2] = { "toString", "valueOf" };
+    for (int i = 0; i < 2; i++) {
+      ScrDyn *m = scr_dyn_obj_get(d, hint[i], strlen(hint[i])); /* borrowed */
+      if (!m || m->kind != SCR_DYN_FUNC) continue;
+      ScrDyn *r = scr_dyn_call(m, NULL, 0, hint[i]);
+      if (!r) return NULL; /* the method threw — pending */
+      if (r->kind == SCR_DYN_OBJ || r->kind == SCR_DYN_ARR ||
+          r->kind == SCR_DYN_FUNC || r->kind == SCR_DYN_HANDLE ||
+          r->kind == SCR_DYN_PROMISE) {
+        scr_dyn_release(r); /* non-primitive answer: try the next method */
+        continue;
+      }
+      ScrStr *s = scr_dyn_string_coerce(r);
+      scr_dyn_release(r);
+      return s;
+    }
+    static const char msg[] = "Cannot convert object to primitive value";
+    scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+    return NULL;
+  }
+  return scr_dyn_string_coerce(d);
+}
+
 /* The checked-dynamic keyed WRITE (`h.k = v` on a dyn receiver): OBJ sets
  * the member (later writes win, insertion order — JS); undefined/null
  * throws Node's "Cannot set properties of ..."; every other kind throws
@@ -1102,6 +1533,13 @@ void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value) {
     scr_dyn_handle_key_set(recv, key, value);
     return;
   }
+  if (recv->kind == SCR_DYN_JSVAL) {
+    /* The write lands on the REAL engine object (aliasing preserved —
+     * island-side readers see it); the value crosses through the uniform
+     * from_dyn conversion, and engine refusals bridge catchably. */
+    scr_dyn_jsval_ops()->key_set(recv->v.jsval.cell, key, value);
+    return;
+  }
   ScrJsonBuf b;
   scr_jb_init(&b);
   if (recv->kind == SCR_DYN_UNDEF || recv->kind == SCR_DYN_NULL) {
@@ -1115,6 +1553,22 @@ void scr_dyn_key_set(ScrDyn *recv, ScrStr *key, ScrDyn *value) {
     for (size_t i = 0; i < key->len; i++) scr_jb_putc(&b, key->data[i]);
     scr_jb_puts(&b, "' on ");
     scr_jb_puts(&b, scr_dyn_kind_name(recv));
+    /* V8 quotes the primitive's own rendering after the kind — "on number
+     * '5'", "on string 'abc'", "on boolean 'true'". Other kinds stop at
+     * the kind word. */
+    if (recv->kind == SCR_DYN_NUM) {
+      char buf[32];
+      size_t n = scr_f64_to_str(recv->v.num, buf);
+      scr_jb_puts(&b, " '");
+      scr_jb_write(&b, buf, n);
+      scr_jb_putc(&b, '\'');
+    } else if (recv->kind == SCR_DYN_STR) {
+      scr_jb_puts(&b, " '");
+      scr_jb_write(&b, recv->v.str->data, recv->v.str->len);
+      scr_jb_putc(&b, '\'');
+    } else if (recv->kind == SCR_DYN_BOOL) {
+      scr_jb_puts(&b, recv->v.b ? " 'true'" : " 'false'");
+    }
   }
   scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));
 }
@@ -1176,12 +1630,28 @@ void scr_jb_put_dyn(ScrJsonBuf *b, const ScrDyn *d) {
     scr_jb_puts(b, "null"); /* the buffer never surfaces: the pending throw wins */
     return;
   }
+  case SCR_DYN_JSVAL: {
+    /* The ENGINE's own JSON.stringify text splices in (toJSON protocols,
+     * cycle TypeErrors — all the engine's, bridged catchably). An engine
+     * FUNCTION serializes like the DOM's FUNC kind (dropped from objects
+     * by the member loop below; null defensively elsewhere). */
+    if (scr_dyn_isl_typeof_is(d, "function")) {
+      scr_jb_puts(b, "null");
+      return;
+    }
+    ScrStr *j = scr_dyn_jsval_ops()->to_json(d->v.jsval.cell);
+    if (!j) return; /* bridged — the pending throw wins */
+    for (size_t i = 0; i < j->len; i++) scr_jb_putc(b, j->data[i]);
+    scr_str_release(j);
+    return;
+  }
   case SCR_DYN_OBJ: {
     scr_jb_putc(b, '{');
     bool first = true;
     for (size_t i = 0; i < d->v.obj.len; i++) {
       const ScrDynEntry *e = &d->v.obj.entries[i];
       if (e->value->kind == SCR_DYN_UNDEF || e->value->kind == SCR_DYN_FUNC) continue; /* dropped, like Node */
+      if (e->value->kind == SCR_DYN_JSVAL && scr_dyn_isl_typeof_is(e->value, "function")) continue; /* engine functions drop too */
       if (!first) scr_jb_putc(b, ',');
       first = false;
       /* Keys escape exactly like string values (put_json_str quotes). */
@@ -1230,6 +1700,9 @@ static const char *scr_dyn_kind_name(const ScrDyn *d) {
   case SCR_DYN_FUNC: return "function";
   case SCR_DYN_HANDLE: return scr_dyn_handle_cls(d); /* "got IncomingMessage" */
   case SCR_DYN_PROMISE: return "Promise"; /* "got Promise" */
+  case SCR_DYN_JSVAL: return "an island value"; /* "got an island value" — validated
+    * extraction of engine-held values has no armed route yet (lane
+    * dom-jsval-long-tail); the failure names the world honestly. */
   }
   return "unknown";
 }
@@ -1784,6 +2257,12 @@ bool scr_dyn_strict_eq(const ScrDyn *a, const ScrDyn *b) {
   case SCR_DYN_PROMISE:
     /* And the PROMISE: one promise crossing twice is one JS value. */
     return a->v.promise == b->v.promise;
+  case SCR_DYN_JSVAL:
+    /* Identity is the ENGINE VALUE, not the box or even the cell: two
+     * wraps of one engine value compare ===-equal (the engine's own
+     * strict equality answers). Mixed kinds already answered false above
+     * — a DOM copy is a different object, which is Node's answer too. */
+    return a == b || scr_dyn_jsval_ops()->strict_eq(a->v.jsval.cell, b->v.jsval.cell);
   default: return a == b;
   }
 }
@@ -1820,6 +2299,12 @@ ScrDyn *scr_dyn_fn_get(const ScrDyn *d, const char *key, size_t key_len) {
 
 void scr_sc_validate_options(const ScrDyn *options) {
   if (options == NULL || options->kind == SCR_DYN_UNDEF || options->kind == SCR_DYN_NULL) return;
+  /* An engine-held options bag IS a dictionary to Node — the "cannot be
+   * converted" TypeError would be a wrong claim. Loud fence. */
+  if (options->kind == SCR_DYN_JSVAL) {
+    scr_dyn_isl_fence(options, "structuredClone options");
+    return;
+  }
   if (options->kind != SCR_DYN_OBJ) {
     static const char msg[] =
         "Failed to execute 'structuredClone': Options cannot be converted to a dictionary";
@@ -1898,6 +2383,12 @@ static ScrDyn *scr_sc_clone(const ScrDyn *v, const ScrScParent *up) {
     }
     return out;
   }
+  case SCR_DYN_JSVAL:
+    /* Node CLONES a plain engine object — the DataCloneError default
+     * below would be a wrong claim, and fabricating a shape would be a
+     * silent wrong answer. Loud fence (lane dom-jsval-long-tail). */
+    scr_dyn_isl_fence(v, "structuredClone");
+    return NULL;
   case SCR_DYN_FUNC:
   case SCR_DYN_HANDLE:
   default: {
@@ -1942,6 +2433,11 @@ ScrDyn *scr_structured_clone_missing(void) {
 }
 
 bool scr_dyn_err_instanceof(const ScrDyn *d, double kind) {
+  /* A JSVAL node never came from a runtime ScrError, so the cache miss
+   * below answers false — the documented contract ("a DOM value that
+   * never came from an error answers false"). An ENGINE TypeError held
+   * in 'unknown' thus answers false where Node answers true: covered by
+   * lane dom-jsval-long-tail (needs the engine's class instanceof). */
   for (size_t i = 0; i < scr_errdyn_n; i++) {
     if (scr_errdyn_cache[i].dyn == d) {
       const ScrVt *vt = scr_errdyn_cache[i].err->vt;
@@ -2009,6 +2505,12 @@ static ScrDyn *scr_dyn_objwalk(const ScrDyn *v, ScrObjWalk mode) {
     scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
     return NULL;
   }
+  if (v->kind == SCR_DYN_JSVAL) {
+    /* The ENGINE walks its own object (own-key order, getters running,
+     * Object.entries' pairs) and the results come back as a NATIVE DOM
+     * array — keys are DOM strings, values wrap per element. */
+    return scr_dyn_jsval_ops()->obj_walk(v->v.jsval.cell, (int)mode);
+  }
   ScrDyn *out = scr_dyn_new_arr();
   if (v->kind == SCR_DYN_OBJ) {
     size_t n = v->v.obj.len;
@@ -2110,21 +2612,150 @@ static ScrDyn *scr_dyn_objwalk(const ScrDyn *v, ScrObjWalk mode) {
 
 ScrDyn *scr_dyn_obj_keys(const ScrDyn *v) { return scr_dyn_objwalk(v, SCR_OBJWALK_KEYS); }
 
+/* One source's own enumerable members onto an OBJ target — the
+ * CopyDataProperties walk Object.assign runs per source. OBJ sources copy
+ * their members directly (last write wins); the index-keyed kinds
+ * (arrays, strings, bytes) ride the entries walk, so the copied key set
+ * is EXACTLY what Object.keys answers for that kind (string sources per
+ * UTF-16 code unit, like Node's String exotic object); nullish sources
+ * copy nothing (Node skips them) and the scalar/function/handle kinds
+ * have no own enumerable string keys. Non-OBJ targets copy nothing (the
+ * existing two-arg stance — a DOM array target has no property table). */
+static void scr_dyn_assign_from(ScrDyn *target, const ScrDyn *src) {
+  if (target->kind != SCR_DYN_OBJ) return;
+  if (src->kind == SCR_DYN_UNDEF || src->kind == SCR_DYN_NULL) return;
+  if (src->kind == SCR_DYN_OBJ) {
+    for (size_t i = 0; i < src->v.obj.len; i++) {
+      scr_dyn_obj_set(target, src->v.obj.entries[i].key,
+                      src->v.obj.entries[i].key_len,
+                      scr_dyn_retain(src->v.obj.entries[i].value));
+    }
+    return;
+  }
+  if (src->kind != SCR_DYN_ARR && src->kind != SCR_DYN_STR &&
+      src->kind != SCR_DYN_BYTES) {
+    return;
+  }
+  ScrDyn *pairs = scr_dyn_obj_entries(src); /* +1; never throws here */
+  if (pairs == NULL) return;
+  if (pairs->kind == SCR_DYN_ARR) {
+    for (size_t i = 0; i < pairs->v.arr.len; i++) {
+      const ScrDyn *pair = pairs->v.arr.items[i];
+      if (pair->kind != SCR_DYN_ARR || pair->v.arr.len != 2) continue;
+      const ScrDyn *k = pair->v.arr.items[0];
+      if (k->kind != SCR_DYN_STR) continue;
+      scr_dyn_obj_set(target, k->v.str->data, k->v.str->len,
+                      scr_dyn_retain(pair->v.arr.items[1]));
+    }
+  }
+  scr_dyn_release(pairs);
+}
+
 /* Object.assign over DOM values: copies `src`'s own members onto `target`
  * (last write wins) and answers the target retained (+1). Nullish
  * receivers throw Node's ToObject TypeError; nullish sources copy
- * nothing; non-object sources copy nothing DOM-representable. */
+ * nothing; index-keyed sources (arrays/strings/bytes) copy their index
+ * keys like Node; the remaining kinds have no own enumerable keys. */
 ScrDyn *scr_dyn_assign(ScrDyn *target, const ScrDyn *src) {
   if (target->kind == SCR_DYN_UNDEF || target->kind == SCR_DYN_NULL) {
     const char *m = "Cannot convert undefined or null to object";
     scr_throw_error_msg(SCR_ERR_TYPE, m, strlen(m));
     return NULL;
   }
-  if (target->kind == SCR_DYN_OBJ && src->kind == SCR_DYN_OBJ) {
-    for (size_t i = 0; i < src->v.obj.len; i++) {
-      scr_dyn_obj_set(target, src->v.obj.entries[i].key,
-                      src->v.obj.entries[i].key_len,
-                      scr_dyn_retain(src->v.obj.entries[i].value));
+  if (target->kind == SCR_DYN_JSVAL) {
+    /* An ENGINE target: the copy runs in the engine (Object.assign's own
+     * semantics — setters fire, own-enumerable order); the source enters
+     * per the uniform conversion (a wrapped source spreads by reference,
+     * DOM data as the usual member deep copy). */
+    if (!scr_dyn_jsval_ops()->assign(target->v.jsval.cell, src)) return NULL;
+    return scr_dyn_retain(target);
+  }
+  if (src->kind == SCR_DYN_JSVAL) {
+    /* A wrapped SOURCE onto a DOM target: the engine lists its own
+     * [key, value] pairs (getters running) and each lands as a DOM
+     * member — values wrap per element, scalars normalized. */
+    if (target->kind == SCR_DYN_OBJ) {
+      ScrDyn *entries = scr_dyn_jsval_ops()->obj_walk(src->v.jsval.cell, 2);
+      if (!entries) return NULL;
+      for (size_t i = 0; i < entries->v.arr.len; i++) {
+        const ScrDyn *pair = entries->v.arr.items[i];
+        const ScrDyn *k = pair->v.arr.items[0];
+        scr_dyn_obj_set(target, k->v.str->data, k->v.str->len,
+                        scr_dyn_retain(pair->v.arr.items[1]));
+      }
+      scr_dyn_release(entries);
+    }
+    return scr_dyn_retain(target);
+  }
+  scr_dyn_assign_from(target, src);
+  return scr_dyn_retain(target);
+}
+
+/* Variadic Object.assign's argument pack (the `Object.assign({},
+ * ...arr.map(f), tail)` shape): the compiler builds one fresh DOM array
+ * of sources — plain arguments push borrowed (+1 in), spread arguments
+ * flatten through the spread-call walk (scr_dyn_arr_push_spread's V8
+ * TypeError texts, `what` spelling the spread expression for the nullish
+ * form) — so every source evaluates and flattens BEFORE any copying,
+ * exactly JS's ArgumentListEvaluation. */
+void scr_dyn_pack_push(ScrDyn *pack, ScrDyn *v) {
+  scr_dyn_arr_push(pack, scr_dyn_retain(v));
+}
+
+void scr_dyn_pack_push_spread(ScrDyn *pack, const ScrDyn *src, const ScrStr *what) {
+  scr_dyn_arr_push_spread(pack, src, what->data);
+}
+
+/* The ITERATED-path spread completion: V8 only takes the optimized
+ * apply-path texts (scr_dyn_arr_push_spread's — the expression spelled
+ * for nullish sources) when the spread is the SINGLE LAST argument; a spread
+ * followed by more arguments, or one of several spreads, drives the real
+ * iterator protocol, whose failure text describes the VALUE instead —
+ * "undefined", "object null", "number 5", "boolean true", "function",
+ * bare "object" — + " is not iterable (cannot read property
+ * Symbol(Symbol.iterator))". The compiler picks the variant by the
+ * spread's syntactic position. MAY THROW (pending). Borrows src. */
+void scr_dyn_pack_push_spread_iter(ScrDyn *pack, const ScrDyn *src) {
+  if (src->kind == SCR_DYN_ARR || src->kind == SCR_DYN_BYTES ||
+      src->kind == SCR_DYN_STR) {
+    scr_dyn_arr_push_spread(pack, src, ""); /* iterable kinds never throw */
+    return;
+  }
+  ScrJsonBuf b;
+  scr_jb_init(&b);
+  switch (src->kind) {
+  case SCR_DYN_UNDEF: scr_jb_puts(&b, "undefined"); break;
+  case SCR_DYN_NULL: scr_jb_puts(&b, "object null"); break;
+  case SCR_DYN_NUM: {
+    scr_jb_puts(&b, "number ");
+    ScrStr *s = scr_f64_to_scrstr(src->v.num);
+    for (size_t i = 0; i < s->len; i++) scr_jb_putc(&b, s->data[i]);
+    scr_str_release(s);
+    break;
+  }
+  case SCR_DYN_BOOL: scr_jb_puts(&b, src->v.b ? "boolean true" : "boolean false"); break;
+  case SCR_DYN_FUNC: scr_jb_puts(&b, "function"); break;
+  default: scr_jb_puts(&b, "object"); break; /* OBJ/HANDLE/PROMISE */
+  }
+  scr_jb_puts(&b, " is not iterable (cannot read property Symbol(Symbol.iterator))");
+  scr_throw_error(SCR_ERR_TYPE, scr_jb_finish(&b));
+}
+
+/* Object.assign(target, ...sources) over the flattened pack: the nullish
+ * ToObject TypeError first (Node throws before looking at sources), then
+ * each source's own-member copy left to right, answering the target
+ * retained (+1) — identity, like JS. */
+ScrDyn *scr_dyn_assign_all(ScrDyn *target, const ScrDyn *sources) {
+  if (target->kind == SCR_DYN_UNDEF || target->kind == SCR_DYN_NULL) {
+    const char *m = "Cannot convert undefined or null to object";
+    scr_throw_error_msg(SCR_ERR_TYPE, m, strlen(m));
+    return NULL;
+  }
+  if (sources->kind == SCR_DYN_ARR) {
+    for (size_t i = 0; i < sources->v.arr.len; i++) {
+      ScrDyn *r = scr_dyn_assign(target, sources->v.arr.items[i]);
+      if (!r) return NULL;
+      scr_dyn_release(r);
     }
   }
   return scr_dyn_retain(target);
@@ -2136,6 +2767,12 @@ bool scr_dyn_has_own(const ScrDyn *v, const ScrStr *key) {
     scr_throw_error_msg(SCR_ERR_TYPE, m, strlen(m));
     return false;
   }
+  /* Engine-held: the ENGINE's own Object.hasOwn answers (a bridged
+   * surprise leaves the exception pending and answers false — callers
+   * check pending like every fallible dyn op). */
+  if (v->kind == SCR_DYN_JSVAL) {
+    return scr_dyn_jsval_ops()->has_own(v->v.jsval.cell, key) == 1;
+  }
   if (v->kind == SCR_DYN_OBJ) {
     return scr_dyn_obj_get(v, key->data, key->len) != NULL;
   }