@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

package/dist/lib/runtime-sources/src/scr_island.c

@@ -1002,6 +1002,12 @@ static const char *isl_dyn_unmarshalable(const ScrDyn *d) {
     return "a promise";
   case SCR_DYN_PROXY:
     return "a native Proxy";
+  case SCR_DYN_TYPED_REF: {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(d);
+    const char *result = isl_dyn_unmarshalable(view);
+    scr_dyn_release(view);
+    return result;
+  }
   case SCR_DYN_ARR:
     for (size_t i = 0; i < d->v.arr.len; i++) {
       const char *r = isl_dyn_unmarshalable(d->v.arr.items[i]);
@@ -1040,6 +1046,12 @@ static JSValue isl_from_bytes(const ScrBytes *b) {
 
 static JSValue isl_from_dyn(const ScrDyn *d) {
   switch (d->kind) {
+  case SCR_DYN_TYPED_REF: {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(d);
+    JSValue result = isl_from_dyn(view);
+    scr_dyn_release(view);
+    return result;
+  }
   case SCR_DYN_FUNC:
     /* A boxed dyn function enters as ONE generic host-function shim over
      * its uniform call thunk (ScrDynThunk): engine args wrap as dyn
@@ -1356,19 +1368,7 @@ 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;
-  }
+static ScrDyn *isl_dynjs_unpack_array(JSValue r) {
   /* 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. */
@@ -1386,6 +1386,22 @@ static ScrDyn *isl_dynjs_iter_drain(ScrJsval *cell, bool spread, const ScrStr *s
   return out;
 }
 
+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;
+  }
+  return isl_dynjs_unpack_array(r);
+}
+
 static ScrDyn *isl_dynjs_iterator(ScrJsval *cell, const ScrStr *spell, bool array_from) {
   isl_entry();
   JSValue s = spell && spell->len ? JS_NewStringLen(isl_ctx, spell->data, spell->len) : JS_UNDEFINED;
@@ -1398,6 +1414,14 @@ static ScrDyn *isl_dynjs_iterator(ScrJsval *cell, const ScrStr *spell, bool arra
   return out;
 }
 
+static ScrDyn *isl_dynjs_iter_n(ScrJsval *cell, double count) {
+  ScrJsval *prefix = scr_jsval_iter_n(cell, count);
+  if (!prefix) return NULL;
+  ScrDyn *out = isl_dynjs_unpack_array(JS_DupValue(isl_ctx, prefix->v));
+  scr_jsval_release(prefix);
+  return out;
+}
+
 static const ScrDynJsvalOps isl_dynjs_ops = {
   isl_dynjs_release,
   isl_dynjs_typeof,
@@ -1417,6 +1441,7 @@ static const ScrDynJsvalOps isl_dynjs_ops = {
   isl_dynjs_to_json,
   isl_dynjs_iter_drain,
   isl_dynjs_iterator,
+  isl_dynjs_iter_n,
 };
 
 ScrDyn *scr_dyn_from_jsval(ScrJsval *cell) {
@@ -2638,7 +2663,7 @@ static JSValue isl_host_env(JSContext *ctx, JSValueConst this_val, int argc,
   for (size_t i = 0; i + 1 < n; i += 2) {
     ScrStr *k = scr_arr_get_ref(pairs, (double)i);
     ScrStr *v = scr_arr_get_ref(pairs, (double)(i + 1));
-    JS_SetPropertyStr(ctx, obj, k->data, JS_NewStringLen(ctx, v->data, v->len));
+    JS_DefinePropertyValueStr(ctx, obj, k->data, JS_NewStringLen(ctx, v->data, v->len), JS_PROP_C_W_E);
     scr_str_release(k);
     scr_str_release(v);
   }
@@ -2831,6 +2856,120 @@ static ScrStr *isl_arg_str(JSContext *ctx, JSValueConst v) {
   return out;
 }
 
+/* Dotenv and environment mutations share the native process environment.
+ * The JS layer validates types before these host calls. */
+static JSValue isl_host_env_get(JSContext *ctx, JSValueConst this_val, int argc,
+                                JSValueConst *argv) {
+  (void)this_val; (void)argc;
+  ScrStr *key = isl_arg_str(ctx, argv[0]);
+  if (!key) return JS_EXCEPTION;
+  ScrStr *value = scr_env_get(key);
+  scr_str_release(key);
+  JSValue result = value ? JS_NewStringLen(ctx, value->data, value->len) : JS_UNDEFINED;
+  scr_str_release(value);
+  return result;
+}
+
+static JSValue isl_host_chdir(JSContext *ctx, JSValueConst this_val, int argc,
+                              JSValueConst *argv) {
+  (void)this_val; (void)argc;
+  ScrStr *directory = isl_arg_str(ctx, argv[0]);
+  if (!directory) return JS_EXCEPTION;
+  scr_process_chdir(directory);
+  scr_str_release(directory);
+  return scr_exc_pending() ? isl_throw_pending(ctx) : JS_UNDEFINED;
+}
+
+static JSValue isl_host_env_set(JSContext *ctx, JSValueConst this_val, int argc,
+                                JSValueConst *argv) {
+  (void)this_val; (void)argc;
+  ScrStr *key = isl_arg_str(ctx, argv[0]);
+  if (!key) return JS_EXCEPTION;
+  ScrStr *value = isl_arg_str(ctx, argv[1]);
+  if (!value) { scr_str_release(key); return JS_EXCEPTION; }
+  scr_env_set(key, value);
+  scr_str_release(key);
+  scr_str_release(value);
+  return JS_TRUE;
+}
+
+static JSValue isl_host_env_delete(JSContext *ctx, JSValueConst this_val, int argc,
+                                   JSValueConst *argv) {
+  (void)this_val; (void)argc;
+  ScrStr *key = isl_arg_str(ctx, argv[0]);
+  if (!key) return JS_EXCEPTION;
+  scr_env_unset(key);
+  scr_str_release(key);
+  return JS_TRUE;
+}
+
+static JSValue isl_host_parse_env(JSContext *ctx, JSValueConst this_val, int argc,
+                                  JSValueConst *argv) {
+  (void)this_val; (void)argc;
+  ScrDyn *content = isl_dyn_from_value(argv[0]);
+  ScrDyn *parsed = scr_util_parse_env(content);
+  scr_dyn_release(content);
+  if (!parsed) return isl_throw_pending(ctx);
+  /* Preserve embedded NUL keys: JS_SetPropertyStr would truncate them. */
+  JSValue result = JS_NewObject(ctx);
+  for (size_t i = 0; i < parsed->v.obj.len; i++) {
+    const ScrDynEntry *entry = &parsed->v.obj.entries[i];
+    JSAtom key = JS_NewAtomLen(ctx, entry->key, entry->key_len);
+    int status = JS_SetProperty(ctx, result, key, isl_from_dyn(entry->value));
+    JS_FreeAtom(ctx, key);
+    if (status < 0) { JS_FreeValue(ctx, result); result = JS_EXCEPTION; break; }
+  }
+  scr_dyn_release(parsed);
+  return result;
+}
+
+static JSValue isl_host_transcode(JSContext *ctx, JSValueConst this_val, int argc,
+                                   JSValueConst *argv) {
+  (void)this_val;
+  if (argc != 3) return JS_ThrowTypeError(ctx, "invalid transcode bridge arity");
+  size_t length = 0;
+  uint8_t *data = JS_GetUint8Array(ctx, &length, argv[0]);
+  if (!data && length) return JS_EXCEPTION;
+  ScrBytes bytes = {0};
+  bytes.elem = SCR_BYTES_U8; bytes.len = length; bytes.data = data;
+  ScrDyn source = {0};
+  source.kind = SCR_DYN_BYTES; source.v.bytes = &bytes;
+  ScrDyn *from = isl_dyn_from_value(argv[1]), *to = isl_dyn_from_value(argv[2]);
+  ScrBytes *result = scr_buffer_transcode(&source, from, to);
+  scr_dyn_release(from); scr_dyn_release(to);
+  if (!result) {
+    JSValue error = isl_pending_to_value(ctx);
+    JSValue code = JS_GetPropertyStr(ctx, error, "code");
+    const char *name = JS_ToCString(ctx, code);
+    if (name && strcmp(name, "U_INVALID_CHAR_FOUND") == 0) JS_SetPropertyStr(ctx, error, "errno", JS_NewInt32(ctx, 10));
+    else if (name && strcmp(name, "U_ILLEGAL_ARGUMENT_ERROR") == 0) JS_SetPropertyStr(ctx, error, "errno", JS_NewInt32(ctx, 1));
+    JS_FreeCString(ctx, name); JS_FreeValue(ctx, code);
+    return JS_Throw(ctx, error);
+  }
+  JSValue value = JS_NewUint8ArrayCopy(ctx, result->data, result->len);
+  scr_bytes_release(result);
+  return value;
+}
+
+static JSValue isl_host_load_env_file(JSContext *ctx, JSValueConst this_val, int argc,
+                                      JSValueConst *argv) {
+  (void)this_val;
+  ScrDyn *path;
+  if (argc > 1 && JS_ToBool(ctx, argv[1])) {
+    size_t len;
+    uint8_t *data = JS_GetUint8Array(ctx, &len, argv[0]);
+    if (!data) return JS_EXCEPTION;
+    ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)len);
+    if (len) memcpy(bytes->data, data, len);
+    path = scr_dyn_new_bytes(bytes);
+    path->buffer = argc > 2 && JS_ToBool(ctx, argv[2]);
+    scr_bytes_release(bytes);
+  } else path = isl_dyn_from_value(argc ? argv[0] : JS_UNDEFINED);
+  scr_process_load_env_file(path);
+  scr_dyn_release(path);
+  return scr_exc_pending() ? isl_throw_pending(ctx) : JS_UNDEFINED;
+}
+
 static JSValue isl_host_fs(JSContext *ctx, JSValueConst this_val, int argc,
                            JSValueConst *argv) {
   (void)this_val;
@@ -2846,8 +2985,47 @@ static JSValue isl_host_fs(JSContext *ctx, JSValueConst this_val, int argc,
       return JS_EXCEPTION;
     }
   }
-  if (strcmp(op, "readFile") == 0) {
-    ScrBytes *data = scr_fs_read_file_bytes(a);
+  if (strcmp(op, "open") == 0) {
+    double flags = 0, mode = 0666;
+    JS_ToFloat64(ctx, &flags, argv[2]);
+    JS_ToFloat64(ctx, &mode, argv[3]);
+    ret = JS_NewFloat64(ctx, scr_fs_open_native(a, flags, mode));
+  } else if (strcmp(op, "close") == 0 || strcmp(op, "fsync") == 0 ||
+             strcmp(op, "fdatasync") == 0 || strcmp(op, "ftruncate") == 0 ||
+             strcmp(op, "fchmod") == 0) {
+    double fd = 0, value = 0;
+    JS_ToFloat64(ctx, &fd, argv[1]);
+    if (argc > 2) JS_ToFloat64(ctx, &value, argv[2]);
+    if (strcmp(op, "close") == 0) scr_fs_close(fd);
+    else if (strcmp(op, "fsync") == 0) scr_fs_fsync(fd);
+    else if (strcmp(op, "fdatasync") == 0) scr_fs_fdatasync(fd);
+    else if (strcmp(op, "ftruncate") == 0) scr_fs_ftruncate(fd, value);
+    else scr_fs_fchmod(fd, value);
+  } else if (strcmp(op, "read") == 0 || strcmp(op, "write") == 0 ||
+             strcmp(op, "readv") == 0 || strcmp(op, "writev") == 0) {
+    double fd = 0, offset = 0, length = 0, position = -1;
+    JS_ToFloat64(ctx, &fd, argv[1]);
+    JS_ToFloat64(ctx, &offset, argv[3]);
+    JS_ToFloat64(ctx, &length, argv[4]);
+    JS_ToFloat64(ctx, &position, argv[5]);
+    size_t size = 0;
+    uint8_t *data = JS_GetUint8Array(ctx, &size, argv[2]);
+    if (data || size == 0) {
+      ScrBytes buffer = {SIZE_MAX, size, SCR_BYTES_U8, data, NULL};
+      if (strcmp(op, "readv") == 0 && argc > 6 && JS_ToBool(ctx, argv[6])) {
+        scr_fs_throw(EINVAL, "read", NULL);
+      } else {
+        double n = op[0] == 'r'
+          ? strcmp(op, "readv") == 0 && length == 0 ? scr_fs_read_zero(fd, position)
+            : scr_fs_read_sync(fd, &buffer, offset, length, position)
+          : scr_fs_write_sync(fd, &buffer, offset, length, position);
+        ret = JS_NewFloat64(ctx, n);
+      }
+    } else ret = JS_EXCEPTION;
+  } else if (strcmp(op, "readFile") == 0) {
+    double fd = 0;
+    if (!a) JS_ToFloat64(ctx, &fd, argv[1]);
+    ScrBytes *data = a ? scr_fs_read_file_bytes(a) : scr_fs_read_fd_bytes(fd);
     if (data) {
       ret = JS_NewUint8ArrayCopy(ctx, data->data, (size_t)scr_bytes_len(data));
       scr_bytes_release(data);
@@ -2856,10 +3034,22 @@ static JSValue isl_host_fs(JSContext *ctx, JSValueConst this_val, int argc,
     size_t len = 0;
     uint8_t *buf = JS_GetUint8Array(ctx, &len, argv[2]);
     if (buf || len == 0) {
-      ScrStr *data = scr_str_new((const char *)buf, len);
-      if (strcmp(op, "writeFile") == 0) scr_fs_write_file(a, data);
-      else scr_fs_append_file(a, data);
-      scr_str_release(data);
+      if (a) {
+        ScrStr *data = scr_str_new((const char *)buf, len);
+        if (strcmp(op, "writeFile") == 0) scr_fs_write_file(a, data);
+        else scr_fs_append_file(a, data);
+        scr_str_release(data);
+      } else {
+        double fd = 0;
+        JS_ToFloat64(ctx, &fd, argv[1]);
+        ScrBytes buffer = {SIZE_MAX, len, SCR_BYTES_U8, buf, NULL};
+        size_t at = 0;
+        while (at < len && !scr_exc_pending()) {
+          double n = scr_fs_write_sync(fd, &buffer, (double)at, (double)(len - at), -1);
+          if (n <= 0) { if (!scr_exc_pending()) scr_fs_throw(EIO, "write", NULL); break; }
+          at += (size_t)n;
+        }
+      }
     } else {
       ret = JS_EXCEPTION;
     }
@@ -2920,8 +3110,11 @@ static JSValue isl_host_fs(JSContext *ctx, JSValueConst this_val, int argc,
       scr_fs_scandir_free(s);
       ret = arr;
     }
-  } else if (strcmp(op, "stat") == 0 || strcmp(op, "lstat") == 0) {
-    ScrStats *st = strcmp(op, "stat") == 0 ? scr_fs_stat(a) : scr_fs_lstat(a);
+  } else if (strcmp(op, "stat") == 0 || strcmp(op, "lstat") == 0 || strcmp(op, "fstat") == 0) {
+    double fd = 0;
+    if (strcmp(op, "fstat") == 0) JS_ToFloat64(ctx, &fd, argv[1]);
+    ScrStats *st = strcmp(op, "fstat") == 0 ? scr_fs_fstat(fd)
+      : strcmp(op, "stat") == 0 ? scr_fs_stat(a) : scr_fs_lstat(a);
     if (st) {
       JSValue arr = JS_NewArray(ctx);
       JS_SetPropertyUint32(ctx, arr, 0, JS_NewBool(ctx, scr_stats_is_file(st)));
@@ -3180,6 +3373,14 @@ static JSValue isl_host_fs_constants(JSContext *ctx, JSValueConst this_val, int
   ISL_CONST(O_EXCL);
   ISL_CONST(O_TRUNC);
   ISL_CONST(O_APPEND);
+#ifdef O_SYNC
+  ISL_CONST(O_SYNC);
+#else
+  JS_SetPropertyStr(ctx, o, "O_SYNC", JS_NewInt32(ctx, 0));
+#endif
+#ifdef O_NOFOLLOW
+  ISL_CONST(O_NOFOLLOW);
+#endif
 #ifdef O_NONBLOCK
   ISL_CONST(O_NONBLOCK);
 #endif
@@ -3228,7 +3429,7 @@ static JSValue isl_host_digest(JSContext *ctx, JSValueConst this_val, int argc,
     JS_FreeCString(ctx, alg);
     return JS_EXCEPTION;
   }
-  unsigned char out[32];
+  unsigned char out[64];
   size_t n = scr_crypto_digest_raw(alg, data, len, out);
   JS_FreeCString(ctx, alg);
   return n == 0 ? JS_UNDEFINED : JS_NewUint8ArrayCopy(ctx, out, n);
@@ -3248,12 +3449,38 @@ static JSValue isl_host_hmac(JSContext *ctx, JSValueConst this_val, int argc,
     JS_FreeCString(ctx, alg);
     return JS_EXCEPTION;
   }
-  unsigned char out[32];
+  unsigned char out[64];
   size_t n = scr_crypto_hmac_raw(alg, key, keylen, data, len, out);
   JS_FreeCString(ctx, alg);
   return n == 0 ? JS_UNDEFINED : JS_NewUint8ArrayCopy(ctx, out, n);
 }
 
+/* The island validates JavaScript overloads; the native RFC 7914 core
+ * owns memory accounting, ROMix, and sensitive scratch cleanup. */
+static JSValue isl_host_scrypt(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+  (void)this_val;
+  if (argc != 7) return JS_ThrowTypeError(ctx, "invalid scrypt bridge arity");
+  size_t password_len = 0, salt_len = 0;
+  uint8_t *password_data = JS_GetUint8Array(ctx, &password_len, argv[0]);
+  uint8_t *salt_data = JS_GetUint8Array(ctx, &salt_len, argv[1]);
+  if ((!password_data && password_len) || (!salt_data && salt_len)) return JS_EXCEPTION;
+  double values[5];
+  for (int i = 0; i < 5; i++) if (JS_ToFloat64(ctx, &values[i], argv[i + 2]) < 0) return JS_EXCEPTION;
+  /* These wrappers borrow engine storage for the synchronous core. No
+   * extra heap copies of the password or salt outlive the bridge call. */
+  ScrBytes password = {0}, salt = {0};
+  password.elem = salt.elem = SCR_BYTES_U8;
+  password.len = password_len;
+  password.data = password_data;
+  salt.len = salt_len;
+  salt.data = salt_data;
+  ScrBytes *result = scr_crypto_scrypt_derive(&password, &salt, values[0], values[1], values[2], values[3], values[4]);
+  if (scr_exc_pending()) return isl_throw_pending(ctx);
+  JSValue value = JS_NewUint8ArrayCopy(ctx, result->data, result->len);
+  scr_bytes_release(result);
+  return value;
+}
+
 static JSValue isl_host_pid(JSContext *ctx, JSValueConst this_val, int argc,
                             JSValueConst *argv) {
   (void)this_val;
@@ -3633,20 +3860,19 @@ static const char isl_modules_bootstrap[] =
     /* Node's events module: the emitter surface streams and CLIs drive —
      * prepend/once/remove with listener-unwrap, maxListeners bookkeeping
      * (warnings are not emitted), eventNames/rawListeners, Node's
-     * unhandled-'error' throw, and the once/getEventListeners statics.
+     * unhandled-'error' throw, cancellable once, and async event iteration.
      * EventEmitter is callable so legacy constructors can use .call(this). */
     "  builtins.events = memo(() => {\n"
     "    function EventEmitter() {\n"
     "      if (this._events === undefined || !Object.prototype.hasOwnProperty.call(this, '_events')) this._events = Object.create(null);\n"
     "      if (!Object.prototype.hasOwnProperty.call(this, '_maxListeners')) this._maxListeners = undefined;\n"
     "    }\n"
+    "    const checkListener = (listener) => {\n"
+    "      if (typeof listener !== 'function') envArgumentError('listener', 'of type function', listener);\n"
+    "    };\n"
     "    class EventEmitterMethods {\n"
     "      _add(n, f, prepend) {\n"
-    "        if (typeof f !== 'function') {\n"
-    "          const e = new TypeError('The \"listener\" argument must be of type function. Received ' + (f === null ? 'null' : typeof f));\n"
-    "          e.code = 'ERR_INVALID_ARG_TYPE';\n"
-    "          throw e;\n"
-    "        }\n"
+    "        checkListener(f);\n"
     "        this.emit('newListener', n, f.listener !== undefined ? f.listener : f);\n"
     "        const a = this._events[n] = this._events[n] || [];\n"
     "        if (prepend) a.unshift(f); else a.push(f);\n"
@@ -3656,42 +3882,64 @@ static const char isl_modules_bootstrap[] =
     "      addListener(n, f) { return this.on(n, f); }\n"
     "      prependListener(n, f) { return this._add(n, f, true); }\n"
     "      _wrapOnce(n, f) {\n"
-    "        const g = (...a) => { this.removeListener(n, g); f.apply(this, a); };\n"
+    "        let fired = false;\n"
+    "        const g = (...a) => {\n"
+    "          if (fired) return;\n"
+    "          this.removeListener(n, g);\n"
+    "          fired = true;\n"
+    "          return f.apply(this, a);\n"
+    "        };\n"
+    "        Object.defineProperty(g, \"name\", { value: \"bound onceWrapper\", configurable: true });\n"
     "        g.listener = f;\n"
     "        return g;\n"
     "      }\n"
-    "      once(n, f) { return this._add(n, this._wrapOnce(n, f), false); }\n"
-    "      prependOnceListener(n, f) { return this._add(n, this._wrapOnce(n, f), true); }\n"
+    "      once(n, f) { checkListener(f); return this._add(n, this._wrapOnce(n, f), false); }\n"
+    "      prependOnceListener(n, f) { checkListener(f); return this._add(n, this._wrapOnce(n, f), true); }\n"
     "      removeListener(n, f) {\n"
+    "        checkListener(f);\n"
     "        const a = this._events[n];\n"
     "        if (a) {\n"
-    "          const i = a.findIndex((x) => x === f || x.listener === f);\n"
+    "          let i = a.length - 1;\n"
+    "          while (i >= 0 && a[i] !== f && a[i].listener !== f) i--;\n"
     "          if (i >= 0) {\n"
-    "            const x = a[i];\n"
+    "            const x = a.length === 1 ? (a[i].listener !== undefined ? a[i].listener : a[i]) : f;\n"
     "            a.splice(i, 1);\n"
     "            if (a.length === 0) delete this._events[n];\n"
-    "            this.emit('removeListener', n, x.listener !== undefined ? x.listener : x);\n"
+    "            this.emit('removeListener', n, x);\n"
     "          }\n"
     "        }\n"
     "        return this;\n"
     "      }\n"
     "      off(n, f) { return this.removeListener(n, f); }\n"
     "      removeAllListeners(n) {\n"
-    "        if (n === undefined) this._events = Object.create(null);\n"
-    "        else delete this._events[n];\n"
+    "        if (!this._events.removeListener) {\n"
+    "          if (arguments.length === 0) this._events = Object.create(null);\n"
+    "          else delete this._events[n];\n"
+    "          return this;\n"
+    "        }\n"
+    "        if (arguments.length === 0) {\n"
+    "          for (const key of Reflect.ownKeys(this._events)) {\n"
+    "            if (key !== 'removeListener') this.removeAllListeners(key);\n"
+    "          }\n"
+    "          this.removeAllListeners('removeListener');\n"
+    "          this._events = Object.create(null);\n"
+    "        } else {\n"
+    "          const listeners = this._events[n];\n"
+    "          if (listeners) for (let i = listeners.length - 1; i >= 0; i--) this.removeListener(n, listeners[i]);\n"
+    "        }\n"
     "        return this;\n"
     "      }\n"
     "      setMaxListeners(m) { this._maxListeners = m; return this; }\n"
     "      getMaxListeners() { return this._maxListeners === undefined ? EventEmitter.defaultMaxListeners : this._maxListeners; }\n"
     "      emit(n, ...args) {\n"
+    "        if (n === 'error' && this._events[EventEmitter.errorMonitor]) this.emit(EventEmitter.errorMonitor, ...args);\n"
     "        const a = this._events[n];\n"
     "        if (!a || a.length === 0) {\n"
     "          if (n === 'error') {\n"
-    /* Node throws the unhandled error payload (or a synthetic one) —
-     * inside the island this crosses the bridge like any engine throw. */
+    /* Unhandled error payloads cross the bridge as engine exceptions. */
     "            const err = args[0];\n"
     "            if (err instanceof Error) throw err;\n"
-    "            const e = new Error(\"Unhandled error.\" + (err === undefined ? '' : ' (' + String(err) + ')'));\n"
+    "            const e = new Error(\"Unhandled error.\" + ' (' + builtins.util().inspect(err) + ')');\n"
     "            e.code = 'ERR_UNHANDLED_ERROR';\n"
     "            e.context = err;\n"
     "            throw e;\n"
@@ -3701,13 +3949,16 @@ static const char isl_modules_bootstrap[] =
     "        for (const f of a.slice()) f.apply(this, args);\n"
     "        return true;\n"
     "      }\n"
-    "      listenerCount(n) { const a = this._events[n]; return a ? a.length : 0; }\n"
+    "      listenerCount(n, listener) {\n"
+    "        const a = this._events[n];\n"
+    "        return a ? listener == null ? a.length : a.filter(f => f === listener || f.listener === listener).length : 0;\n"
+    "      }\n"
     "      listeners(n) {\n"
     "        const a = this._events[n];\n"
     "        return a ? a.map((x) => (x.listener !== undefined ? x.listener : x)) : [];\n"
     "      }\n"
     "      rawListeners(n) { const a = this._events[n]; return a ? a.slice() : []; }\n"
-    "      eventNames() { return Object.keys(this._events); }\n"
+    "      eventNames() { return Reflect.ownKeys(this._events); }\n"
     "    }\n"
     "    EventEmitter.prototype = EventEmitterMethods.prototype;\n"
     "    EventEmitter.prototype.constructor = EventEmitter;\n"
@@ -3717,18 +3968,155 @@ static const char isl_modules_bootstrap[] =
     "    EventEmitter.listenerCount = (emitter, n) => emitter.listenerCount(n);\n"
     "    EventEmitter.getEventListeners = (emitter, n) => emitter.listeners(n);\n"
     "    EventEmitter.setMaxListeners = (m, ...emitters) => { for (const e of emitters) e.setMaxListeners(m); };\n"
-    "    EventEmitter.once = (emitter, name) => new Promise((resolve, reject) => {\n"
-    "      const onEvent = (...args) => {\n"
-    "        emitter.removeListener('error', onError);\n"
-    "        resolve(args);\n"
+    "    const resistStopPropagation = Symbol.for('scriptc.events.resistStopPropagation');\n"
+    "    const checkSignal = (signal, name) => {\n"
+    "      if (signal !== undefined && (signal === null || typeof signal !== 'object' || !('aborted' in signal)))\n"
+    "        envArgumentError(name, 'an instance of AbortSignal', signal);\n"
+    "    };\n"
+    "    const checkOptions = (options) => {\n"
+    "      if (options === null || typeof options !== 'object' || Array.isArray(options))\n"
+    "        envArgumentError('options', 'of type object', options);\n"
+    "    };\n"
+    "    const abortError = (signal) => {\n"
+    "      const error = new Error('The operation was aborted', { cause: signal.reason });\n"
+    "      error.name = 'AbortError';\n"
+    "      error.code = 'ABORT_ERR';\n"
+    "      return error;\n"
+    "    };\n"
+    "    const add = (emitter, name, listener, flags) => {\n"
+    "      if (typeof emitter.on === 'function') {\n"
+    "        if (flags && flags.once) emitter.once(name, listener);\n"
+    "        else emitter.on(name, listener);\n"
+    "      } else if (typeof emitter.addEventListener === 'function') emitter.addEventListener(name, listener, flags);\n"
+    "      else envArgumentError('emitter', 'an instance of EventEmitter', emitter);\n"
+    "    };\n"
+    "    const remove = (emitter, name, listener) => {\n"
+    "      if (typeof emitter.removeListener === 'function') emitter.removeListener(name, listener);\n"
+    "      else if (typeof emitter.removeEventListener === 'function') emitter.removeEventListener(name, listener);\n"
+    "      else envArgumentError('emitter', 'an instance of EventEmitter', emitter);\n"
+    "    };\n"
+    "    EventEmitter.addAbortListener = (signal, listener) => {\n"
+    "      if (signal === undefined) envArgumentError('signal', 'an instance of AbortSignal', signal);\n"
+    "      checkSignal(signal, 'signal');\n"
+    "      checkListener(listener);\n"
+    "      let dispose;\n"
+    "      if (signal.aborted) queueMicrotask(() => listener());\n"
+    "      else {\n"
+    "        signal.addEventListener('abort', listener, { once: true, [resistStopPropagation]: true });\n"
+    "        dispose = () => signal.removeEventListener('abort', listener);\n"
+    "      }\n"
+    "      return { __proto__: null, [Symbol.dispose]() { if (dispose) dispose(); } };\n"
+    "    };\n"
+    "    EventEmitter.once = async (emitter, name, options = {}) => {\n"
+    "      checkOptions(options);\n"
+    "      const signal = options.signal;\n"
+    "      checkSignal(signal, 'options.signal');\n"
+    "      if (signal && signal.aborted) throw abortError(signal);\n"
+    "      return new Promise((resolve, reject) => {\n"
+    "        const onError = (err) => {\n"
+    "          remove(emitter, name, onEvent);\n"
+    "          if (signal) remove(signal, 'abort', onAbort);\n"
+    "          reject(err);\n"
+    "        };\n"
+    "        const onEvent = (...args) => {\n"
+    "          if (typeof emitter.removeListener === 'function') emitter.removeListener('error', onError);\n"
+    "          if (signal) remove(signal, 'abort', onAbort);\n"
+    "          resolve(args);\n"
+    "        };\n"
+    "        const onAbort = () => {\n"
+    "          remove(emitter, name, onEvent);\n"
+    "          remove(emitter, 'error', onError);\n"
+    "          reject(abortError(signal));\n"
+    "        };\n"
+    "        const flags = { __proto__: null, once: true, [resistStopPropagation]: true };\n"
+    "        add(emitter, name, onEvent, flags);\n"
+    "        if (name !== 'error' && typeof emitter.once === 'function') emitter.once('error', onError);\n"
+    "        if (signal) add(signal, 'abort', onAbort, flags);\n"
+    "      });\n"
+    "    };\n"
+    "    const queue = () => {\n"
+    "      let values = [], head = 0;\n"
+    "      return {\n"
+    "        get size() { return values.length - head; },\n"
+    "        push(value) { values.push(value); },\n"
+    "        shift() {\n"
+    "          const value = values[head];\n"
+    "          values[head++] = undefined;\n"
+    "          if (head === values.length) { values = []; head = 0; }\n"
+    "          else if (head >= 1024 && head * 2 > values.length) { values = values.slice(head); head = 0; }\n"
+    "          return value;\n"
+    "        },\n"
+    "      };\n"
+    "    };\n"
+    "    const checkWatermark = (value, name) => {\n"
+    "      if (typeof value !== 'number') envArgumentError(name, 'of type number', value);\n"
+    "      if (!Number.isInteger(value) || value < 1 || value > Number.MAX_SAFE_INTEGER) {\n"
+    "        const range = Number.isInteger(value) ? '>= 1 && <= 9007199254740991' : 'an integer';\n"
+    "        const received = Number.isInteger(value) && Math.abs(value) > 2 ** 32 ? String(value).replace(/\\B(?=(\\d{3})+(?!\\d))/g, '_') : String(value);\n"
+    "        const error = new RangeError('The value of \"' + name + '\" is out of range. It must be ' + range + '. Received ' + received);\n"
+    "        error.code = 'ERR_OUT_OF_RANGE';\n"
+    "        throw error;\n"
+    "      }\n"
+    "    };\n"
+    "    const iteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf((async function* () {})())));\n"
+    "    EventEmitter.on = (emitter, name, options = {}) => {\n"
+    "      checkOptions(options);\n"
+    "      const signal = options.signal;\n"
+    "      checkSignal(signal, 'options.signal');\n"
+    "      if (signal && signal.aborted) throw abortError(signal);\n"
+    "      const high = options.highWaterMark ?? options.highWatermark ?? Number.MAX_SAFE_INTEGER;\n"
+    "      checkWatermark(high, 'options.highWaterMark');\n"
+    "      const low = options.lowWaterMark ?? options.lowWatermark ?? 1;\n"
+    "      checkWatermark(low, 'options.lowWaterMark');\n"
+    "      const events = queue(), pending = queue(), listeners = [];\n"
+    "      let paused = false, error = null, finished = false, abortListener;\n"
+    "      const close = () => {\n"
+    "        if (abortListener) abortListener[Symbol.dispose]();\n"
+    "        while (listeners.length) { const [event, handler] = listeners.pop(); remove(emitter, event, handler); }\n"
+    "        finished = true;\n"
+    "        paused = false;\n"
+    "        const result = { value: undefined, done: true };\n"
+    "        while (pending.size) pending.shift().resolve(result);\n"
+    "        return Promise.resolve(result);\n"
     "      };\n"
     "      const onError = (err) => {\n"
-    "        emitter.removeListener(name, onEvent);\n"
-    "        reject(err);\n"
+    "        if (pending.size) pending.shift().reject(err);\n"
+    "        else error = err;\n"
+    "        close();\n"
     "      };\n"
-    "      emitter.once(name, onEvent);\n"
-    "      if (name !== 'error') emitter.once('error', onError);\n"
-    "    });\n"
+    "      const onEvent = (...args) => {\n"
+    "        if (pending.size) pending.shift().resolve({ value: args, done: false });\n"
+    "        else {\n"
+    "          if (!paused && events.size + 1 > high) { paused = true; emitter.pause(); }\n"
+    "          events.push(args);\n"
+    "        }\n"
+    "      };\n"
+    "      const iterator = Object.setPrototypeOf({\n"
+    "        next() {\n"
+    "          if (events.size) {\n"
+    "            const value = events.shift();\n"
+    "            if (paused && events.size < low) { emitter.resume(); paused = false; }\n"
+    "            return Promise.resolve({ value, done: false });\n"
+    "          }\n"
+    "          if (error) { const err = error; error = null; return Promise.reject(err); }\n"
+    "          if (finished) return close();\n"
+    "          return new Promise((resolve, reject) => pending.push({ resolve, reject }));\n"
+    "        },\n"
+    "        return() { return close(); },\n"
+    "        throw(err) {\n"
+    "          if (!(err instanceof Error)) envArgumentError('EventEmitter.AsyncIterator', 'an instance of Error', err);\n"
+    "          onError(err);\n"
+    "        },\n"
+    "        [Symbol.asyncIterator]() { return this; },\n"
+    "      }, iteratorPrototype);\n"
+    "      const listen = (event, handler) => { add(emitter, event, handler); listeners.push([event, handler]); };\n"
+    "      listen(name, onEvent);\n"
+    "      if (name !== 'error' && typeof emitter.on === 'function') listen('error', onError);\n"
+    "      const closeEvents = options.close;\n"
+    "      if (closeEvents && closeEvents.length) { for (let i = 0; i < closeEvents.length; i++) listen(closeEvents[i], close); }\n"
+    "      if (signal) abortListener = EventEmitter.addAbortListener(signal, () => onError(abortError(signal)));\n"
+    "      return iterator;\n"
+    "    };\n"
     "    EventEmitter.EventEmitter = EventEmitter;\n"
     "    EventEmitter.default = EventEmitter;\n"
     "    return EventEmitter;\n"
@@ -3962,13 +4350,19 @@ static const char isl_modules_bootstrap[] =
     "function makeFs(env) {\n"
     "  const Buffer = env.Buffer;\n"
     "  const constants = env.fsConstants();\n"
-    "  const call = env.fs;\n"
+    "  const call = (op, ...args) => {\n"
+    "    try { return env.fs(op, ...args); } catch (e) {\n"
+    "      if (e.code && !e.code.startsWith('ERR_') && e.code !== 'SC2020') {\n"
+    "        e.syscall = op === 'readv' ? 'read' : op === 'writev' ? 'write' : op;\n"
+    "        if (typeof args[0] === 'string') e.path = args[0];\n"
+    "      }\n"
+    "      throw e;\n"
+    "    }\n"
+    "  };\n"
     "  const pathOf = (p) => {\n"
     "    if (typeof p === \"string\") return p;\n"
     "    if (p instanceof Uint8Array) return Buffer.from(p).toString(\"utf8\");\n"
-    "    if (p !== null && typeof p === \"object\" && typeof p.href === \"string\" && p.href.startsWith(\"file://\")) {\n"
-    "      return decodeURIComponent(p.href.slice(7));\n"
-    "    }\n"
+    "    if (p instanceof env.URL) return env.fileURLToPath(p);\n"
     "    const e = new TypeError('The \"path\" argument must be of type string or an instance of Buffer or URL. Received ' + (p === null ? \"null\" : typeof p === \"object\" ? \"an instance of \" + ((p.constructor && p.constructor.name) || \"Object\") : \"type \" + typeof p + \" (\" + JSON.stringify(p) + \")\"));\n"
     "    e.code = \"ERR_INVALID_ARG_TYPE\";\n"
     "    throw e;\n"
@@ -4024,16 +4418,16 @@ static const char isl_modules_bootstrap[] =
     "    isBlockDevice() { return this._kind === 7; }\n"
     "  }\n"
     "  const readFileSync = (p, options) => {\n"
-    "    const u8 = call(\"readFile\", pathOf(p));\n"
+    "    const u8 = call(\"readFile\", typeof p === \"number\" ? fdOf(p) : pathOf(p));\n"
     "    const enc = encodingOf(options, null);\n"
     "    const buf = Buffer.from(u8.buffer, u8.byteOffset, u8.length);\n"
     "    return enc === null ? buf : buf.toString(enc);\n"
     "  };\n"
     "  const writeFileSync = (p, data, options) => {\n"
-    "    call(\"writeFile\", pathOf(p), dataToU8(data, options));\n"
+    "    call(\"writeFile\", typeof p === \"number\" ? fdOf(p) : pathOf(p), dataToU8(data, options));\n"
     "  };\n"
     "  const appendFileSync = (p, data, options) => {\n"
-    "    call(\"appendFile\", pathOf(p), dataToU8(data, options));\n"
+    "    call(\"appendFile\", typeof p === \"number\" ? fdOf(p) : pathOf(p), dataToU8(data, options));\n"
     "  };\n"
     "  const existsSync = (p) => {\n"
     "    try {\n"
@@ -4087,11 +4481,209 @@ static const char isl_modules_bootstrap[] =
     "  const readlinkSync = (p) => call(\"readlink\", pathOf(p));\n"
     "  const copyFileSync = (src, dest) => call(\"copyFile\", pathOf(src), pathOf(dest));\n"
     "  const renameSync = (src, dest) => call(\"rename\", pathOf(src), pathOf(dest));\n"
+    "  // Descriptor callbacks validate before scheduling; only system I/O failures\n"
+    "  // travel through the callback. Payloads always retain the caller's identity.\n"
+    "  const received = (v) => v === undefined ? 'undefined' : v === null ? 'null' : typeof v === 'string' ? 'type string (' + JSON.stringify(v) + ')' : typeof v === 'object' ? 'an instance of ' + ((v.constructor && v.constructor.name) || 'Object') : 'type ' + typeof v + ' (' + String(v) + ')';\n"
+    "  const failType = (name, expected, v) => { const e = new TypeError('The \"' + name + '\" argument must be ' + expected + '. Received ' + received(v)); e.code = 'ERR_INVALID_ARG_TYPE'; throw e; };\n"
+    "  const failRange = (name, range, v) => { const e = new RangeError('The value of \"' + name + '\" is out of range. It must be ' + range + '. Received ' + String(v)); e.code = 'ERR_OUT_OF_RANGE'; throw e; };\n"
+    "  const integer = (v, name, min = -9007199254740991, max = 9007199254740991) => {\n"
+    "    if (typeof v !== 'number') failType(name, 'of type number', v);\n"
+    "    if (!Number.isInteger(v)) failRange(name, 'an integer', v);\n"
+    "    if (v < min || v > max) failRange(name, '>= ' + min + ' && <= ' + max, v);\n"
+    "    return v;\n"
+    "  };\n"
+    "  const fdOf = (fd) => integer(fd, 'fd', 0, 2147483647);\n"
+    "  const cbOf = (cb) => { if (typeof cb !== 'function') failType('cb', 'of type function', cb); return cb; };\n"
+    "  const optionsOf = (o) => { if (o != null && (typeof o !== 'object' || Array.isArray(o))) failType('options', 'of type object', o); return o || {}; };\n"
+    "  const viewOf = (v) => { if (!ArrayBuffer.isView(v)) failType('buffer', 'an instance of Buffer, TypedArray, or DataView', v); return new Uint8Array(v.buffer, v.byteOffset, v.byteLength); };\n"
+    "  const modeOf = (m, dflt = 0o666) => { if (m === undefined) return dflt; if (typeof m === 'string') { if (!/^[0-7]+$/.test(m)) { const e = new TypeError(\"The argument 'mode' must be a 32-bit unsigned integer or an octal string. Received '\" + m + \"'\"); e.code = 'ERR_INVALID_ARG_VALUE'; throw e; } m = parseInt(m, 8); } return integer(m, 'mode', 0, 4294967295); };\n"
+    "  const flagsOf = (f) => {\n"
+    "    if (f === undefined) f = 'r';\n"
+    "    if (typeof f === 'number') return integer(f, 'flags', -2147483648, 2147483647);\n"
+    "    if (typeof f !== 'string') failType('flags', 'of type string or number', f);\n"
+    "    const c = constants, sync = c.O_SYNC || 0;\n"
+    "    const flags = { r: c.O_RDONLY, rs: c.O_RDONLY | sync, sr: c.O_RDONLY | sync, 'r+': c.O_RDWR, 'rs+': c.O_RDWR | sync, 'sr+': c.O_RDWR | sync,\n"
+    "      w: c.O_WRONLY | c.O_CREAT | c.O_TRUNC, wx: c.O_WRONLY | c.O_CREAT | c.O_TRUNC | c.O_EXCL, xw: c.O_WRONLY | c.O_CREAT | c.O_TRUNC | c.O_EXCL,\n"
+    "      'w+': c.O_RDWR | c.O_CREAT | c.O_TRUNC, 'wx+': c.O_RDWR | c.O_CREAT | c.O_TRUNC | c.O_EXCL, 'xw+': c.O_RDWR | c.O_CREAT | c.O_TRUNC | c.O_EXCL,\n"
+    "      a: c.O_WRONLY | c.O_CREAT | c.O_APPEND, ax: c.O_WRONLY | c.O_CREAT | c.O_APPEND | c.O_EXCL, xa: c.O_WRONLY | c.O_CREAT | c.O_APPEND | c.O_EXCL,\n"
+    "      as: c.O_WRONLY | c.O_CREAT | c.O_APPEND | sync, sa: c.O_WRONLY | c.O_CREAT | c.O_APPEND | sync,\n"
+    "      'a+': c.O_RDWR | c.O_CREAT | c.O_APPEND, 'ax+': c.O_RDWR | c.O_CREAT | c.O_APPEND | c.O_EXCL, 'xa+': c.O_RDWR | c.O_CREAT | c.O_APPEND | c.O_EXCL,\n"
+    "      'as+': c.O_RDWR | c.O_CREAT | c.O_APPEND | sync, 'sa+': c.O_RDWR | c.O_CREAT | c.O_APPEND | sync };\n"
+    "    if (Object.prototype.hasOwnProperty.call(flags, f)) return flags[f];\n"
+    "    const e = new TypeError(\"The argument 'flags' is invalid. Received '\" + f + \"'\"); e.code = 'ERR_INVALID_ARG_VALUE'; throw e;\n"
+    "  };\n"
+    "  const openArgs = (p, flags, mode) => {\n"
+    "    const path = pathOf(p);\n"
+    "    if (path.includes('\\0')) { const e = new TypeError(\"The argument 'path' must be a string, Uint8Array, or URL without null bytes. Received \" + JSON.stringify(path)); e.code = 'ERR_INVALID_ARG_VALUE'; throw e; }\n"
+    "    return [path, flagsOf(flags), modeOf(mode)];\n"
+    "  };\n"
+    "  const openSync = (p, flags, mode) => call('open', ...openArgs(p, flags, mode));\n"
+    "  const closeSync = (fd) => call('close', fdOf(fd));\n"
+    "  const fsyncSync = (fd) => call('fsync', fdOf(fd));\n"
+    "  const fdatasyncSync = (fd) => call('fdatasync', fdOf(fd));\n"
+    "  const ftruncateSync = (fd, len = 0) => { fdOf(fd); integer(len, 'len'); return call('ftruncate', fd, Math.max(0, len)); };\n"
+    "  const fchmodSync = (fd, mode) => { fdOf(fd); if (mode === undefined) failType('mode', 'of type number', mode); return call('fchmod', fd, modeOf(mode)); };\n"
+    "  const fstatSync = (fd, options) => {\n"
+    "    fdOf(fd);\n"
+    "    if (options && options.bigint) { const e = new Error('fs.fstat with bigint Stats is not supported in the scriptc island'); e.code = 'SC2020'; throw e; }\n"
+    "    return new Stats(call('fstat', fd));\n"
+    "  };\n"
+    "  const readWindow = (buffer, offset, length, position, nullOffset, coerceLength = true) => {\n"
+    "    const bytes = viewOf(buffer);\n"
+    "    offset = offset === undefined || (nullOffset && offset === null) ? 0 : integer(offset, 'offset', 0);\n"
+    "    if (coerceLength) length |= 0;\n"
+    "    if (length === 0) return [bytes, offset, 0, -1];\n"
+    "    if (bytes.length === 0) { const e = new TypeError(\"The argument 'buffer' is empty and cannot be written. Received \" + (Buffer.isBuffer(buffer) ? '<Buffer >' : String(buffer))); e.code = 'ERR_INVALID_ARG_VALUE'; throw e; }\n"
+    "    if (offset > bytes.length) failRange('offset', '>= 0 && <= 9007199254740991', offset);\n"
+    "    if (length < 0 || offset + length > bytes.length) failRange('length', '<= ' + (bytes.length - offset), length);\n"
+    "    if (position == null) position = -1;\n"
+    "    else if (typeof position === 'bigint') {\n"
+    "      if (position < -1n || position > 9007199254740991n) { const e = new Error('fs.read positions outside the safe integer range are not supported in the scriptc island'); e.code = 'SC2020'; throw e; }\n"
+    "      position = Number(position);\n"
+    "    } else integer(position, 'position', -1);\n"
+    "    return [bytes, offset, length, position];\n"
+    "  };\n"
+    "  const readSync = function(fd, buffer, offset, length, position) {\n"
+    "    viewOf(buffer);\n"
+    "    if (arguments.length <= 3 || typeof offset === 'object') {\n"
+    "      ({ offset = 0, length = buffer.byteLength - offset, position = null } = optionsOf(offset));\n"
+    "    }\n"
+    "    const a = readWindow(buffer, offset, length, position, false);\n"
+    "    if (a[2] === 0) return 0;\n"
+    "    return call('read', fdOf(fd), ...a);\n"
+    "  };\n"
+    "  const writeWindow = (buffer, offset, length, position) => {\n"
+    "    const bytes = viewOf(buffer);\n"
+    "    offset = offset == null || typeof offset === 'function' ? 0 : integer(offset, 'offset', 0);\n"
+    "    if (typeof length !== 'number') length = bytes.length - offset;\n"
+    "    if (offset > bytes.length) failRange('offset', '<= ' + bytes.length, offset);\n"
+    "    if (length < 0) failRange('length', '>= 0', length);\n"
+    "    if (length > bytes.length - offset) failRange('length', '<= ' + (bytes.length - offset), length);\n"
+    "    integer(length, 'length', 0);\n"
+    "    position = typeof position === 'number' ? position : -1;\n"
+    "    return [bytes, offset, length, position];\n"
+    "  };\n"
+    "  const stringBytes = (buffer, encoding) => {\n"
+    "    if (typeof buffer !== 'string') failType('buffer', 'of type string or an instance of Buffer, TypedArray, or DataView', buffer);\n"
+    "    if (encoding && !Buffer.isEncoding(encoding)) { const e = new TypeError('Unknown encoding: ' + encoding); e.code = 'ERR_UNKNOWN_ENCODING'; throw e; }\n"
+    "    return Buffer.from(buffer, encoding || 'utf8');\n"
+    "  };\n"
+    "  const writeSync = (fd, buffer, offset, length, position) => {\n"
+    "    let a;\n"
+    "    if (ArrayBuffer.isView(buffer)) {\n"
+    "      if (typeof offset === 'object') { const o = optionsOf(offset); offset = o.offset; length = o.length; position = o.position; }\n"
+    "      a = writeWindow(buffer, offset, length, position);\n"
+    "    } else { const bytes = stringBytes(buffer, length); a = [bytes, 0, bytes.length, typeof offset === 'number' ? offset : -1]; }\n"
+    "    return call('write', fdOf(fd), ...a);\n"
+    "  };\n"
+    "  const vectorArgs = (buffers, position) => {\n"
+    "    if (!Array.isArray(buffers)) failType('buffers', 'an instance of Array', buffers);\n"
+    "    const views = buffers.map((b) => viewOf(b));\n"
+    "    position = typeof position === 'number' && Number.isFinite(position) && position >= 0 ? Math.trunc(position) : -1;\n"
+    "    return [views, position];\n"
+    "  };\n"
+    "  const vectorIO = (writing, fd, buffers, views, position) => {\n"
+    "    if (writing && buffers.length === 0) return 0;\n"
+    "    fdOf(fd);\n"
+    "    const length = views.reduce((n, b) => n + b.length, 0);\n"
+    "    const bytes = writing ? Buffer.concat(views) : Buffer.alloc(length);\n"
+    "    const n = call(writing ? 'writev' : 'readv', fd, bytes, 0, length, position, buffers.length === 0);\n"
+    "    if (!writing) { let at = 0; for (const b of views) { const size = Math.min(b.length, n - at); if (size > 0) b.set(bytes.subarray(at, at + size)); at += b.length; } }\n"
+    "    return n;\n"
+    "  };\n"
+    "  const readvSync = (fd, buffers, position) => { const [views, pos] = vectorArgs(buffers, position); return vectorIO(false, fd, buffers, views, pos); };\n"
+    "  const writevSync = (fd, buffers, position) => { const [views, pos] = vectorArgs(buffers, position); return vectorIO(true, fd, buffers, views, pos); };\n"
+    "  const callbackIO = (cb, action, payload) => {\n"
+    "    let result, error = null;\n"
+    "    try { result = action(); } catch (e) { error = e; }\n"
+    "    env.nextTick(() => payload === undefined ? cb(error, result) : cb(error, result || 0, payload));\n"
+    "  };\n"
+    "  const open = function(p, flags, mode, cb) {\n"
+    "    if (arguments.length < 3) { cb = flags; flags = 'r'; mode = 0o666; }\n"
+    "    else if (typeof mode === 'function') { cb = mode; mode = 0o666; }\n"
+    "    const a = openArgs(p, flags, mode); cbOf(cb); callbackIO(cb, () => call('open', ...a));\n"
+    "  };\n"
+    "  const read = function(fd, buffer, offset, length, position, cb) {\n"
+    "    fdOf(fd);\n"
+    "    if (arguments.length <= 4) {\n"
+    "      let o;\n"
+    "      if (arguments.length === 4) { o = optionsOf(offset); cb = length; }\n"
+    "      else if (arguments.length === 3) { cb = offset; if (!ArrayBuffer.isView(buffer)) { o = optionsOf(buffer); ({ buffer = Buffer.alloc(16384) } = o); } }\n"
+    "      else { cb = buffer; buffer = Buffer.alloc(16384); }\n"
+    "      ({ offset = 0, length = buffer.byteLength - offset, position = null } = o || {});\n"
+    "    }\n"
+    "    viewOf(buffer); cbOf(cb);\n"
+    "    const a = readWindow(buffer, offset, length, position, true);\n"
+    "    callbackIO(cb, () => a[2] === 0 ? 0 : call('read', fd, ...a), buffer);\n"
+    "  };\n"
+    "  const write = function(fd, buffer, offset, length, position, cb) {\n"
+    "    fdOf(fd); let a;\n"
+    "    if (ArrayBuffer.isView(buffer)) {\n"
+    "      cb = cb || position || length || offset; cbOf(cb);\n"
+    "      if (typeof offset === 'object') { const o = optionsOf(offset); offset = o.offset; length = o.length; position = o.position; }\n"
+    "      a = writeWindow(buffer, offset, length, position);\n"
+    "    } else {\n"
+    "      if (typeof position !== 'function') { if (typeof offset === 'function') { position = offset; offset = null; } else position = length; length = 'utf8'; }\n"
+    "      const bytes = stringBytes(buffer, length); cb = position; cbOf(cb); a = [bytes, 0, bytes.length, typeof offset === 'number' ? offset : -1];\n"
+    "    }\n"
+    "    callbackIO(cb, () => call('write', fd, ...a), buffer);\n"
+    "  };\n"
+    "  const vectorCallback = (writing) => (fd, buffers, position, cb) => {\n"
+    "    fdOf(fd); const [views, pos] = vectorArgs(buffers, position); cb = cb || position; cbOf(cb);\n"
+    "    callbackIO(cb, () => vectorIO(writing, fd, buffers, views, pos), buffers);\n"
+    "  };\n"
+    "  const controlCallback = (op, normalize) => (...args) => {\n"
+    "    const cb = args.pop(); fdOf(args[0]); normalize(args); cbOf(cb);\n"
+    "    callbackIO(cb, () => call(op, ...args));\n"
+    "  };\n"
+    "  const handleState = new WeakMap();\n"
+    "  class FileHandle extends env.EventEmitter {\n"
+    "    constructor(fd) { super(); handleState.set(this, { fd }); }\n"
+    "    get fd() { return handleState.get(this).fd; }\n"
+    "    close = () => {\n"
+    "      const state = handleState.get(this);\n"
+    "      if (state.fd === -1) return Promise.resolve();\n"
+    "      const fd = state.fd; state.fd = -1;\n"
+    "      const result = Promise.resolve().then(() => closeSync(fd));\n"
+    "      this.emit('close'); return result;\n"
+    "    };\n"
+    "    async [Symbol.asyncDispose || Symbol.for('nodejs.asyncDispose')]() { await this.close(); }\n"
+    "    async _call(op, action) {\n"
+    "      if (this.fd === -1) { const e = new Error('file closed'); e.code = 'EBADF'; e.syscall = op; throw e; }\n"
+    "      return action(this.fd);\n"
+    "    }\n"
+    "    read(buffer, offset, length, position) {\n"
+    "      return this._call('read', (fd) => {\n"
+    "        if (!ArrayBuffer.isView(buffer)) { ({ buffer = Buffer.alloc(16384), offset = 0, length = buffer.byteLength - offset, position = null } = optionsOf(buffer)); }\n"
+    "        if (offset !== null && typeof offset === 'object') { ({ offset = 0, length = buffer.byteLength - offset, position = null } = optionsOf(offset)); }\n"
+    "        if (offset == null) offset = 0;\n"
+    "        if (length == null) length = buffer.byteLength - offset;\n"
+    "        const a = readWindow(buffer, offset, length, position, true, false);\n"
+    "        return { __proto__: null, bytesRead: a[2] === 0 ? 0 : call('read', fd, ...a), buffer };\n"
+    "      });\n"
+    "    }\n"
+    "    write(buffer, offset, length, position) {\n"
+    "      return this._call('write', (fd) => {\n"
+    "        const bytesWritten = buffer && buffer.byteLength === 0 ? 0 : writeSync(fd, buffer, offset, length, position);\n"
+    "        return { __proto__: null, bytesWritten, buffer };\n"
+    "      });\n"
+    "    }\n"
+    "    readv(buffers, position) { return this._call('readv', (fd) => ({ __proto__: null, bytesRead: readvSync(fd, buffers, position), buffers })); }\n"
+    "    writev(buffers, position) { return this._call('writev', (fd) => ({ __proto__: null, bytesWritten: writevSync(fd, buffers, position), buffers })); }\n"
+    "    readFile(options) { return this._call('readFile', (fd) => readFileSync(fd, options)); }\n"
+    "    writeFile(data, options) { return this._call('writeFile', (fd) => writeFileSync(fd, data, options)); }\n"
+    "    appendFile(data, options) { return this._call('writeFile', (fd) => writeFileSync(fd, data, options)); }\n"
+    "    stat(options) { return this._call('fstat', (fd) => fstatSync(fd, options)); }\n"
+    "    sync() { return this._call('fsync', fsyncSync); }\n"
+    "    datasync() { return this._call('fdatasync', fdatasyncSync); }\n"
+    "    truncate(len = 0) { return this._call('ftruncate', (fd) => ftruncateSync(fd, len)); }\n"
+    "    chmod(mode) { return this._call('fchmod', (fd) => fchmodSync(fd, mode)); }\n"
+    "  }\n"
     "  const sync = {\n"
     "    readFileSync, writeFileSync, appendFileSync, existsSync, realpathSync,\n"
     "    mkdirSync, rmSync, rmdirSync, unlinkSync, readdirSync, statSync,\n"
     "    lstatSync, accessSync, mkdtempSync, chmodSync, copyFileSync, renameSync,\n"
-    "    readlinkSync,\n"
+    "    readlinkSync, openSync, closeSync, readSync, writeSync, readvSync, writevSync, fstatSync, fchmodSync, ftruncateSync, fsyncSync, fdatasyncSync,\n"
     "  };\n"
     "  const callbackify = (syncFn) => (...args) => {\n"
     "    const cb = args.pop();\n"
@@ -4188,22 +4780,13 @@ static const char isl_modules_bootstrap[] =
     "    watchFile: () => {\n"
     "      throw new Error(\"fs.watchFile is not available in the scriptc island\");\n"
     "    },\n"
-    "    openSync: () => {\n"
-    "      throw new Error(\"fs.openSync is not available in the scriptc island (whole-file reads/writes only)\");\n"
-    "    },\n"
-    "    closeSync: () => undefined,\n"
-    "    readSync: () => {\n"
-    "      throw new Error(\"fs.readSync is not available in the scriptc island (whole-file reads/writes only)\");\n"
-    "    },\n"
-    "    writeSync: () => {\n"
-    "      throw new Error(\"fs.writeSync is not available in the scriptc island (whole-file reads/writes only)\");\n"
-    "    },\n"
-    "    read: () => {\n"
-    "      throw new Error(\"fs.read is not available in the scriptc island (whole-file reads/writes only)\");\n"
-    "    },\n"
-    "    open: () => {\n"
-    "      throw new Error(\"fs.open is not available in the scriptc island (whole-file reads/writes only)\");\n"
-    "    },\n"
+    "    open, read, write, readv: vectorCallback(false), writev: vectorCallback(true),\n"
+    "    close: controlCallback('close', () => {}),\n"
+    "    fsync: controlCallback('fsync', () => {}),\n"
+    "    fdatasync: controlCallback('fdatasync', () => {}),\n"
+    "    ftruncate: controlCallback('ftruncate', (a) => { a[1] = a[1] === undefined ? 0 : integer(a[1], 'len'); }),\n"
+    "    fchmod: controlCallback('fchmod', (a) => { if (a[1] === undefined) failType('mode', 'of type number', a[1]); a[1] = modeOf(a[1]); }),\n"
+    "    fstat: (fd, options, cb) => { fdOf(fd); if (typeof options === 'function') { cb = options; options = undefined; } cbOf(cb); callbackIO(cb, () => fstatSync(fd, options)); },\n"
     "    unwatchFile: () => undefined,\n"
     "  };\n"
     "  fs.promises = {\n"
@@ -4225,13 +4808,11 @@ static const char isl_modules_bootstrap[] =
     "    rename: promisify(renameSync),\n"
     "    readlink: promisify(readlinkSync),\n"
     "    constants,\n"
-    "    open: () => {\n"
-    "      return Promise.reject(new Error(\"fs.promises.open is not available in the scriptc island (whole-file reads/writes only)\"));\n"
-    "    },\n"
+    "    open: async (p, flags, mode) => new FileHandle(openSync(p, flags, mode)),\n"
     "  };\n"
     "  return fs;\n"
     "}\n"
-    "    const fs = makeFs({ fs: (...a) => host.fs(...a), fsConstants: () => host.fsConstants(), Buffer: builtins.buffer().Buffer, Readable: builtins.stream().Readable, Writable: builtins.stream().Writable, nextTick: (fn) => queueMicrotask(fn) });\n"
+    "    const fs = makeFs({ fs: (...a) => host.fs(...a), fsConstants: () => host.fsConstants(), Buffer: builtins.buffer().Buffer, Readable: builtins.stream().Readable, Writable: builtins.stream().Writable, EventEmitter: builtins.events().EventEmitter, URL: builtins.url().URL, fileURLToPath: builtins.url().fileURLToPath, nextTick: (fn) => queueMicrotask(fn) });\n"
     "    fs.default = fs;\n"
     "    return fs;\n"
     "  });\n"
@@ -4485,7 +5066,7 @@ static const char isl_modules_bootstrap[] =
     "  const K_STRING_MAX_LENGTH = 536870888;\n"
     "  const INSPECT_MAX_BYTES = 50;\n"
     "  const utf8Enc = new TextEncoder();\n"
-    "  const utf8Dec = new TextDecoder();\n"
+    "  const utf8Dec = new TextDecoder(\"utf-8\", { ignoreBOM: true });\n"
     "  const B64 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n"
     "  const B64U = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\n"
     "  const b64Val = (() => {\n"
@@ -4523,7 +5104,7 @@ static const char isl_modules_bootstrap[] =
     "    return e;\n"
     "  };\n"
     "  const invalidArg = (name, expected, actual) => {\n"
-    "    const t = actual === null ? \"null\" : typeof actual === \"object\" ? \"an instance of \" + (actual.constructor && actual.constructor.name || \"Object\") : typeof actual === \"string\" ? \"type string ('\" + actual + \"')\" : \"type \" + typeof actual + \" (\" + String(actual) + \")\";\n"
+    "    const t = actual == null ? String(actual) : typeof actual === \"object\" ? \"an instance of \" + (actual.constructor && actual.constructor.name || \"Object\") : typeof actual === \"string\" ? \"type string ('\" + actual + \"')\" : \"type \" + typeof actual + \" (\" + String(actual) + (typeof actual === 'bigint' ? 'n' : '') + \")\";\n"
     "    const label = name === \"first argument\" ? \"The first argument\" : 'The \"' + name + '\" argument';\n"
     "    const e = new TypeError(label + \" must be \" + expected + \". Received \" + t);\n"
     "    e.code = \"ERR_INVALID_ARG_TYPE\";\n"
@@ -5185,15 +5766,20 @@ static const char isl_modules_bootstrap[] =
     "    return -1;\n"
     "  };\n"
     "  function SlowBuffer(size) { return Buffer.alloc(size); }\n"
+    "  const validationBytes = (input) => {\n"
+    "    if (ArrayBuffer.isView(input) && !(input instanceof DataView)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);\n"
+    "    if (input instanceof ArrayBuffer || (typeof SharedArrayBuffer === 'function' && input instanceof SharedArrayBuffer)) return new Uint8Array(input);\n"
+    "    throw invalidArg('input', 'an instance of ArrayBuffer, Buffer, or TypedArray', input);\n"
+    "  };\n"
     "  const isAscii = (input) => {\n"
-    "    const u8 = input instanceof Uint8Array ? input : new Uint8Array(input);\n"
+    "    const u8 = validationBytes(input);\n"
     "    for (let i = 0; i < u8.length; i++) {\n"
     "      if (u8[i] > 0x7f) return false;\n"
     "    }\n"
     "    return true;\n"
     "  };\n"
     "  const isUtf8 = (input) => {\n"
-    "    const u8 = input instanceof Uint8Array ? input : new Uint8Array(input);\n"
+    "    const u8 = validationBytes(input);\n"
     "    let i = 0;\n"
     "    while (i < u8.length) {\n"
     "      const b = u8[i];\n"
@@ -5231,8 +5817,9 @@ static const char isl_modules_bootstrap[] =
      * (scr_web.c) owns the implementations. */
     "    Blob: globalThis.Blob,\n"
     "    File: globalThis.File,\n"
-    "    transcode: () => {\n"
-    "      throw new Error(\"buffer.transcode is not available in the scriptc island\");\n"
+    "    transcode: (source, from, to) => {\n"
+    "      if (!(source instanceof Uint8Array)) throw invalidArg('source', 'an instance of Buffer or Uint8Array', source);\n"
+    "      return Buffer.from(host.transcode(source, from, to));\n"
     "    },\n"
     "    resolveObjectURL: () => undefined,\n"
     "  };\n"
@@ -5241,97 +5828,89 @@ static const char isl_modules_bootstrap[] =
     "    mod.default = mod;\n"
     "    return mod;\n"
     "  });\n"
-    /* node:string_decoder — StringDecoder over the Buffer shim: utf8
-     * rides the prelude TextDecoder's streaming state machine,
-     * utf16le holds byte parity, base64 carries mod-3 remainders. */
+    /* node:string_decoder — preserve Node's byte buffering independently
+     * of WHATWG TextDecoder: BOMs, invalid prefixes, UTF-16 pairs, and
+     * base64 groups retain their chunk-boundary behavior. */
     "  builtins.string_decoder = memo(() => {\n"
     "function makeStringDecoder(Buffer) {\n"
     "  const normEnc = (enc) => {\n"
-    "    if (enc === undefined || enc === null) return \"utf8\";\n"
-    "    const e = String(enc).toLowerCase();\n"
-    "    if (e === \"utf8\" || e === \"utf-8\") return \"utf8\";\n"
-    "    if (e === \"hex\") return \"hex\";\n"
-    "    if (e === \"base64\") return \"base64\";\n"
-    "    if (e === \"base64url\") return \"base64url\";\n"
-    "    if (e === \"latin1\" || e === \"binary\") return \"latin1\";\n"
-    "    if (e === \"ascii\") return \"ascii\";\n"
-    "    if (e === \"utf16le\" || e === \"utf-16le\" || e === \"ucs2\" || e === \"ucs-2\") return \"utf16le\";\n"
-    "    const err = new TypeError(\"Unknown encoding: \" + enc);\n"
-    "    err.code = \"ERR_UNKNOWN_ENCODING\";\n"
+    "    if (enc === undefined || enc === null || enc === '') return 'utf8';\n"
+    "    const e = typeof enc === 'string' ? enc.toLowerCase() : enc;\n"
+    "    if (e === 'utf8' || e === 'utf-8') return 'utf8';\n"
+    "    if (e === 'hex' || e === 'base64' || e === 'base64url' || e === 'ascii') return e;\n"
+    "    if (e === 'latin1' || e === 'binary') return 'latin1';\n"
+    "    if (e === 'utf16le' || e === 'utf-16le' || e === 'ucs2' || e === 'ucs-2') return 'utf16le';\n"
+    "    const err = new TypeError('Unknown encoding: ' + String(enc));\n"
+    "    err.code = 'ERR_UNKNOWN_ENCODING';\n"
     "    throw err;\n"
     "  };\n"
     "  class StringDecoder {\n"
     "    constructor(encoding) {\n"
     "      this.encoding = normEnc(encoding);\n"
-    "      if (this.encoding === \"utf8\") {\n"
-    "        this._dec = new TextDecoder();\n"
-    "      } else if (this.encoding === \"utf16le\") {\n"
-    "        this._oddByte = -1;\n"
-    "      } else if (this.encoding === \"base64\" || this.encoding === \"base64url\") {\n"
-    "        this._rem = null;\n"
-    "      }\n"
+    "      this._encoding = this.encoding;\n"
+    "      this._pending = new Uint8Array(0);\n"
+    "      this._missing = 0;\n"
     "    }\n"
     "    write(buf) {\n"
-    "      if (typeof buf === \"string\") return buf;\n"
-    "      const u8 = buf instanceof Uint8Array ? buf : new Uint8Array(buf);\n"
-    "      switch (this.encoding) {\n"
-    "        case \"utf8\":\n"
-    "          return this._dec.decode(u8, { stream: true });\n"
-    "        case \"utf16le\": {\n"
-    "          let bytes = u8;\n"
-    "          if (this._oddByte >= 0) {\n"
-    "            const joined = new Uint8Array(u8.length + 1);\n"
-    "            joined[0] = this._oddByte;\n"
-    "            joined.set(u8, 1);\n"
-    "            bytes = joined;\n"
-    "            this._oddByte = -1;\n"
-    "          }\n"
-    "          if (bytes.length % 2 !== 0) {\n"
-    "            this._oddByte = bytes[bytes.length - 1];\n"
-    "            bytes = bytes.subarray(0, bytes.length - 1);\n"
+    "      if (typeof buf === 'string') return buf;\n"
+    "      if (!ArrayBuffer.isView(buf)) {\n"
+    "        const received = buf === null ? 'null' : buf === undefined ? 'undefined' : typeof buf === 'object' ? 'an instance of ' + (buf.constructor && buf.constructor.name || 'Object') : 'type ' + typeof buf + ' (' + String(buf) + ')';\n"
+    "        const err = new TypeError('The \"buf\" argument must be an instance of Buffer, TypedArray, or DataView. Received ' + received);\n"
+    "        err.code = 'ERR_INVALID_ARG_TYPE';\n"
+    "        throw err;\n"
+    "      }\n"
+    "      const bytes = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);\n"
+    "      const enc = this._encoding;\n"
+    "      let offset = 0;\n"
+    "      let out = '';\n"
+    "      if (this._missing > 0) {\n"
+    "        let take = Math.min(bytes.length, this._missing);\n"
+    "        if (enc === 'utf8') {\n"
+    "          for (let i = 0; i < take; i++) {\n"
+    "            if ((bytes[i] & 0xc0) !== 0x80) { take = i; this._missing = i; break; }\n"
     "          }\n"
-    "          return Buffer.from(bytes).toString(\"utf16le\");\n"
     "        }\n"
-    "        case \"base64\":\n"
-    "        case \"base64url\": {\n"
-    "          let bytes = u8;\n"
-    "          if (this._rem !== null) {\n"
-    "            const joined = new Uint8Array(this._rem.length + u8.length);\n"
-    "            joined.set(this._rem, 0);\n"
-    "            joined.set(u8, this._rem.length);\n"
-    "            bytes = joined;\n"
-    "            this._rem = null;\n"
-    "          }\n"
-    "          const usable = bytes.length - (bytes.length % 3);\n"
-    "          if (usable < bytes.length) {\n"
-    "            this._rem = bytes.slice(usable);\n"
-    "            bytes = bytes.subarray(0, usable);\n"
-    "          }\n"
-    "          return Buffer.from(bytes).toString(this.encoding);\n"
+    "        const pending = new Uint8Array(this._pending.length + take);\n"
+    "        pending.set(this._pending);\n"
+    "        pending.set(bytes.subarray(0, take), this._pending.length);\n"
+    "        this._pending = pending;\n"
+    "        this._missing -= take;\n"
+    "        offset = take;\n"
+    "        if (this._missing === 0) {\n"
+    "          out = Buffer.from(pending).toString(enc);\n"
+    "          this._pending = new Uint8Array(0);\n"
     "        }\n"
-    "        default:\n"
-    "          return Buffer.from(u8).toString(this.encoding);\n"
-    "      }\n"
+    "        if (offset === bytes.length) return out;\n"
+    "      }\n"
+    "      const n = bytes.length - offset;\n"
+    "      let held = 0;\n"
+    "      let total = 0;\n"
+    "      if (enc === 'utf8') {\n"
+    "        for (let back = 1; back <= Math.min(n, 3); back++) {\n"
+    "          const b = bytes[bytes.length - back];\n"
+    "          if ((b & 0xc0) === 0x80) continue;\n"
+    "          total = (b & 0xe0) === 0xc0 ? 2 : (b & 0xf0) === 0xe0 ? 3 : (b & 0xf8) === 0xf0 ? 4 : 0;\n"
+    "          if (back < total) held = back;\n"
+    "          break;\n"
+    "        }\n"
+    "      } else if (enc === 'utf16le') {\n"
+    "        if (n % 2) { held = 1; total = 2; }\n"
+    "        else if (n >= 2 && (bytes[bytes.length - 1] & 0xfc) === 0xd8) { held = 2; total = 4; }\n"
+    "      } else if (enc === 'base64' || enc === 'base64url') {\n"
+    "        held = n % 3;\n"
+    "        total = 3;\n"
+    "      }\n"
+    "      const end = bytes.length - held;\n"
+    "      this._pending = bytes.slice(end);\n"
+    "      this._missing = held ? total - held : 0;\n"
+    "      return out + Buffer.from(bytes.subarray(offset, end)).toString(enc);\n"
     "    }\n"
     "    end(buf) {\n"
-    "      let out = buf !== undefined ? this.write(buf) : \"\";\n"
-    "      switch (this.encoding) {\n"
-    "        case \"utf8\":\n"
-    "          out += this._dec.decode();\n"
-    "          this._dec = new TextDecoder();\n"
-    "          break;\n"
-    "        case \"utf16le\":\n"
-    "          this._oddByte = -1;\n"
-    "          break;\n"
-    "        case \"base64\":\n"
-    "        case \"base64url\":\n"
-    "          if (this._rem !== null) {\n"
-    "            out += Buffer.from(this._rem).toString(this.encoding);\n"
-    "            this._rem = null;\n"
-    "          }\n"
-    "          break;\n"
-    "      }\n"
-    "      return out;\n"
+    "      const out = buf === undefined ? '' : this.write(buf);\n"
+    "      const tail = Buffer.from(this._pending).toString(this._encoding);\n"
+    "      this._pending = new Uint8Array(0);\n"
+    "      this._missing = 0;\n"
+    "      return out + tail;\n"
     "    }\n"
     "  }\n"
     "  return { StringDecoder };\n"
@@ -5341,7 +5920,7 @@ static const char isl_modules_bootstrap[] =
     "    return mod;\n"
     "  });\n"
     /* node:crypto — the hashing/random slice over host bridges
-     * (md5/sha1/sha256 digest + HMAC through the same C
+     * (MD5/SHA-1/SHA-2 digest + HMAC through the same C
      * implementations the static lowerings use; randomness through
      * the web prelude's CSPRNG), pbkdf2 over the HMAC bridge, and
      * honest throwing stubs for the key/cipher machinery the island
@@ -5559,12 +6138,119 @@ static const char isl_modules_bootstrap[] =
     "    }\n"
     "    queueMicrotask(() => callback(null, derived));\n"
     "  };\n"
+    "  const kdfError = (kind, code, message) => {\n"
+    "    const error = new kind(message);\n"
+    "    error.code = code;\n"
+    "    return error;\n"
+    "  };\n"
+    "  const kdfNumber = (value) => Number.isInteger(value) && Math.abs(value) > 4294967296 ? String(value).replace(/\\B(?=(\\d{3})+(?!\\d))/g, \"_\") : String(value);\n"
+    "  const kdfInteger = (value, name, max) => {\n"
+    "    if (typeof value !== \"number\") {\n"
+    "      const received = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value === \"object\" ? \"an instance of \" + ((value.constructor && value.constructor.name) || \"Object\") : \"type \" + typeof value + \" (\" + (typeof value === \"string\" ? \"'\" + value + \"'\" : String(value)) + \")\";\n"
+    "      throw kdfError(TypeError, \"ERR_INVALID_ARG_TYPE\", 'The \"' + name + '\" argument must be of type number. Received ' + received);\n"
+    "    }\n"
+    "    if (!Number.isInteger(value) || value < 0 || value > max) {\n"
+    "      const range = Number.isInteger(value) ? \">= 0 && <= \" + max : \"an integer\";\n"
+    "      throw kdfError(RangeError, \"ERR_OUT_OF_RANGE\", 'The value of \"' + name + '\" is out of range. It must be ' + range + '. Received ' + kdfNumber(value));\n"
+    "    }\n"
+    "    return value;\n"
+    "  };\n"
+    "  const kdfInput = (value, name, hkdfKey = false, hkdfSource = false) => {\n"
+    "    if (typeof value === \"string\") return Buffer.from(value);\n"
+    "    if (value instanceof ArrayBuffer) return new Uint8Array(value);\n"
+    "    if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n"
+    "    const received = value === null ? \"null\" : value === undefined ? \"undefined\" : typeof value === \"object\" ? \"an instance of \" + ((value.constructor && value.constructor.name) || \"Object\") : \"type \" + typeof value + \" (\" + (typeof value === \"string\" ? \"'\" + value + \"'\" : String(value)) + \")\";\n"
+    "    const expected = hkdfKey ? \"string or an instance of SecretKeyObject, ArrayBuffer, TypedArray, DataView, or Buffer\" : hkdfSource ? \"string or an instance of ArrayBuffer, TypedArray, DataView, or Buffer\" : \"string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView\";\n"
+    "    throw kdfError(TypeError, \"ERR_INVALID_ARG_TYPE\", 'The \"' + name + '\" argument must be of type ' + expected + '. Received ' + received);\n"
+    "  };\n"
+    "  const kdfCallback = (callback) => {\n"
+    "    if (typeof callback !== \"function\") {\n"
+    "      const received = callback === undefined ? \"undefined\" : callback === null ? \"null\" : typeof callback === \"object\" ? \"an instance of \" + ((callback.constructor && callback.constructor.name) || \"Object\") : \"type \" + typeof callback + \" (\" + String(callback) + \")\";\n"
+    "      throw kdfError(TypeError, \"ERR_INVALID_ARG_TYPE\", 'The \"callback\" argument must be of type function. Received ' + received);\n"
+    "    }\n"
+    "  };\n"
+    "  const hkdfParameters = (digest, ikm, salt, info, keylen) => {\n"
+    "    if (typeof digest !== \"string\") {\n"
+    "      const received = digest === undefined ? \"undefined\" : digest === null ? \"null\" : \"type \" + typeof digest + \" (\" + String(digest) + \")\";\n"
+    "      throw kdfError(TypeError, \"ERR_INVALID_ARG_TYPE\", 'The \"digest\" argument must be of type string. Received ' + received);\n"
+    "    }\n"
+    "    ikm = kdfInput(ikm, \"ikm\", true);\n"
+    "    salt = kdfInput(salt, \"salt\", false, true);\n"
+    "    info = kdfInput(info, \"info\", false, true);\n"
+    "    kdfInteger(keylen, \"length\", Number.MAX_SAFE_INTEGER);\n"
+    "    if (info.length > 1024) throw kdfError(RangeError, \"ERR_OUT_OF_RANGE\", 'The value of \"info\" is out of range. It must be must not contain more than 1024 bytes. Received ' + info.length);\n"
+    "    return [digest, ikm, salt, info, keylen];\n"
+    "  };\n"
+    "  const hkdfDerive = (digest, ikm, salt, info, keylen) => {\n"
+    "    const prk = env.hmac(digest.toLowerCase(), salt, ikm);\n"
+    "    if (prk === undefined) throw kdfError(TypeError, \"ERR_CRYPTO_INVALID_DIGEST\", \"Invalid digest: \" + digest);\n"
+    "    if (keylen > 255 * prk.length) {\n"
+    "      prk.fill(0);\n"
+    "      throw kdfError(RangeError, \"ERR_CRYPTO_INVALID_KEYLEN\", \"Invalid key length\");\n"
+    "    }\n"
+    "    const result = new Uint8Array(keylen);\n"
+    "    let previous = new Uint8Array(0), offset = 0;\n"
+    "    for (let counter = 1; offset < keylen; counter++) {\n"
+    "      const block = new Uint8Array(previous.length + info.length + 1);\n"
+    "      block.set(previous);\n"
+    "      block.set(info, previous.length);\n"
+    "      block[block.length - 1] = counter;\n"
+    "      const next = env.hmac(digest.toLowerCase(), prk, block);\n"
+    "      previous.fill(0);\n"
+    "      block.fill(0);\n"
+    "      previous = next;\n"
+    "      const take = Math.min(next.length, keylen - offset);\n"
+    "      result.set(next.subarray(0, take), offset);\n"
+    "      offset += take;\n"
+    "    }\n"
+    "    prk.fill(0);\n"
+    "    previous.fill(0);\n"
+    "    return result.buffer;\n"
+    "  };\n"
+    "  const hkdfSync = (digest, ikm, salt, info, keylen) => {\n"
+    "    const result = hkdfDerive(...hkdfParameters(digest, ikm, salt, info, keylen));\n"
+    "    if (result.byteLength === 0) throw new Error(\"Deriving bits failed\");\n"
+    "    return result;\n"
+    "  };\n"
+    "  const hkdf = (digest, ikm, salt, info, keylen, callback) => {\n"
+    "    const params = hkdfParameters(digest, ikm, salt, info, keylen);\n"
+    "    kdfCallback(callback);\n"
+    "    const result = hkdfDerive(...params);\n"
+    "    setImmediate(() => result.byteLength === 0 ? callback(new Error(\"Deriving bits failed\")) : callback(null, result));\n"
+    "  };\n"
+    "  const scryptParameters = (password, salt, keylen, options) => {\n"
+    "    password = kdfInput(password, \"password\");\n"
+    "    salt = kdfInput(salt, \"salt\");\n"
+    "    kdfInteger(keylen, \"keylen\", 2147483647);\n"
+    "    const values = [16384, 8, 1, 33554432];\n"
+    "    if (options) {\n"
+    "      const names = [\"N\", \"r\", \"p\"], aliases = [\"cost\", \"blockSize\", \"parallelization\"];\n"
+    "      for (let i = 0; i < 3; i++) {\n"
+    "        const name = names[i], alias = aliases[i], present = options[name] !== undefined;\n"
+    "        if (present) values[i] = kdfInteger(options[name], name, 4294967295);\n"
+    "        if (options[alias] !== undefined) {\n"
+    "          if (present) throw kdfError(TypeError, \"ERR_INCOMPATIBLE_OPTION_PAIR\", 'Option \"' + name + '\" cannot be used in combination with option \"' + alias + '\"');\n"
+    "          values[i] = kdfInteger(options[alias], alias, 4294967295);\n"
+    "        }\n"
+    "      }\n"
+    "      if (options.maxmem !== undefined) values[3] = kdfInteger(options.maxmem, \"maxmem\", Number.MAX_SAFE_INTEGER);\n"
+    "    }\n"
+    "    return [password, salt, keylen, ...values];\n"
+    "  };\n"
+    "  const scryptSync = (password, salt, keylen, options) => Buffer.from(env.scrypt(...scryptParameters(password, salt, keylen, options)));\n"
+    "  const scrypt = (password, salt, keylen, options, callback) => {\n"
+    "    if (callback === undefined) { callback = options; options = undefined; }\n"
+    "    const params = scryptParameters(password, salt, keylen, options);\n"
+    "    kdfCallback(callback);\n"
+    "    const result = Buffer.from(env.scrypt(...params));\n"
+    "    setImmediate(() => callback(null, result));\n"
+    "  };\n"
     "  const die = (name) => function unsupported() {\n"
-    "    throw new Error(\"crypto.\" + name + \" is not available in the scriptc island (the embedded runtime carries the hashing/random slice only)\");\n"
+    "    throw new Error(\"crypto.\" + name + \" is not available in the scriptc island (the embedded runtime carries the hashing/random/KDF slice only)\");\n"
     "  };\n"
     "  class KeyObject {\n"
     "    constructor() {\n"
-    "      throw new Error(\"crypto.KeyObject is not available in the scriptc island (the embedded runtime carries the hashing/random slice only)\");\n"
+    "      throw new Error(\"crypto.KeyObject is not available in the scriptc island (the embedded runtime carries the hashing/random/KDF slice only)\");\n"
     "    }\n"
     "  }\n"
     "  const constants = {\n"
@@ -5582,8 +6268,8 @@ static const char isl_modules_bootstrap[] =
     "    createHash, createHmac, hash, Hash, Hmac,\n"
     "    randomBytes, randomFillSync, randomFill, randomInt, randomUUID,\n"
     "    getRandomValues: (ta) => webcrypto.getRandomValues(ta),\n"
-    "    timingSafeEqual, pbkdf2, pbkdf2Sync,\n"
-    "    getHashes: () => [\"md5\", \"sha1\", \"sha256\"],\n"
+    "    timingSafeEqual, pbkdf2, pbkdf2Sync, hkdf, hkdfSync, scrypt, scryptSync,\n"
+    "    getHashes: () => [\"md5\", \"sha1\", \"sha224\", \"sha256\", \"sha384\", \"sha512\"],\n"
     "    getCiphers: () => [],\n"
     "    getCurves: () => [],\n"
     "    webcrypto,\n"
@@ -5609,10 +6295,6 @@ static const char isl_modules_bootstrap[] =
     "    publicDecrypt: die(\"publicDecrypt\"),\n"
     "    privateEncrypt: die(\"privateEncrypt\"),\n"
     "    privateDecrypt: die(\"privateDecrypt\"),\n"
-    "    scrypt: die(\"scrypt\"),\n"
-    "    scryptSync: die(\"scryptSync\"),\n"
-    "    hkdf: die(\"hkdf\"),\n"
-    "    hkdfSync: die(\"hkdfSync\"),\n"
     "    X509Certificate: die(\"X509Certificate\"),\n"
     "    Certificate: die(\"Certificate\"),\n"
     "    checkPrime: die(\"checkPrime\"),\n"
@@ -5627,7 +6309,7 @@ static const char isl_modules_bootstrap[] =
     "  crypto.subtle = webcrypto ? webcrypto.subtle : undefined;\n"
     "  return crypto;\n"
     "}\n"
-    "    const mod = makeCrypto({ digest: (a, d) => host.digest(a, d), hmac: (a, k, d) => host.hmac(a, k, d), Buffer: builtins.buffer().Buffer });\n"
+    "    const mod = makeCrypto({ digest: (a, d) => host.digest(a, d), hmac: (a, k, d) => host.hmac(a, k, d), scrypt: (...args) => host.scrypt(...args), Buffer: builtins.buffer().Buffer });\n"
     "    mod.default = mod;\n"
     "    return mod;\n"
     "  });\n"
@@ -6917,6 +7599,17 @@ static const char isl_modules_bootstrap[] =
      * isDeepStrictEqual, stripVTControlCharacters, styleText,
      * parseArgs, toUSVString). The host supplies what JS cannot see:
      * promise state (JS_PromiseState), the pid, and fd writes. */
+    "  const envArgumentError = (name, expected, value) => {\n"
+    "    const type = typeof value;\n"
+    "    let received;\n"
+    "    if (value === null || value === undefined) received = String(value);\n"
+    "    else if (type === 'function') received = 'function ' + value.name;\n"
+    "    else if (type === 'object' && value.constructor && value.constructor.name) received = 'an instance of ' + value.constructor.name;\n"
+    "    else received = type === 'object' ? builtins.util().inspect(value, { depth: -1 }) : 'type ' + type + ' (' + builtins.util().inspect(value) + ')';\n"
+    "    const error = new TypeError('The \"' + name + '\" ' + (name.includes('.') ? 'property' : 'argument') + ' must be ' + expected + '. Received ' + received);\n"
+    "    error.code = 'ERR_INVALID_ARG_TYPE';\n"
+    "    throw error;\n"
+    "  };\n"
     "  builtins.util = memo(() => {\n"
     "function makeUtil(env) {\n"
     "  const inspectCustom = Symbol.for(\"nodejs.util.inspect.custom\");\n"
@@ -7312,7 +8005,7 @@ static const char isl_modules_bootstrap[] =
     "        braces = [\"{\", \"}\"];\n"
     "        formatter = () => [];\n"
     "      } else {\n"
-    "        if (depth > ctx.depth && ctx.depth !== null) {\n"
+    "        if (keys.length > 0 && depth > ctx.depth && ctx.depth !== null) {\n"
     "          return \"[\" + (ctorName === null ? \"Object: null prototype\" : ctorName) + \"]\";\n"
     "        }\n"
     "        if (protoOf === null) {\n"
@@ -7502,21 +8195,33 @@ static const char isl_modules_bootstrap[] =
     "    Object.defineProperty(ctor, \"super_\", { value: superCtor, writable: true, configurable: true });\n"
     "    Object.setPrototypeOf(ctor.prototype, superCtor.prototype);\n"
     "  };\n"
+    "  const received = (v) => {\n"
+    "    if (v === null || v === undefined) return String(v);\n"
+    "    if (typeof v === 'object') return v.constructor && 'name' in v.constructor ? 'an instance of ' + v.constructor.name : inspect(v, { depth: -1 });\n"
+    "    if (typeof v === 'function') return 'function ' + v.name;\n"
+    "    if (typeof v === 'string') {\n"
+    "      if (v.length > 28) v = v.slice(0, 25) + '...';\n"
+    "      return 'type string (' + (v.includes(\"'\") ? JSON.stringify(v) : \"'\" + v + \"'\") + ')';\n"
+    "    }\n"
+    "    if (typeof v === 'number') return 'type number (' + (Object.is(v, -0) ? '-0' : String(v)) + ')';\n"
+    "    if (typeof v === 'bigint') return 'type bigint (' + v + 'n)';\n"
+    "    if (typeof v === 'symbol') return 'type symbol (' + String(v) + ')';\n"
+    "    return 'type ' + typeof v + ' (' + String(v) + ')';\n"
+    "  };\n"
+    "  const validateAdapterFunction = (value, name) => {\n"
+    "    if (typeof value !== 'function') {\n"
+    "      const e = new TypeError('The ' + (name === 'last argument' ? name : '\"' + name + '\" ' + (name.includes('.') ? 'property' : 'argument')) + ' must be of type function. Received ' + received(value));\n"
+    "      e.code = 'ERR_INVALID_ARG_TYPE';\n"
+    "      throw e;\n"
+    "    }\n"
+    "  };\n"
     "  const kCustomPromisified = Symbol.for(\"nodejs.util.promisify.custom\");\n"
     "  const kCustomPromisifyArgs = Symbol(\"customPromisifyArgs\");\n"
     "  const promisify = (original) => {\n"
-    "    if (typeof original !== \"function\") {\n"
-    "      const e = new TypeError('The \"original\" argument must be of type function. Received ' + (original === null ? \"null\" : typeof original === \"object\" ? \"an instance of Object\" : typeof original === \"undefined\" ? \"undefined\" : \"type \" + typeof original + \" (\" + JSON.stringify(original) + \")\"));\n"
-    "      e.code = \"ERR_INVALID_ARG_TYPE\";\n"
-    "      throw e;\n"
-    "    }\n"
+    "    validateAdapterFunction(original, 'original');\n"
     "    if (original[kCustomPromisified]) {\n"
     "      const fn = original[kCustomPromisified];\n"
-    "      if (typeof fn !== \"function\") {\n"
-    "        const e = new TypeError('The \"util.promisify.custom\" property must be of type function');\n"
-    "        e.code = \"ERR_INVALID_ARG_TYPE\";\n"
-    "        throw e;\n"
-    "      }\n"
+    "      validateAdapterFunction(fn, 'util.promisify.custom');\n"
     "      return Object.defineProperty(fn, kCustomPromisified, { value: fn, enumerable: false, writable: false, configurable: true });\n"
     "    }\n"
     "    const argumentNames = original[kCustomPromisifyArgs];\n"
@@ -7538,30 +8243,21 @@ static const char isl_modules_bootstrap[] =
     "    Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n"
     "    Object.defineProperty(fn, kCustomPromisified, { value: fn, enumerable: false, writable: false, configurable: true });\n"
     "    const descriptors = Object.getOwnPropertyDescriptors(original);\n"
-    "    delete descriptors.name;\n"
-    "    delete descriptors.length;\n"
+    "    for (const descriptor of Object.values(descriptors)) Object.setPrototypeOf(descriptor, null);\n"
     "    return Object.defineProperties(fn, descriptors);\n"
     "  };\n"
     "  promisify.custom = kCustomPromisified;\n"
     "  const callbackify = (original) => {\n"
-    "    if (typeof original !== \"function\") {\n"
-    "      const e = new TypeError('The \"original\" argument must be of type function');\n"
-    "      e.code = \"ERR_INVALID_ARG_TYPE\";\n"
-    "      throw e;\n"
-    "    }\n"
+    "    validateAdapterFunction(original, 'original');\n"
     "    function callbackified(...args) {\n"
     "      const maybeCb = args.pop();\n"
-    "      if (typeof maybeCb !== \"function\") {\n"
-    "        const e = new TypeError(\"The last argument must be of type function\");\n"
-    "        e.code = \"ERR_INVALID_ARG_TYPE\";\n"
-    "        throw e;\n"
-    "      }\n"
+    "      validateAdapterFunction(maybeCb, 'last argument');\n"
     "      const cb = (...cbArgs) => Reflect.apply(maybeCb, this, cbArgs);\n"
     "      Reflect.apply(original, this, args).then(\n"
     "        (ret) => queueMicrotask(() => cb(null, ret)),\n"
     "        (rej) => queueMicrotask(() => {\n"
-    "          if (rej === null || (typeof rej !== \"object\" && typeof rej !== \"function\")) {\n"
-    "            const wrapped = new Error(\"Promise was rejected with a falsy value\");\n"
+    "          if (!rej) {\n"
+    "            const wrapped = new Error(\"Promise was rejected with falsy value\");\n"
     "            wrapped.code = \"ERR_FALSY_VALUE_REJECTION\";\n"
     "            wrapped.reason = rej;\n"
     "            return cb(wrapped);\n"
@@ -7570,8 +8266,10 @@ static const char isl_modules_bootstrap[] =
     "        }),\n"
     "      );\n"
     "    }\n"
-    "    Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n"
     "    const descriptors = Object.getOwnPropertyDescriptors(original);\n"
+    "    if (typeof descriptors.length.value === 'number') descriptors.length.value++;\n"
+    "    if (typeof descriptors.name.value === 'string') descriptors.name.value += 'Callbackified';\n"
+    "    for (const descriptor of Object.values(descriptors)) Object.setPrototypeOf(descriptor, null);\n"
     "    Object.defineProperties(callbackified, descriptors);\n"
     "    return callbackified;\n"
     "  };\n"
@@ -7842,147 +8540,138 @@ static const char isl_modules_bootstrap[] =
     "    }\n"
     "    return colorize ? left + text + right : text;\n"
     "  };\n"
-    "  const parseArgs = (config) => {\n"
-    "    config = config === undefined ? {} : config;\n"
-    "    const args = config.args !== undefined ? config.args : env.argv.slice(2);\n"
-    "    const strict = config.strict !== undefined ? !!config.strict : true;\n"
-    "    const allowPositionals = config.allowPositionals !== undefined ? !!config.allowPositionals : !strict;\n"
-    "    const allowNegative = !!config.allowNegative;\n"
-    "    const returnTokens = !!config.tokens;\n"
-    "    const options = config.options !== undefined ? config.options : {};\n"
-    "    const result = { values: { __proto__: null }, positionals: [] };\n"
-    "    const tokens = [];\n"
-    "    const shortOf = (ch) => {\n"
-    "      for (const name of Object.keys(options)) {\n"
-    "        if (options[name].short === ch) return name;\n"
-    "      }\n"
-    "      return undefined;\n"
-    "    };\n"
-    "    const unknownError = (raw) => {\n"
-    "      const e = new TypeError(\"Unknown option '\" + raw + \"'. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- \\\"\" + raw + \"\\\"\");\n"
-    "      e.code = \"ERR_PARSE_ARGS_UNKNOWN_OPTION\";\n"
-    "      throw e;\n"
+    "  const parseArgs = (config = {}) => {\n"
+    "    if (config === null) throw new TypeError(\"Cannot convert undefined or null to object\");\n"
+    "    const own = (o, k) => Object.prototype.hasOwnProperty.call(o, k);\n"
+    "    const get = (o, k) => own(o, k) ? o[k] : undefined;\n"
+    "    const args = get(config, 'args') ?? env.argv.slice(2);\n"
+    "    const strict = get(config, 'strict') ?? true;\n"
+    "    const allowPositionals = get(config, 'allowPositionals') ?? !strict;\n"
+    "    const returnTokens = get(config, 'tokens') ?? false;\n"
+    "    const allowNegative = get(config, 'allowNegative') ?? false;\n"
+    "    const options = get(config, 'options') ?? Object.create(null);\n"
+    "    const fail = (code, message) => { const e = new TypeError(message); e.code = code; throw e; };\n"
+    "    const validate = (v, name, expected, ok) => {\n"
+    "      if (!ok) fail('ERR_INVALID_ARG_TYPE', 'The \"' + name + '\" ' + (name.startsWith('options.') ? 'property' : 'argument') + ' must be ' + expected + '. Received ' + received(v));\n"
     "    };\n"
-    "    const store = (name, value, raw) => {\n"
-    "      const cfg = options[name] || {};\n"
-    "      const type = cfg.type;\n"
-    "      if (strict) {\n"
-    "        if (options[name] === undefined) unknownError(raw);\n"
-    "        if (type === \"string\" && value === undefined) {\n"
-    "          const e = new TypeError(\"Option '\" + raw + (cfg.short && raw.startsWith(\"--\") === false ? \"\" : \"\") + \" <value>' argument missing\");\n"
-    "          e.code = \"ERR_PARSE_ARGS_INVALID_OPTION_VALUE\";\n"
-    "          throw e;\n"
-    "        }\n"
-    "        if (type === \"boolean\" && value !== undefined) {\n"
-    "          const e = new TypeError(\"Option '\" + raw + \"' does not take an argument\");\n"
-    "          e.code = \"ERR_PARSE_ARGS_INVALID_OPTION_VALUE\";\n"
-    "          throw e;\n"
-    "        }\n"
-    "      }\n"
-    "      const finalValue = value === undefined ? true : value;\n"
-    "      tokens.push({ kind: \"option\", name, rawName: raw, index: tokenIndex, value: value === undefined ? undefined : value, inlineValue: inline });\n"
-    "      if (cfg.multiple) {\n"
-    "        if (result.values[name] === undefined) result.values[name] = [];\n"
-    "        result.values[name].push(finalValue);\n"
-    "      } else {\n"
-    "        result.values[name] = finalValue;\n"
+    "    const object = (v, name) => validate(v, name, 'of type object', v !== null && typeof v === 'object' && !Array.isArray(v));\n"
+    "    const boolean = (v, name) => validate(v, name, 'of type boolean', typeof v === 'boolean');\n"
+    "    const string = (v, name) => validate(v, name, 'of type string', typeof v === 'string');\n"
+    "    validate(args, 'args', 'an instance of Array', Array.isArray(args));\n"
+    "    boolean(strict, 'strict');\n"
+    "    boolean(allowPositionals, 'allowPositionals');\n"
+    "    boolean(returnTokens, 'tokens');\n"
+    "    boolean(allowNegative, 'allowNegative');\n"
+    "    object(options, 'options');\n"
+    "    for (const [name, option] of Object.entries(options)) {\n"
+    "      const path = 'options.' + name;\n"
+    "      object(option, path);\n"
+    "      const type = get(option, 'type');\n"
+    "      validate(type, path + '.type', \"('string|boolean')\", type === 'string' || type === 'boolean');\n"
+    "      if (own(option, 'short')) {\n"
+    "        const short = option.short;\n"
+    "        string(short, path + '.short');\n"
+    "        if (short.length !== 1) fail('ERR_INVALID_ARG_VALUE', \"The property '\" + path + \".short' must be a single character. Received \" + inspect(short));\n"
+    "      }\n"
+    "      const multiple = get(option, 'multiple');\n"
+    "      if (own(option, 'multiple')) boolean(multiple, path + '.multiple');\n"
+    "      const value = get(option, 'default');\n"
+    "      if (value !== undefined) {\n"
+    "        const check = type === 'string' ? string : boolean;\n"
+    "        if (multiple) {\n"
+    "          validate(value, path + '.default', 'an instance of Array', Array.isArray(value));\n"
+    "          for (let i = 0; i < value.length; i++) check(value[i], path + '.default[' + i + ']');\n"
+    "        } else check(value, path + '.default');\n"
     "      }\n"
+    "    }\n"
+    "    const optionGet = (name, key) => own(options, name) ? get(options[name], key) : undefined;\n"
+    "    const shortName = (ch) => {\n"
+    "      const entry = Object.entries(options).find(([, option]) => get(option, 'short') === ch);\n"
+    "      return entry ? entry[0] : ch;\n"
     "    };\n"
-    "    let tokenIndex = -1;\n"
-    "    let inline;\n"
-    "    let afterDashDash = false;\n"
-    "    for (let i = 0; i < args.length; i++) {\n"
-    "      const arg = args[i];\n"
-    "      tokenIndex = i;\n"
-    "      inline = undefined;\n"
-    "      if (afterDashDash) {\n"
-    "        tokens.push({ kind: \"positional\", index: i, value: arg });\n"
-    "        result.positionals.push(arg);\n"
-    "        continue;\n"
-    "      }\n"
-    "      if (arg === \"--\") {\n"
-    "        afterDashDash = true;\n"
-    "        tokens.push({ kind: \"option-terminator\", index: i });\n"
-    "        continue;\n"
+    "    const tokens = [];\n"
+    "    // Tokenize the full argument snapshot before checking usage, as Node does.\n"
+    "    const remaining = Array.prototype.slice.call(args);\n"
+    "    let index = -1;\n"
+    "    let groupCount = 0;\n"
+    "    while (remaining.length) {\n"
+    "      const arg = remaining.shift();\n"
+    "      if (groupCount > 0) groupCount--; else index++;\n"
+    "      if (arg === '--') {\n"
+    "        tokens.push({ kind: 'option-terminator', index });\n"
+    "        for (const value of remaining) tokens.push({ kind: 'positional', index: ++index, value });\n"
+    "        break;\n"
     "      }\n"
-    "      if (arg.startsWith(\"--\")) {\n"
-    "        const eq = arg.indexOf(\"=\");\n"
-    "        if (eq !== -1) {\n"
-    "          const name = arg.slice(2, eq);\n"
-    "          inline = true;\n"
-    "          store(name, arg.slice(eq + 1), \"--\" + name);\n"
+    "      // Reading length first deliberately preserves Node's nullish-argument error.\n"
+    "      if (arg == null) throw new TypeError(\"Cannot read properties of \" + arg + \" (reading 'length')\");\n"
+    "      const length = arg.length;\n"
+    "      if (length === 2 && String.prototype.charAt.call(arg, 0) === '-' && String.prototype.charAt.call(arg, 1) !== '-') {\n"
+    "        const name = shortName(String.prototype.charAt.call(arg, 1));\n"
+    "        let value, inlineValue;\n"
+    "        if (optionGet(name, 'type') === 'string' && remaining[0] != null) { value = remaining.shift(); inlineValue = false; }\n"
+    "        tokens.push({ kind: 'option', name, rawName: arg, index, value, inlineValue });\n"
+    "        if (value != null) index++;\n"
+    "      } else if (length > 2 && String.prototype.charAt.call(arg, 0) === '-' && String.prototype.charAt.call(arg, 1) !== '-') {\n"
+    "        const firstName = shortName(String.prototype.charAt.call(arg, 1));\n"
+    "        if (optionGet(firstName, 'type') === 'string') {\n"
+    "          tokens.push({ kind: 'option', name: firstName, rawName: '-' + String.prototype.charAt.call(arg, 1), index, value: String.prototype.slice.call(arg, 2), inlineValue: true });\n"
     "        } else {\n"
-    "          const name = arg.slice(2);\n"
-    "          const cfg = options[name];\n"
-    "          if (cfg !== undefined && cfg.type === \"string\" && i + 1 < args.length) {\n"
-    "            inline = false;\n"
-    "            store(name, args[++i], arg);\n"
-    "          } else if (allowNegative && name.startsWith(\"no-\") && (options[name.slice(3)] || {}).type === \"boolean\") {\n"
-    "            const positive = name.slice(3);\n"
-    "            tokens.push({ kind: \"option\", name: positive, rawName: arg, index: i, value: undefined, inlineValue: undefined });\n"
-    "            result.values[positive] = false;\n"
-    "          } else {\n"
-    "            if (strict && cfg === undefined) unknownError(arg);\n"
-    "            if (strict && cfg.type === \"string\") {\n"
-    "              const e = new TypeError(\"Option '--\" + name + \" <value>' argument missing\");\n"
-    "              e.code = \"ERR_PARSE_ARGS_INVALID_OPTION_VALUE\";\n"
-    "              throw e;\n"
-    "            }\n"
-    "            store(name, undefined, arg);\n"
+    "          const expanded = [];\n"
+    "          for (let i = 1; i < length; i++) {\n"
+    "            const ch = String.prototype.charAt.call(arg, i);\n"
+    "            const name = shortName(ch);\n"
+    "            if (optionGet(name, 'type') === 'string' && i !== length - 1) { expanded.push('-' + String.prototype.slice.call(arg, i)); break; }\n"
+    "            expanded.push('-' + ch);\n"
     "          }\n"
+    "          remaining.unshift(...expanded);\n"
+    "          groupCount = expanded.length;\n"
     "        }\n"
-    "        continue;\n"
-    "      }\n"
-    "      if (arg.length > 1 && arg[0] === \"-\") {\n"
-    "        const chars = arg.slice(1);\n"
-    "        let consumed = false;\n"
-    "        for (let c = 0; c < chars.length; c++) {\n"
-    "          const ch = chars[c];\n"
-    "          const name = shortOf(ch);\n"
-    "          const raw = \"-\" + ch;\n"
-    "          const cfg = name !== undefined ? options[name] : undefined;\n"
-    "          if (cfg !== undefined && cfg.type === \"string\") {\n"
-    "            if (c < chars.length - 1) {\n"
-    "              inline = true;\n"
-    "              store(name, chars.slice(c + 1), raw);\n"
-    "            } else if (i + 1 < args.length) {\n"
-    "              inline = false;\n"
-    "              store(name, args[++i], raw);\n"
-    "            } else if (strict) {\n"
-    "              const e = new TypeError(\"Option '\" + raw + \", --\" + name + \" <value>' argument missing\");\n"
-    "              e.code = \"ERR_PARSE_ARGS_INVALID_OPTION_VALUE\";\n"
-    "              throw e;\n"
-    "            } else {\n"
-    "              store(name, undefined, raw);\n"
-    "            }\n"
-    "            consumed = true;\n"
-    "            break;\n"
+    "      } else if (length > 2 && String.prototype.startsWith.call(arg, '--')) {\n"
+    "        const eq = String.prototype.indexOf.call(arg, '=', 3);\n"
+    "        const name = String.prototype.slice.call(arg, 2, eq < 0 ? undefined : eq);\n"
+    "        let value, inlineValue;\n"
+    "        if (eq >= 0) { value = String.prototype.slice.call(arg, eq + 1); inlineValue = true; }\n"
+    "        else if (optionGet(name, 'type') === 'string' && remaining[0] != null) { value = remaining.shift(); inlineValue = false; }\n"
+    "        tokens.push({ kind: 'option', name, rawName: '--' + name, index, value, inlineValue });\n"
+    "        if (eq < 0 && value != null) index++;\n"
+    "      } else tokens.push({ kind: 'positional', index, value: arg });\n"
+    "    }\n"
+    "    const result = { values: Object.create(null), positionals: [] };\n"
+    "    if (returnTokens) result.tokens = tokens;\n"
+    "    for (const token of tokens) {\n"
+    "      if (token.kind === 'positional') {\n"
+    "        if (!allowPositionals) fail('ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL', \"Unexpected argument '\" + token.value + \"'. This command does not take positional arguments\");\n"
+    "        result.positionals.push(token.value);\n"
+    "      } else if (token.kind === 'option') {\n"
+    "        let name = token.name;\n"
+    "        if (strict) {\n"
+    "          if (!own(options, name)) {\n"
+    "            if (allowNegative && name.startsWith('no-') && own(options, name.slice(3)) && optionGet(name.slice(3), 'type') === 'boolean') name = name.slice(3);\n"
+    "            else fail('ERR_PARSE_ARGS_UNKNOWN_OPTION', \"Unknown option '\" + token.rawName + \"'\" + (allowPositionals ? \". To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- \\\"\" + token.rawName + \"\\\"\" : ''));\n"
     "          }\n"
-    "          if (name === undefined) {\n"
-    "            if (strict) unknownError(raw);\n"
-    "            store(ch, undefined, raw);\n"
-    "          } else {\n"
-    "            store(name, undefined, raw);\n"
+    "          const short = optionGet(name, 'short');\n"
+    "          const label = (short ? '-' + short + ', ' : '') + '--' + name;\n"
+    "          if (optionGet(name, 'type') === 'string' && typeof token.value !== 'string') fail('ERR_PARSE_ARGS_INVALID_OPTION_VALUE', \"Option '\" + label + \" <value>' argument missing\");\n"
+    "          if (optionGet(name, 'type') === 'boolean' && token.value != null) fail('ERR_PARSE_ARGS_INVALID_OPTION_VALUE', \"Option '\" + label + \"' does not take an argument\");\n"
+    "          if (!token.inlineValue && token.value != null && token.value.length > 1 && String.prototype.charAt.call(token.value, 0) === '-') {\n"
+    "            const example = token.rawName.startsWith('--') ? \"'\" + token.rawName + \"=-XYZ'\" : \"'--\" + token.name + \"=-XYZ' or '\" + token.rawName + \"-XYZ'\";\n"
+    "            fail('ERR_PARSE_ARGS_INVALID_OPTION_VALUE', \"Option '\" + token.rawName + \"' argument is ambiguous.\\nDid you forget to specify the option argument for '\" + token.rawName + \"'?\\nTo specify an option argument starting with a dash use \" + example + '.');\n"
     "          }\n"
     "        }\n"
-    "        void consumed;\n"
-    "        continue;\n"
-    "      }\n"
-    "      if (strict && !allowPositionals) {\n"
-    "        const e = new TypeError(\"Unexpected argument '\" + arg + \"'. This command does not take positional arguments\");\n"
-    "        e.code = \"ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL\";\n"
-    "        throw e;\n"
+    "        name = token.name;\n"
+    "        let value = token.value;\n"
+    "        if (name === '__proto__') continue;\n"
+    "        if (allowNegative && name.startsWith('no-') && value === undefined) { name = name.slice(3); token.name = name; value = false; }\n"
+    "        value = value ?? true;\n"
+    "        if (optionGet(name, 'multiple')) {\n"
+    "          if (!result.values[name]) result.values[name] = [];\n"
+    "          result.values[name].push(value);\n"
+    "        } else result.values[name] = value;\n"
     "      }\n"
-    "      tokens.push({ kind: \"positional\", index: i, value: arg });\n"
-    "      result.positionals.push(arg);\n"
     "    }\n"
-    "    for (const name of Object.keys(options)) {\n"
-    "      const cfg = options[name];\n"
-    "      if (cfg.default !== undefined && !(name in result.values)) {\n"
-    "        result.values[name] = cfg.default;\n"
-    "      }\n"
+    "    for (const [name, option] of Object.entries(options)) {\n"
+    "      if (name !== '__proto__' && get(option, 'default') !== undefined && result.values[name] === undefined) result.values[name] = get(option, 'default');\n"
     "    }\n"
-    "    if (returnTokens) result.tokens = tokens;\n"
     "    return result;\n"
     "  };\n"
     "  const toUSVString = (s) => String(s).replace(/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/g, \"�\");\n"
@@ -7995,6 +8684,10 @@ static const char isl_modules_bootstrap[] =
     "    format, formatWithOptions, inspect, inherits, promisify, callbackify,\n"
     "    deprecate, debuglog, debug: debuglog, types, isDeepStrictEqual,\n"
     "    stripVTControlCharacters, styleText, parseArgs, toUSVString, _extend,\n"
+    "    parseEnv: (content) => {\n"
+    "      if (typeof content !== 'string') envArgumentError('content', 'of type string', content);\n"
+    "      return host.parseEnv(toUSVString(content));\n"
+    "    },\n"
     "    TextEncoder: globalThis.TextEncoder, TextDecoder: globalThis.TextDecoder,\n"
     "    isArray: (v) => Array.isArray(v),\n"
     "  };\n"
@@ -8766,9 +9459,8 @@ static const char isl_modules_bootstrap[] =
     "    c.default = c;\n"
     "    return c;\n"
     "  });\n"
-    /* node:timers (+ timers/promises) over the island's timer
-     * bridge; setImmediate rides a zero-delay timer (Node's check
-     * phase does not exist here — documented divergence). */
+    /* node:timers and timers/promises share the native timer heap and
+     * immediate queue through the web prelude's handle objects. */
     "  builtins.timers = memo(() => {\n"
     "    const t = {\n"
     "      setTimeout: globalThis.setTimeout,\n"
@@ -8782,30 +9474,94 @@ static const char isl_modules_bootstrap[] =
     "    return t;\n"
     "  });\n"
     "  builtins['timers/promises'] = memo(() => {\n"
-    "    const delay = (ms, value, options) => new Promise((resolve, reject) => {\n"
-    "      const t = globalThis.setTimeout(() => resolve(value), ms);\n"
-    "      if (options !== undefined && options !== null && options.signal !== undefined && typeof options.signal.addEventListener === 'function') {\n"
-    "        options.signal.addEventListener('abort', () => {\n"
-    "          globalThis.clearTimeout(t);\n"
-    "          const e = new Error('The operation was aborted');\n"
-    "          e.name = 'AbortError';\n"
-    "          e.code = 'ABORT_ERR';\n"
-    "          reject(e);\n"
-    "        });\n"
+    "    const resistant = Symbol.for('scriptc.events.resistStopPropagation');\n"
+    "    const checkDelay = (delay) => {\n"
+    "      if (delay !== undefined && typeof delay !== 'number') envArgumentError('delay', 'of type number', delay);\n"
+    "    };\n"
+    "    const checkOptions = (options) => {\n"
+    "      if (options === null || typeof options !== 'object' || Array.isArray(options)) envArgumentError('options', 'of type object', options);\n"
+    "      if (options.signal !== undefined) {\n"
+    "        const signal = options.signal;\n"
+    "        if (signal === null || typeof signal !== 'object' || !('aborted' in signal)) envArgumentError('options.signal', 'an instance of AbortSignal', signal);\n"
+    "      }\n"
+    "      if (options.ref !== undefined) {\n"
+    "        const ref = options.ref;\n"
+    "        if (typeof ref !== 'boolean') envArgumentError('options.ref', 'of type boolean', ref);\n"
+    "      }\n"
+    "      const { signal, ref = true } = options;\n"
+    "      return { signal, ref };\n"
+    "    };\n"
+    "    const abortError = (signal) => {\n"
+    "      const error = new Error('The operation was aborted', { cause: signal.reason });\n"
+    "      error.name = 'AbortError'; error.code = 'ABORT_ERR';\n"
+    "      return error;\n"
+    "    };\n"
+    "    const wait = (immediate, delay, value, options) => {\n"
+    "      let signal, ref;\n"
+    "      try {\n"
+    "        if (!immediate) checkDelay(delay);\n"
+    "        ({ signal, ref } = checkOptions(options));\n"
+    "      } catch (error) { return Promise.reject(error); }\n"
+    "      if (signal && signal.aborted) return Promise.reject(abortError(signal));\n"
+    "      let timer, onCancel;\n"
+    "      const promise = new Promise((resolve, reject) => {\n"
+    "        timer = immediate ? globalThis.setImmediate(resolve, value) : globalThis.setTimeout(resolve, delay, value);\n"
+    "        if (!ref) timer.unref();\n"
+    "        if (signal) {\n"
+    "          onCancel = () => {\n"
+    "            if (!timer._destroyed) {\n"
+    "              if (immediate) globalThis.clearImmediate(timer); else globalThis.clearTimeout(timer);\n"
+    "              reject(abortError(signal));\n"
+    "            }\n"
+    "          };\n"
+    "          signal.addEventListener('abort', onCancel, { __proto__: null, [resistant]: true });\n"
+    "        }\n"
+    "      });\n"
+    "      return onCancel ? promise.finally(() => signal.removeEventListener('abort', onCancel)) : promise;\n"
+    "    };\n"
+    "    function setTimeout(delay, value, options = {}) { return wait(false, delay, value, options); }\n"
+    "    function setImmediate(value, options = {}) { return wait(true, undefined, value, options); }\n"
+    "    async function* setInterval(delay, value, options = {}) {\n"
+    "      checkDelay(delay);\n"
+    "      const { signal, ref } = checkOptions(options);\n"
+    "      if (signal && signal.aborted) throw abortError(signal);\n"
+    "      let timer, onCancel;\n"
+    "      try {\n"
+    "        let notYielded = 0, callback;\n"
+    "        timer = globalThis.setInterval(() => {\n"
+    "          notYielded++;\n"
+    "          if (callback) { callback(); callback = undefined; }\n"
+    "        }, delay);\n"
+    "        if (!ref) timer.unref();\n"
+    "        if (signal) {\n"
+    "          onCancel = () => {\n"
+    "            globalThis.clearInterval(timer);\n"
+    "            if (callback) { callback(Promise.reject(abortError(signal))); callback = undefined; }\n"
+    "          };\n"
+    "          signal.addEventListener('abort', onCancel, { __proto__: null, once: true, [resistant]: true });\n"
+    "        }\n"
+    "        while (!(signal && signal.aborted)) {\n"
+    "          if (notYielded === 0) await new Promise(resolve => callback = resolve);\n"
+    "          for (; notYielded > 0; notYielded--) yield value;\n"
+    "        }\n"
+    "        throw abortError(signal);\n"
+    "      } finally {\n"
+    "        globalThis.clearInterval(timer);\n"
+    "        if (signal) signal.removeEventListener('abort', onCancel);\n"
     "      }\n"
-    "    });\n"
+    "    }\n"
+    "    const schedulerBrand = Symbol('kScheduler');\n"
+    "    const checkScheduler = (receiver) => {\n"
+    "      if (!receiver[schedulerBrand]) { const error = new TypeError('Value of \"this\" must be of type Scheduler'); error.code = 'ERR_INVALID_THIS'; throw error; }\n"
+    "    };\n"
+    "    class Scheduler {\n"
+    "      constructor() { const error = new TypeError('Illegal constructor'); error.code = 'ERR_ILLEGAL_CONSTRUCTOR'; throw error; }\n"
+    "      yield() { checkScheduler(this); return setImmediate(); }\n"
+    "      wait(delay, options) { checkScheduler(this); return setTimeout(delay, undefined, options); }\n"
+    "    }\n"
+    "    const scheduler = Object.create(Scheduler.prototype); scheduler[schedulerBrand] = true;\n"
     "    const tp = {\n"
-    "      setTimeout: delay,\n"
-    "      setImmediate: (value) => delay(0, value),\n"
-    "      setInterval: (ms, value, options) => ({\n"
-    "        async *[Symbol.asyncIterator]() {\n"
-    "          for (;;) {\n"
-    "            await delay(ms, undefined, options);\n"
-    "            yield value;\n"
-    "          }\n"
-    "        },\n"
-    "      }),\n"
-    "      scheduler: { wait: (ms) => delay(ms), yield: () => delay(0) },\n"
+    "      setTimeout, setImmediate, setInterval, scheduler,\n"
     "    };\n"
     "    tp.default = tp;\n"
     "    return tp;\n"
@@ -9199,9 +9955,54 @@ static const char isl_modules_bootstrap[] =
     "      s.emit = () => false;\n"
     "      return s;\n"
     "    };\n"
+    "    const envPrototype = Object.create(Object.prototype);\n"
+    "    Object.defineProperty(envPrototype, 'constructor', { value: Object, writable: true, configurable: true });\n"
+    "    const envTarget = Object.create(envPrototype);\n"
+    "    const env = new Proxy(envTarget, {\n"
+    "      get: (target, key, receiver) => {\n"
+    "        if (typeof key === 'symbol') return Reflect.get(target, key, receiver);\n"
+    "        const value = host.envGet(key);\n"
+    "        return value === undefined ? Reflect.get(target, key, receiver) : value;\n"
+    "      },\n"
+    "      set: (_, key, value) => {\n"
+    "        if (typeof key === 'symbol' || typeof value === 'symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n"
+    "        return host.envSet(key, String(value));\n"
+    "      },\n"
+    "      deleteProperty: (_, key) => {\n"
+    "        if (typeof key === 'symbol') return true;\n"
+    "        return host.envDelete(key);\n"
+    "      },\n"
+    "      has: (target, key) => typeof key !== 'symbol' && host.envGet(key) !== undefined || Reflect.has(target, key),\n"
+    "      ownKeys: () => Reflect.ownKeys(host.env()),\n"
+    "      getOwnPropertyDescriptor: (_, key) => {\n"
+    "        if (typeof key === 'symbol') return undefined;\n"
+    "        const value = host.envGet(key);\n"
+    "        return value === undefined ? undefined : { value, writable: true, enumerable: true, configurable: true };\n"
+    "      },\n"
+    "      defineProperty: (_, key, descriptor) => {\n"
+    "        if (!descriptor.configurable || !descriptor.writable || !descriptor.enumerable || !('value' in descriptor) || 'get' in descriptor || 'set' in descriptor) {\n"
+    "          const error = new TypeError(\"'process.env' only accepts a configurable, writable, and enumerable data descriptor\");\n"
+    "          error.code = 'ERR_INVALID_OBJECT_DEFINE_PROPERTY';\n"
+    "          throw error;\n"
+    "        }\n"
+    "        if (typeof key === 'symbol' || typeof descriptor.value === 'symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n"
+    "        return host.envSet(key, String(descriptor.value));\n"
+    "      },\n"
+    "      preventExtensions: () => { throw new TypeError('Cannot prevent extensions'); },\n"
+    "    });\n"
+    "    const loadEnvFile = (path) => {\n"
+    "      if (path instanceof globalThis.URL) path = host.urlToPath(path.href);\n"
+    "      const bytes = path instanceof Uint8Array;\n"
+    "      if (path != null && typeof path !== 'string' && !bytes) envArgumentError('path', 'of type string or an instance of Buffer or URL', path);\n"
+    "      return host.loadEnvFile(path, bytes, bytes && builtins.buffer().Buffer.isBuffer(path));\n"
+    "    };\n"
     "    const p = {\n"
     "      argv,\n"
-    "      env: host.env(),\n"
+    "      env, loadEnvFile,\n"
+    "      chdir: (directory) => {\n"
+    "        if (typeof directory !== 'string') envArgumentError('directory', 'of type string', directory);\n"
+    "        return host.chdir(directory);\n"
+    "      },\n"
     "      platform: host.platform(),\n"
     "      execPath: argv[0],\n"
     "      execArgv: [],\n"
@@ -9312,15 +10113,9 @@ static const char isl_modules_bootstrap[] =
     /* Node's Buffer global (and `global` itself) — embedded CJS
      * reaches both without requiring anything. */
     "  globalThis.Buffer = builtins.buffer().Buffer;\n"
-    /* setImmediate/clearImmediate globals (zero-delay timers — no
-     * check phase in the island; documented divergence), and the
-     * global console upgraded to Node's util.format semantics for
+    /* The global console upgraded to Node's util.format semantics for
      * npm builds (the web prelude's String() console stays for
      * non-npm islands). */
-    "  if (globalThis.setImmediate === undefined) {\n"
-    "    globalThis.setImmediate = (fn, ...args) => globalThis.setTimeout(fn, 0, ...args);\n"
-    "    globalThis.clearImmediate = (t) => globalThis.clearTimeout(t);\n"
-    "  }\n"
     "  {\n"
     "    const fmt = (...a) => builtins.util().formatWithOptions({}, ...a);\n"
     "    const to = (fd, prefix) => (...a) => { host.write(fd, (prefix || '') + fmt(...a) + '\\n'); };\n"
@@ -9385,6 +10180,13 @@ static void isl_modules_boot(void) {
   JS_SetPropertyStr(isl_ctx, host, "resolve", JS_NewCFunction(isl_ctx, isl_host_resolve, "resolve", 2));
   JS_SetPropertyStr(isl_ctx, host, "argv", JS_NewCFunction(isl_ctx, isl_host_argv, "argv", 0));
   JS_SetPropertyStr(isl_ctx, host, "env", JS_NewCFunction(isl_ctx, isl_host_env, "env", 0));
+  JS_SetPropertyStr(isl_ctx, host, "chdir", JS_NewCFunction(isl_ctx, isl_host_chdir, "chdir", 1));
+  JS_SetPropertyStr(isl_ctx, host, "envGet", JS_NewCFunction(isl_ctx, isl_host_env_get, "envGet", 1));
+  JS_SetPropertyStr(isl_ctx, host, "envSet", JS_NewCFunction(isl_ctx, isl_host_env_set, "envSet", 2));
+  JS_SetPropertyStr(isl_ctx, host, "envDelete", JS_NewCFunction(isl_ctx, isl_host_env_delete, "envDelete", 1));
+  JS_SetPropertyStr(isl_ctx, host, "parseEnv", JS_NewCFunction(isl_ctx, isl_host_parse_env, "parseEnv", 1));
+  JS_SetPropertyStr(isl_ctx, host, "transcode", JS_NewCFunction(isl_ctx, isl_host_transcode, "transcode", 3));
+  JS_SetPropertyStr(isl_ctx, host, "loadEnvFile", JS_NewCFunction(isl_ctx, isl_host_load_env_file, "loadEnvFile", 2));
   JS_SetPropertyStr(isl_ctx, host, "write", JS_NewCFunction(isl_ctx, isl_host_write, "write", 2));
   JS_SetPropertyStr(isl_ctx, host, "readStdin",
                     JS_NewCFunction(isl_ctx, isl_host_read_stdin, "readStdin", 0));
@@ -9403,6 +10205,7 @@ static void isl_modules_boot(void) {
   JS_SetPropertyStr(isl_ctx, host, "promiseState", JS_NewCFunction(isl_ctx, isl_host_promise_state, "promiseState", 1));
   JS_SetPropertyStr(isl_ctx, host, "digest", JS_NewCFunction(isl_ctx, isl_host_digest, "digest", 2));
   JS_SetPropertyStr(isl_ctx, host, "hmac", JS_NewCFunction(isl_ctx, isl_host_hmac, "hmac", 3));
+  JS_SetPropertyStr(isl_ctx, host, "scrypt", JS_NewCFunction(isl_ctx, isl_host_scrypt, "scrypt", 7));
   JS_SetPropertyStr(isl_ctx, host, "fs", JS_NewCFunction(isl_ctx, isl_host_fs, "fs", 4));
   JS_SetPropertyStr(isl_ctx, host, "fsConstants", JS_NewCFunction(isl_ctx, isl_host_fs_constants, "fsConstants", 0));
   JS_SetPropertyStr(isl_ctx, host, "path", JS_NewCFunction(isl_ctx, isl_host_path, "path", 4));
@@ -9794,20 +10597,34 @@ static JSValue isl_url_parse_host(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv) {
   (void)this_val;
   if (argc < 1) return JS_ThrowTypeError(ctx, "Invalid URL");
-  size_t len;
-  const char *s = JS_ToCStringLen(ctx, &len, argv[0]);
-  if (!s) return JS_EXCEPTION;
-  ScrStr *in = scr_str_new(s, len);
-  JS_FreeCString(ctx, s);
-  ScrUrl *u = scr_url_new(in);
+  ScrStr *in = isl_arg_str(ctx, argv[0]);
+  if (!in) return JS_EXCEPTION;
+  ScrStr *base = argc > 1 && !JS_IsUndefined(argv[1]) ? isl_arg_str(ctx, argv[1]) : NULL;
+  if (argc > 1 && !JS_IsUndefined(argv[1]) && !base) {
+    scr_str_release(in);
+    return JS_EXCEPTION;
+  }
+  ScrUrl *u = base ? scr_url_new_base(in, base) : scr_url_new(in);
   scr_str_release(in);
-  if (!u) return isl_throw_pending(ctx); /* the parser's catchable TypeError */
+  scr_str_release(base);
+  if (!u) {
+    if (argc > 2 && JS_ToBool(ctx, argv[2])) {
+      scr_exc_clear();
+      return JS_NULL;
+    }
+    return isl_throw_pending(ctx);
+  }
   ScrStr *href = scr_url_href(u);
   ScrStr *protocol = scr_url_protocol(u);
   ScrStr *pathname = scr_url_pathname(u);
   ScrStr *host = scr_url_host(u);
   ScrStr *hostname = scr_url_hostname(u);
   ScrStr *search = scr_url_search(u);
+  ScrStr *origin = scr_url_origin(u);
+  ScrStr *username = scr_url_username(u);
+  ScrStr *password = scr_url_password(u);
+  ScrStr *hash = scr_url_hash(u);
+  ScrStr *port = scr_url_port(u);
   scr_url_release(u);
   JSValue arr = JS_NewArray(ctx);
   JS_SetPropertyUint32(ctx, arr, 0, JS_NewStringLen(ctx, href->data, href->len));
@@ -9816,12 +10633,22 @@ static JSValue isl_url_parse_host(JSContext *ctx, JSValueConst this_val,
   JS_SetPropertyUint32(ctx, arr, 3, JS_NewStringLen(ctx, host->data, host->len));
   JS_SetPropertyUint32(ctx, arr, 4, JS_NewStringLen(ctx, hostname->data, hostname->len));
   JS_SetPropertyUint32(ctx, arr, 5, JS_NewStringLen(ctx, search->data, search->len));
+  JS_SetPropertyUint32(ctx, arr, 6, JS_NewStringLen(ctx, origin->data, origin->len));
+  JS_SetPropertyUint32(ctx, arr, 7, JS_NewStringLen(ctx, username->data, username->len));
+  JS_SetPropertyUint32(ctx, arr, 8, JS_NewStringLen(ctx, password->data, password->len));
+  JS_SetPropertyUint32(ctx, arr, 9, JS_NewStringLen(ctx, hash->data, hash->len));
+  JS_SetPropertyUint32(ctx, arr, 10, JS_NewStringLen(ctx, port->data, port->len));
   scr_str_release(href);
   scr_str_release(protocol);
   scr_str_release(pathname);
   scr_str_release(host);
   scr_str_release(hostname);
   scr_str_release(search);
+  scr_str_release(origin);
+  scr_str_release(username);
+  scr_str_release(password);
+  scr_str_release(hash);
+  scr_str_release(port);
   return arr;
 }
 
@@ -9829,32 +10656,23 @@ static const char isl_url_src[] =
     "(function (parse) {\n"
     "  'use strict';\n"
     "  const def = (o, n, v) => Object.defineProperty(o, n, { value: v, enumerable: true });\n"
+    "  const text = (v) => {\n"
+    "    if (typeof v === 'symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n"
+    "    return `${v}`;\n"
+    "  };\n"
     "  class URL {\n"
-    /* The (input, base) form supports RELATIVE resolution — the Emscripten
-     * loader's `new URL("x.wasm", import.meta.url)` — with RFC 3986
-     * dot-segment removal over the base's path. Inputs that carry their
-     * own scheme ignore the base (per spec); protocol-relative inputs
-     * keep a narrow fence. */
     "    constructor(input, base) {\n"
-    "      let s = String(input);\n"
-    "      const hasScheme = /^[A-Za-z][A-Za-z0-9+.-]*:/;\n"
-    "      if (base !== undefined && !hasScheme.test(s)) {\n"
-    "        const b = String(base !== null && typeof base === 'object' && 'href' in base ? base.href : base);\n"
-    "        const m = hasScheme.test(b) && b.match(/^([A-Za-z][A-Za-z0-9+.-]*:)(\\/\\/[^\\/?#]*)?([^?#]*)/);\n"
-    "        if (!m) throw new TypeError('Invalid base URL');\n"
-    "        if (s.startsWith('//')) {\n"
-    "          throw new TypeError('protocol-relative URLs are not supported in the scriptc island yet');\n"
-    "        }\n"
-    "        let path = s.startsWith('/') ? s : (m[3] || '/').replace(/[^\\/]*$/, '') + s;\n"
-    "        const out = [];\n"
-    "        for (const seg of path.split('/')) {\n"
-    "          if (seg === '.') continue;\n"
-    "          if (seg === '..') { if (out.length > 1) out.pop(); continue; }\n"
-    "          out.push(seg);\n"
-    "        }\n"
-    "        s = m[1] + (m[2] || '') + out.join('/');\n"
-    "      }\n"
-    "      const c = parse(s);\n"
+    "      if (arguments.length === 0) throw URL._missing();\n"
+    "      const s = text(input);\n"
+    "      const b = base === undefined ? undefined : text(base);\n"
+    "      this._init(parse(s, b));\n"
+    "    }\n"
+    "    static _missing() {\n"
+    "      const error = new TypeError('The \"url\" argument must be specified');\n"
+    "      error.code = 'ERR_MISSING_ARGS';\n"
+    "      return error;\n"
+    "    }\n"
+    "    _init(c) {\n"
     /* href and search are LIVE-COUPLED (the one WHATWG mutation loop the
      * a real CLI's API client drives: url.searchParams.set('teamId', …)
      * then fetch(url)): both live in writable slots, the search setter
@@ -9880,18 +10698,11 @@ static const char isl_url_src[] =
     "      def(this, 'pathname', c[2]);\n"
     "      def(this, 'host', c[3]);\n"
     "      def(this, 'hostname', c[4]);\n"
-    "      def(this, 'port', c[3].length > c[4].length ? c[3].slice(c[4].length + 1) : '');\n"
-    "      const hashAt = c[0].indexOf('#');\n"
-    "      def(this, 'hash', hashAt < 0 ? '' : c[0].slice(hashAt));\n"
-    "      const cred = c[3] !== '' && c[0].startsWith(c[1] + '//')\n"
-    "        ? c[0].slice(c[1].length + 2, c[0].indexOf(c[3], c[1].length + 2)) : '';\n"
-    "      const at = cred.lastIndexOf('@');\n"
-    "      const userinfo = at < 0 ? '' : cred.slice(0, at);\n"
-    "      const colon = userinfo.indexOf(':');\n"
-    "      def(this, 'username', colon < 0 ? userinfo : userinfo.slice(0, colon));\n"
-    "      def(this, 'password', colon < 0 ? '' : userinfo.slice(colon + 1));\n"
-    "      def(this, 'origin', (c[1] === 'http:' || c[1] === 'https:' || c[1] === 'ws:' || c[1] === 'wss:' || c[1] === 'ftp:')\n"
-    "        ? c[1] + '//' + c[3] : 'null');\n"
+    "      def(this, 'origin', c[6]);\n"
+    "      def(this, 'username', c[7]);\n"
+    "      def(this, 'password', c[8]);\n"
+    "      def(this, 'hash', c[9]);\n"
+    "      def(this, 'port', c[10]);\n"
     "    }\n"
     /* The search half of the live coupling: normalize the assigned
      * query, splice it into href between the pre-query part and the
@@ -9929,10 +10740,20 @@ static const char isl_url_src[] =
     "    toString() { return this.href; }\n"
     "    toJSON() { return this.href; }\n"
     "    static canParse(input, base) {\n"
-    "      try { new URL(input, base); return true; } catch (e) { return false; }\n"
+    "      if (arguments.length === 0) throw URL._missing();\n"
+    "      const s = text(input);\n"
+    "      const b = base === undefined ? undefined : text(base);\n"
+    "      return parse(s, b, true) !== null;\n"
     "    }\n"
     "    static parse(input, base) {\n"
-    "      try { return new URL(input, base); } catch (e) { return null; }\n"
+    "      if (arguments.length === 0) throw URL._missing();\n"
+    "      const s = text(input);\n"
+    "      const b = base === undefined ? undefined : text(base);\n"
+    "      const c = parse(s, b, true);\n"
+    "      if (c === null) return null;\n"
+    "      const result = Object.create(URL.prototype);\n"
+    "      result._init(c);\n"
+    "      return result;\n"
     "    }\n"
     "  }\n"
     "  globalThis.URL = URL;\n"
@@ -9951,7 +10772,7 @@ static void isl_install_url_class(void) {
       fprintf(stderr, "scriptc: island URL prelude failed to evaluate\n");
       abort(); /* fixed source; failing to parse is a build defect */
     }
-    JSValue parse = JS_NewCFunction(isl_ctx, isl_url_parse_host, "__scr_url_parse", 1);
+    JSValue parse = JS_NewCFunction(isl_ctx, isl_url_parse_host, "__scr_url_parse", 3);
     JSValue r = JS_Call(isl_ctx, installer, JS_UNDEFINED, 1, &parse);
     JS_FreeValue(isl_ctx, parse);
     JS_FreeValue(isl_ctx, installer);