@scriptc/cli-darwin-arm64 0.2.1 → 0.2.3

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

@@ -135,6 +135,11 @@ static const ScrIslandModule *isl_mods = NULL;
 static size_t isl_nmods = 0;
 static const ScrIslandEdge *isl_edges = NULL;
 static size_t isl_nedges = 0;
+static const char *isl_main_module = NULL;
+
+void scr_island_entry_module(const char *filename) {
+  isl_main_module = filename;
+}
 
 /* Compressed embedded module text (src_raw/esm_raw > 0: raw DEFLATE, the
  * emitter's size lever) inflates LAZILY at a module's first load and the
@@ -222,6 +227,7 @@ static const char *isl_edge_find(const char *from, const char *spec, int want) {
 
 /* Defined with the module system below; called from isl_init. */
 static void isl_install_module_loader(void);
+static void isl_init_type_brands(void);
 /* Defined with the host-function machinery below; called from isl_init. */
 static void isl_register_hostfn_class(void);
 /* Defined with the island → static promise bridge below; called from the
@@ -536,6 +542,7 @@ static void isl_init(void) {
     fprintf(stderr, "scriptc: island engine context allocation failed\n");
     abort();
   }
+  isl_init_type_brands();
   JSValue arr = JS_Eval(isl_ctx, isl_prelude, sizeof isl_prelude - 1,
                         "<scr-prelude>", JS_EVAL_TYPE_GLOBAL);
   if (JS_IsException(arr)) {
@@ -1154,6 +1161,103 @@ static bool isl_dynjs_strict_eq(ScrJsval *a, ScrJsval *b) {
 static bool isl_dynjs_is_array(ScrJsval *cell) { return JS_IsArray(cell->v); }
 static bool isl_dynjs_is_error(ScrJsval *cell) { return JS_IsError(cell->v); }
 
+/* Cache engine class IDs from pristine builtins before user code runs.
+ * Class comparisons never inspect public properties or execute traps. */
+static SCR_TL JSClassID isl_module_namespace_class;
+static const char *const isl_brand_names[] = { "SharedArrayBuffer", "GeneratorFunction", "AsyncGeneratorFunction", "Generator", "AsyncGenerator",
+  "Arguments", "Arguments", "Map Iterator", "Set Iterator", "Number", "String", "Boolean", "Symbol", "BigInt" };
+static SCR_TL JSClassID isl_brand_classes[sizeof isl_brand_names / sizeof isl_brand_names[0]];
+static void isl_init_type_brands(void) {
+  static const char brand_source[] =
+    "[new SharedArrayBuffer(0), function*(){}, async function*(){}, (function*(){})(), (async function*(){})(),"
+    "(function(){'use strict';return arguments})(1), Function('a','return arguments')(1),"
+    "new Map().entries(), new Set().values(), Object(0), Object(''), Object(false), Object(Symbol()), Object(0n)]";
+  JSValue brands = JS_Eval(isl_ctx, brand_source, sizeof brand_source - 1, "<scr-type-brands>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(brands)) {
+    fprintf(stderr, "scriptc: island type brands failed to initialize\n");
+    abort();
+  }
+  for (size_t i = 0; i < sizeof isl_brand_classes / sizeof isl_brand_classes[0]; i++) {
+    JSValue value = JS_GetPropertyUint32(isl_ctx, brands, (uint32_t)i);
+    isl_brand_classes[i] = JS_GetClassID(value);
+    JS_FreeValue(isl_ctx, value);
+  }
+  JS_FreeValue(isl_ctx, brands);
+  static const char namespace_source[] = "export {};";
+  JSValue module = JS_Eval(isl_ctx, namespace_source, sizeof namespace_source - 1,
+      "<scr-type-brands>", JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+  JSValue evaluated = JS_IsException(module) ? JS_EXCEPTION : JS_EvalFunction(isl_ctx, JS_DupValue(isl_ctx, module));
+  JSValue namespace = JS_IsException(evaluated) ? JS_EXCEPTION : JS_GetModuleNamespace(isl_ctx, JS_VALUE_GET_PTR(module));
+  if (JS_IsException(namespace)) {
+    fprintf(stderr, "scriptc: island type brands failed to initialize\n");
+    abort();
+  }
+  isl_module_namespace_class = JS_GetClassID(namespace);
+  JS_FreeValue(isl_ctx, namespace);
+  JS_FreeValue(isl_ctx, evaluated);
+  JS_FreeValue(isl_ctx, module);
+}
+
+static bool isl_class_named(JSValueConst value, const char *name) {
+  JSClassID id = JS_GetClassID(value);
+  if (!id) return false;
+  for (size_t i = 0; i < sizeof isl_brand_names / sizeof isl_brand_names[0]; i++)
+    if (id == isl_brand_classes[i] && strcmp(isl_brand_names[i], name) == 0) return true;
+  return false;
+}
+
+static bool isl_type_probe(JSValueConst value, const char *probe, size_t len) {
+#define PROBE(name) (len == sizeof(name) - 1 && memcmp(probe, name, sizeof(name) - 1) == 0)
+  int typed = JS_GetTypedArrayType(value);
+  if (PROBE("isTypedArray")) return typed >= 0;
+  if (PROBE("isArrayBufferView")) return typed >= 0 || JS_IsDataView(value);
+  if (PROBE("isUint8Array")) return typed == JS_TYPED_ARRAY_UINT8;
+  if (PROBE("isUint8ClampedArray")) return typed == JS_TYPED_ARRAY_UINT8C;
+  if (PROBE("isUint16Array")) return typed == JS_TYPED_ARRAY_UINT16;
+  if (PROBE("isUint32Array")) return typed == JS_TYPED_ARRAY_UINT32;
+  if (PROBE("isInt8Array")) return typed == JS_TYPED_ARRAY_INT8;
+  if (PROBE("isInt16Array")) return typed == JS_TYPED_ARRAY_INT16;
+  if (PROBE("isInt32Array")) return typed == JS_TYPED_ARRAY_INT32;
+  if (PROBE("isFloat16Array")) return typed == JS_TYPED_ARRAY_FLOAT16;
+  if (PROBE("isFloat32Array")) return typed == JS_TYPED_ARRAY_FLOAT32;
+  if (PROBE("isFloat64Array")) return typed == JS_TYPED_ARRAY_FLOAT64;
+  if (PROBE("isBigInt64Array")) return typed == JS_TYPED_ARRAY_BIG_INT64;
+  if (PROBE("isBigUint64Array")) return typed == JS_TYPED_ARRAY_BIG_UINT64;
+  if (PROBE("isArrayBuffer")) return JS_IsArrayBuffer(value);
+  if (PROBE("isDataView")) return JS_IsDataView(value);
+  if (PROBE("isDate")) return JS_IsDate(value);
+  if (PROBE("isMap")) return JS_IsMap(value);
+  if (PROBE("isSet")) return JS_IsSet(value);
+  if (PROBE("isWeakMap")) return JS_IsWeakMap(value);
+  if (PROBE("isWeakSet")) return JS_IsWeakSet(value);
+  if (PROBE("isRegExp")) return JS_IsRegExp(value);
+  if (PROBE("isPromise")) return JS_IsPromise(value);
+  if (PROBE("isProxy")) return JS_IsProxy(value);
+  if (PROBE("isNativeError")) return JS_IsError(value);
+  if (PROBE("isAnyArrayBuffer")) return JS_IsArrayBuffer(value) || isl_class_named(value, "SharedArrayBuffer");
+  if (PROBE("isSharedArrayBuffer")) return isl_class_named(value, "SharedArrayBuffer");
+  if (PROBE("isAsyncFunction")) return JS_IsAsyncFunction(value) || isl_class_named(value, "AsyncGeneratorFunction");
+  if (PROBE("isGeneratorFunction")) return isl_class_named(value, "GeneratorFunction") || isl_class_named(value, "AsyncGeneratorFunction");
+  if (PROBE("isGeneratorObject")) return isl_class_named(value, "Generator") || isl_class_named(value, "AsyncGenerator");
+  if (PROBE("isArgumentsObject")) return isl_class_named(value, "Arguments");
+  if (PROBE("isMapIterator")) return isl_class_named(value, "Map Iterator");
+  if (PROBE("isSetIterator")) return isl_class_named(value, "Set Iterator");
+  if (PROBE("isModuleNamespaceObject")) return isl_module_namespace_class && JS_GetClassID(value) == isl_module_namespace_class;
+  if (PROBE("isNumberObject")) return isl_class_named(value, "Number");
+  if (PROBE("isStringObject")) return isl_class_named(value, "String");
+  if (PROBE("isBooleanObject")) return isl_class_named(value, "Boolean");
+  if (PROBE("isSymbolObject")) return isl_class_named(value, "Symbol");
+  if (PROBE("isBigIntObject")) return isl_class_named(value, "BigInt");
+  if (PROBE("isBoxedPrimitive")) return isl_class_named(value, "Number") || isl_class_named(value, "String") ||
+    isl_class_named(value, "Boolean") || isl_class_named(value, "Symbol") || isl_class_named(value, "BigInt");
+#undef PROBE
+  return false;
+}
+
+static bool isl_dynjs_type_probe(ScrJsval *cell, const ScrStr *probe) {
+  return isl_type_probe(cell->v, probe->data, probe->len);
+}
+
 static const ScrDynJsvalOps isl_dynjs_ops;
 
 /* The jsval→dyn wrap over a RAW engine value (BORROWED) — the scalar
@@ -1442,6 +1546,7 @@ static const ScrDynJsvalOps isl_dynjs_ops = {
   isl_dynjs_iter_drain,
   isl_dynjs_iterator,
   isl_dynjs_iter_n,
+  isl_dynjs_type_probe,
 };
 
 ScrDyn *scr_dyn_from_jsval(ScrJsval *cell) {
@@ -2552,32 +2657,49 @@ static JSModuleDef *isl_module_load(JSContext *ctx, const char *name, void *opaq
   free(heap);
   if (JS_IsException(v)) return NULL;
   JSModuleDef *def = JS_VALUE_GET_PTR(v);
-  /* import.meta.url — Node sets the module's file:// URL; embedded keys
-   * are realpaths, builtins keep their node: name. Emscripten factory
-   * modules read it (_scriptName, createRequire(import.meta.url)). */
+  /* File-backed metadata uses the same converters as node:url. Embedded
+   * keys are resolved paths, including spaces, percent signs and Unicode;
+   * concatenating file:// would reinterpret those as URL syntax. */
   JSValue meta = JS_GetImportMeta(ctx, def);
   if (!JS_IsException(meta)) {
     JSValue url;
-    if (name[0] == '/') {
-      size_t n = strlen(name) + 8;
-      char *buf2 = malloc(n);
-      if (buf2) {
-        snprintf(buf2, n, "file://%s", name);
-        url = JS_NewString(ctx, buf2);
-        free(buf2);
-      } else {
-        url = JS_NewString(ctx, name);
+    bool file_backed = name[0] == '/' ||
+      (name[0] && name[1] == ':' && (name[2] == '/' || name[2] == '\\')) ||
+      (name[0] == '\\' && name[1] == '\\');
+    if (file_backed) {
+      ScrStr *path = scr_str_new(name, strlen(name));
+      ScrUrl *parsed = scr_url_from_path(path);
+      ScrStr *href = parsed ? scr_url_href(parsed) : NULL;
+      ScrStr *dir = scr_path_dirname(path);
+      if (!href || !dir) {
+        if (href) scr_str_release(href);
+        if (dir) scr_str_release(dir);
+        if (parsed) scr_url_release(parsed);
+        scr_str_release(path);
+        isl_throw_pending(ctx);
+        JS_FreeValue(ctx, meta);
+        JS_FreeValue(ctx, v);
+        return NULL;
       }
+      JS_SetPropertyStr(ctx, meta, "dirname", JS_NewStringLen(ctx, dir->data, dir->len));
+      JS_SetPropertyStr(ctx, meta, "filename", JS_NewStringLen(ctx, path->data, path->len));
+      url = JS_NewStringLen(ctx, href->data, href->len);
+      scr_str_release(href);
+      scr_str_release(dir);
+      scr_url_release(parsed);
+      scr_str_release(path);
     } else {
       url = JS_NewString(ctx, name);
     }
-    JS_SetPropertyStr(ctx, meta, "url", url); /* consumed */
+    JS_SetPropertyStr(ctx, meta, "main", JS_NewBool(ctx, isl_main_module && strcmp(isl_main_module, name) == 0));
     JSValue key = JS_NewString(ctx, name);
     JSValueConst data[1] = {key};
     JSValue resolve_fn = JS_NewCFunctionData(ctx, isl_import_meta_resolve, 1,
                                              0, 1, data);
     JS_FreeValue(ctx, key); /* resolve_fn's func_data retains it */
+    JS_DefinePropertyValueStr(ctx, resolve_fn, "name", JS_NewString(ctx, "resolve"), JS_PROP_CONFIGURABLE);
     JS_SetPropertyStr(ctx, meta, "resolve", resolve_fn); /* consumed */
+    JS_SetPropertyStr(ctx, meta, "url", url); /* consumed */
     JS_FreeValue(ctx, meta);
   }
   JS_FreeValue(ctx, v);
@@ -2663,7 +2785,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);
   }
@@ -2856,6 +2978,143 @@ 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_system_error_entries(JSContext *ctx, JSValueConst this_val, int argc,
+                                             JSValueConst *argv) {
+  (void)ctx; (void)this_val; (void)argc; (void)argv;
+  ScrDyn *entries = scr_util_system_error_entries();
+  JSValue result = isl_from_dyn(entries);
+  scr_dyn_release(entries);
+  return result;
+}
+
+static JSValue isl_host_system_error_info(JSContext *ctx, JSValueConst this_val, int argc,
+                                          JSValueConst *argv) {
+  (void)this_val;
+  if (argc != 2) return JS_ThrowTypeError(ctx, "invalid system error bridge arity");
+  double number;
+  if (JS_ToFloat64(ctx, &number, argv[0]) < 0) return JS_EXCEPTION;
+  ScrDyn value = {0}; value.kind = SCR_DYN_NUM; value.v.num = number;
+  ScrStr *text = JS_ToBool(ctx, argv[1]) ? scr_util_system_error_message(&value) : scr_util_system_error_name(&value);
+  if (!text) return isl_throw_pending(ctx);
+  JSValue result = JS_NewStringLen(ctx, text->data, text->len);
+  scr_str_release(text);
+  return result;
+}
+
+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;
@@ -2871,8 +3130,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);
@@ -2881,10 +3179,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;
     }
@@ -2945,8 +3255,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)));
@@ -3143,41 +3456,44 @@ static JSValue isl_host_zlib(JSContext *ctx, JSValueConst this_val, int argc,
 static JSValue isl_host_url_to_path(JSContext *ctx, JSValueConst this_val, int argc,
                                     JSValueConst *argv) {
   (void)this_val;
-  (void)argc;
-  ScrStr *s = isl_arg_str(ctx, argv[0]);
-  if (!s) return JS_EXCEPTION;
-#ifdef _WIN32
-  ScrUrl *u = scr_url_new(s);
-  ScrStr *r = u ? scr_url_to_path_w32(u) : NULL;
-  if (u) scr_url_release(u);
-#else
-  ScrStr *r = scr_url_str_to_path(s);
-#endif
-  scr_str_release(s);
-  if (!r) return isl_throw_pending(ctx);
-  JSValue out = JS_NewStringLen(ctx, r->data, r->len);
-  scr_str_release(r);
-  return out;
+  ScrDyn *input = isl_dyn_from_value(argc ? argv[0] : JS_UNDEFINED);
+  if (!input) return JS_EXCEPTION;
+  ScrDyn *options = isl_dyn_from_value(argc > 1 ? argv[1] : JS_UNDEFINED);
+  ScrStr *path = scr_url_checked_to_path_options(input, options);
+  scr_dyn_release(input); scr_dyn_release(options);
+  if (!path) return isl_throw_pending(ctx);
+  JSValue result = JS_NewStringLen(ctx, path->data, path->len);
+  scr_str_release(path);
+  return result;
+}
+
+static JSValue isl_host_url_to_path_buffer(JSContext *ctx, JSValueConst this_val, int argc,
+                                           JSValueConst *argv) {
+  (void)this_val;
+  ScrDyn *input = isl_dyn_from_value(argc ? argv[0] : JS_UNDEFINED);
+  if (!input) return JS_EXCEPTION;
+  ScrDyn *options = isl_dyn_from_value(argc > 1 ? argv[1] : JS_UNDEFINED);
+  ScrBytes *path = scr_url_checked_to_path_buffer(input, options);
+  scr_dyn_release(input); scr_dyn_release(options);
+  if (!path) return isl_throw_pending(ctx);
+  JSValue result = JS_NewUint8ArrayCopy(ctx, path->data, path->len);
+  scr_bytes_release(path);
+  return result;
 }
 
 static JSValue isl_host_url_from_path(JSContext *ctx, JSValueConst this_val, int argc,
                                       JSValueConst *argv) {
   (void)this_val;
-  (void)argc;
-  ScrStr *s = isl_arg_str(ctx, argv[0]);
-  if (!s) return JS_EXCEPTION;
-#ifdef _WIN32
-  ScrUrl *u = scr_url_from_path_w32(s);
-#else
-  ScrUrl *u = scr_url_from_path(s);
-#endif
-  scr_str_release(s);
-  if (!u) return isl_throw_pending(ctx);
-  ScrStr *href = scr_url_href(u);
-  scr_url_release(u);
-  JSValue out = JS_NewStringLen(ctx, href->data, href->len);
+  ScrDyn *input = isl_dyn_from_value(argc ? argv[0] : JS_UNDEFINED);
+  ScrDyn *options = isl_dyn_from_value(argc > 1 ? argv[1] : JS_UNDEFINED);
+  ScrUrl *url = scr_url_checked_from_path(input, options);
+  scr_dyn_release(input); scr_dyn_release(options);
+  if (!url) return isl_throw_pending(ctx);
+  ScrStr *href = scr_url_href(url);
+  scr_url_release(url);
+  JSValue result = JS_NewStringLen(ctx, href->data, href->len);
   scr_str_release(href);
-  return out;
+  return result;
 }
 
 /* fs.constants (and the legacy `constants` module's fs half): the REAL
@@ -3205,6 +3521,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
@@ -3253,7 +3577,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);
@@ -3273,12 +3597,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;
@@ -3484,6 +3834,18 @@ static JSValue isl_host_hostname(JSContext *ctx, JSValueConst this_val, int argc
   return JS_NewString(ctx, buf);
 }
 
+static JSValue isl_host_type_probe(JSContext *ctx, JSValueConst this_val,
+    int argc, JSValueConst *argv) {
+  (void)this_val;
+  if (argc < 2) return JS_FALSE;
+  size_t len;
+  const char *probe = JS_ToCStringLen(ctx, &len, argv[0]);
+  if (!probe) return JS_EXCEPTION;
+  bool result = isl_type_probe(argv[1], probe, len);
+  JS_FreeCString(ctx, probe);
+  return JS_NewBool(ctx, result);
+}
+
 /* The bootstrap: the CommonJS require shim over the embedded map, the
  * builtin shims, and the real process bridge. Evaluated once (module boot);
  * returns the CJS import helper the boundary below pins. Everything JS
@@ -3554,16 +3916,15 @@ static const char isl_modules_bootstrap[] =
     "  const cache = Object.create(null);\n"
     "  const builtins = Object.create(null);\n"
     "  const builtinModules = ['assert','assert/strict','async_hooks','buffer','child_process','cluster','console','constants','crypto','dgram','diagnostics_channel','dns','dns/promises','domain','events','fs','fs/promises','http','http2','https','inspector','inspector/promises','module','net','os','path','path/posix','path/win32','perf_hooks','process','punycode','querystring','readline','readline/promises','repl','stream','stream/consumers','stream/promises','stream/web','string_decoder','sys','timers','timers/promises','tls','trace_events','tty','url','util','util/types','v8','vm','wasi','worker_threads','zlib'];\n"
-    /* Node's require stack: each CJS module remembers its FIRST requirer
-     * (Node's module.parent / moduleParentCache — the chain is static,
-     * captured at first load, not the dynamic call stack), and a failing
-     * resolution reports the requiring module plus its parent chain.
+    /* Node's require stack follows module records, including parents
+     * whose evaluation failed or whose cache entry was deleted. A failing
+     * resolution reports the requiring module plus its first-parent chain.
      * Entry modules loaded from the compiled (ESM-like) world have no
      * parent, exactly like Node's ESM→CJS boundary. */
-    "  const parents = Object.create(null);\n"
-    "  const requireStackOf = (from) => {\n"
+    "  const moduleParents = new WeakMap();\n"
+    "  const requireStackOf = (parent) => {\n"
     "    const stack = [];\n"
-    "    for (let m = from; m !== undefined; m = parents[m]) stack.push(m);\n"
+    "    for (let m = parent; m; m = moduleParents.get(m)) stack.push(m.filename || m.id);\n"
     "    return stack;\n"
     "  };\n"
     /* Node resolves core modules unconditionally, before node_modules
@@ -3576,12 +3937,13 @@ static const char isl_modules_bootstrap[] =
      * properties. (Unshimmed BUILTINS reached by build-time-visible lazy
      * edges resolve through the edge table to their node: keys and take
      * requireKey's does-not-provide throw below instead.) */
-    "  const resolveFrom = (from, spec) => {\n"
+    "  const resolveFrom = (parent, spec) => {\n"
+    "    const from = parent.filename;\n"
     "    const to = host.resolve(from, spec);\n"
     "    if (to === undefined) {\n"
     "      const name = spec.startsWith('node:') ? spec.slice(5) : spec;\n"
     "      if (builtins[name]) return 'node:' + name;\n"
-    "      const stack = requireStackOf(from);\n"
+    "      const stack = requireStackOf(parent);\n"
     "      const err = new Error(\"Cannot find module '\" + spec + \"'\" +\n"
     "        (stack.length ? '\\nRequire stack:\\n- ' + stack.join('\\n- ') : ''));\n"
     "      err.code = 'MODULE_NOT_FOUND';\n"
@@ -3611,12 +3973,52 @@ static const char isl_modules_bootstrap[] =
     "    }\n"
     "    return out;\n"
     "  };\n"
-    "  const decorateRequire = (req, from) => {\n"
+    "  // CommonJS module records retain identity across cache hits and circular loads.\n"
+    "  const modulePathsFrom = (directory) => {\n"
+    "    const paths = [];\n"
+    "    const path = builtins.path();\n"
+    "    for (let dir = directory;;) {\n"
+    "      if (path.basename(dir) !== 'node_modules') paths.push(path.join(dir, 'node_modules'));\n"
+    "      const parent = path.dirname(dir);\n"
+    "      if (parent === dir) break;\n"
+    "      dir = parent;\n"
+    "    }\n"
+    "    return paths;\n"
+    "  };\n"
+    "  const updateChildren = (parent, child) => {\n"
+    "    if (parent && parent.children && !parent.children.includes(child)) parent.children.push(child);\n"
+    "  };\n"
+    "  function Module(id = '', parent) {\n"
+    "    this.id = id;\n"
+    "    this.path = builtins.path().dirname(id);\n"
+    "    this.exports = {};\n"
+    "    moduleParents.set(this, parent);\n"
+    "    updateChildren(parent, this);\n"
+    "    this.filename = null;\n"
+    "    this.loaded = false;\n"
+    "    this.children = [];\n"
+    "  }\n"
+    "  Object.defineProperty(Module.prototype, 'parent', {\n"
+    "    get() { return moduleParents.get(this); },\n"
+    "    set(parent) { moduleParents.set(this, parent); },\n"
+    "  });\n"
+    "  Object.defineProperty(Module.prototype, 'isPreloading', { get() { return false; } });\n"
+    "  Module.prototype.require = function(id) {\n"
+    "    if (typeof id !== 'string') envArgumentError('id', 'of type string', id);\n"
+    "    if (id.length === 0) {\n"
+    "      const error = new TypeError(\"The argument 'id' must be a non-empty string. Received ''\");\n"
+    "      error.code = 'ERR_INVALID_ARG_VALUE';\n"
+    "      throw error;\n"
+    "    }\n"
+    "    return requireKey(resolveFrom(this, id), this);\n"
+    "  };\n"
+    "  const decorateRequire = (req, parent) => {\n"
+    "    const from = parent.filename;\n"
     "    const resolve = (spec) => {\n"
     "      if (typeof spec !== 'string') return requirePathsFrom(from, spec);\n"
     "      const bare = spec.startsWith('node:') ? spec.slice(5) : spec;\n"
     "      if (builtinModules.includes(bare) && (spec.startsWith('node:') || bare !== 'test')) return spec;\n"
-    "      return resolveFrom(from, spec);\n"
+    "      return resolveFrom(parent, spec);\n"
     "    };\n"
     "    resolve.paths = (spec) => requirePathsFrom(from, spec);\n"
     "    req.resolve = resolve;\n"
@@ -3630,26 +4032,32 @@ static const char isl_modules_bootstrap[] =
     "      return b();\n"
     "    }\n"
     "    const hit = cache[key];\n"
-    "    if (hit) return hit.exports;\n"
+    "    if (hit) { updateChildren(parent, hit); return hit.exports; }\n"
     "    const info = host.source(key);\n"
     "    if (info === undefined) throw new Error(\"module '\" + key + \"' is not embedded\");\n"
     "    const src = info[0], format = info[1];\n"
-    "    const mod = { exports: {} };\n"
+    "    const mod = new Module(key, parent);\n"
+    "    mod.filename = key;\n"
+    "    mod.paths = modulePathsFrom(mod.path);\n"
     "    cache[key] = mod;\n"
-    "    if (parent !== undefined && !(key in parents)) parents[key] = parent;\n"
-    "    if (format === 2) { mod.exports = JSON.parse(src); return mod.exports; }\n"
-    "    if (format === 0) { delete cache[key]; throw new Error('require() of ES module ' + key); }\n"
-    "    const fn = new Function('exports', 'require', 'module', '__filename', '__dirname', src);\n"
-    "    const req = decorateRequire((spec) => requireKey(resolveFrom(key, spec), key), key);\n"
-    "    const dir = key.slice(0, key.lastIndexOf('/')) || '/';\n"
+    "    const req = decorateRequire((spec) => mod.require(spec), mod);\n"
     /* A module whose evaluation THROWS leaves no cache entry — Node
      * deletes it so a later require re-evaluates (and a lazy require
      * trap throws EVERY time instead of answering {} on the retry). */
     "    try {\n"
-    "      fn.call(mod.exports, mod.exports, req, mod, key, dir);\n"
+    "      if (format === 2) mod.exports = JSON.parse(src);\n"
+    "      else {\n"
+    "        if (format === 0) throw new Error('require() of ES module ' + key);\n"
+    "        const fn = new Function('exports', 'require', 'module', '__filename', '__dirname', src);\n"
+    "        fn.call(mod.exports, mod.exports, req, mod, key, mod.path);\n"
+    "      }\n"
+    "      mod.loaded = true;\n"
     "    } catch (e) {\n"
     "      delete cache[key];\n"
-    "      delete parents[key];\n"
+    "      if (parent && Array.isArray(parent.children)) {\n"
+    "        const index = parent.children.indexOf(mod);\n"
+    "        if (index !== -1) parent.children.splice(index, 1);\n"
+    "      }\n"
     "      throw e;\n"
     "    }\n"
     "    return mod.exports;\n"
@@ -3658,20 +4066,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"
@@ -3681,42 +4088,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"
@@ -3726,13 +4155,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"
@@ -3742,18 +4174,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"
@@ -3987,13 +4556,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"
@@ -4049,16 +4624,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"
@@ -4112,11 +4687,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"
@@ -4213,22 +4986,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"
@@ -4250,13 +5014,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"
@@ -4339,44 +5101,161 @@ static const char isl_modules_bootstrap[] =
     "    return tty;\n"
     "  });\n"
     "  builtins.diagnostics_channel = memo(() => {\n"
-    /* Real pub/sub semantics for plain channels (publish with no
-     * subscribers is a no-op, matching Node); tracingChannel reports
-     * hasSubscribers=false and its trace* methods run the traced function
-     * without publishing lifecycle events — the AI SDK checks
-     * hasSubscribers and skips tracing, exactly the Node path when nothing
-     * subscribed. */
-    "    const channels = Object.create(null);\n"
+    "    // Store bindings count as active even when there are no message subscribers.\n"
+    "    // Store propagation follows the island's synchronous AsyncLocalStorage model.\n"
+    "    const channels = new Map();\n"
+    "    const deferError = (error) => { queueMicrotask(() => { throw error; }); };\n"
+    "    const deactivate = (channel) => {\n"
+    "      if (!channel._subscribers.length && !channel._stores.size) {\n"
+    "        channel._subscribers = undefined;\n"
+    "        channel._stores = undefined;\n"
+    "      }\n"
+    "    };\n"
     "    class Channel {\n"
-    "      constructor(name) { this.name = name; this._subs = []; }\n"
-    "      get hasSubscribers() { return this._subs.length > 0; }\n"
-    "      subscribe(fn) { this._subs.push(fn); }\n"
-    "      unsubscribe(fn) {\n"
-    "        const i = this._subs.indexOf(fn);\n"
-    "        if (i < 0) return false;\n"
-    "        this._subs.splice(i, 1);\n"
+    "      constructor(name) {\n"
+    "        this._subscribers = undefined;\n"
+    "        this._stores = undefined;\n"
+    "        this.name = name;\n"
+    "        channels.set(name, this);\n"
+    "      }\n"
+    "      static [Symbol.hasInstance](value) {\n"
+    "        if (value == null) throw new TypeError('Cannot convert undefined or null to object');\n"
+    "        return Object.getPrototypeOf(value) === Channel.prototype;\n"
+    "      }\n"
+    "      _activate() {\n"
+    "        if (this._subscribers === undefined) {\n"
+    "          this._subscribers = [];\n"
+    "          this._stores = new Map();\n"
+    "        }\n"
+    "      }\n"
+    "      get hasSubscribers() { return this._subscribers !== undefined; }\n"
+    "      subscribe(subscription) {\n"
+    "        this._activate();\n"
+    "        if (typeof subscription !== 'function') envArgumentError('subscription', 'of type function', subscription);\n"
+    "        this._subscribers = [...this._subscribers, subscription];\n"
+    "      }\n"
+    "      unsubscribe(subscription) {\n"
+    "        const index = this._subscribers?.indexOf(subscription) ?? -1;\n"
+    "        if (index === -1) return false;\n"
+    "        this._subscribers = [...this._subscribers.slice(0, index), ...this._subscribers.slice(index + 1)];\n"
+    "        deactivate(this);\n"
     "        return true;\n"
     "      }\n"
-    "      publish(msg) { for (const f of this._subs.slice()) f(msg, this.name); }\n"
+    "      publish(data) {\n"
+    "        const subscribers = this._subscribers;\n"
+    "        for (const subscriber of subscribers ?? []) {\n"
+    "          try { subscriber(data, this.name); }\n"
+    "          catch (error) { deferError(error); }\n"
+    "        }\n"
+    "      }\n"
+    "      bindStore(store, transform) { this._activate(); this._stores.set(store, transform); }\n"
+    "      unbindStore(store) {\n"
+    "        if (!this._stores?.delete(store)) return false;\n"
+    "        deactivate(this);\n"
+    "        return true;\n"
+    "      }\n"
+    "      runStores(data, fn, thisArg, ...args) {\n"
+    "        let run = () => { this.publish(data); return Reflect.apply(fn, thisArg, args); };\n"
+    "        for (const [store, transform = (data) => data] of this._stores ?? []) {\n"
+    "          const next = run;\n"
+    "          run = () => {\n"
+    "            let context;\n"
+    "            try { context = transform(data); }\n"
+    "            catch (error) { deferError(error); return next(); }\n"
+    "            return store.run(context, next);\n"
+    "          };\n"
+    "        }\n"
+    "        return run();\n"
+    "      }\n"
     "    }\n"
-    "    const channel = (name) => channels[name] || (channels[name] = new Channel(name));\n"
-    "    const tracingChannel = (name) => ({\n"
-    "      get hasSubscribers() {\n"
-    "        if (typeof name !== 'string') return false;\n"
-    "        for (const s of ['start', 'end', 'asyncStart', 'asyncEnd', 'error']) {\n"
-    "          if (channel('tracing:' + name + ':' + s).hasSubscribers) return true;\n"
+    "    const channel = (name) => {\n"
+    "      const existing = channels.get(name);\n"
+    "      if (existing) return existing;\n"
+    "      if (typeof name !== 'string' && typeof name !== 'symbol') envArgumentError('channel', 'one of type string or symbol', name);\n"
+    "      return new Channel(name);\n"
+    "    };\n"
+    "    const traceEvents = ['start', 'end', 'asyncStart', 'asyncEnd', 'error'];\n"
+    "    class TracingChannel {\n"
+    "      constructor(nameOrChannels) {\n"
+    "        for (const name of traceEvents) {\n"
+    "          let event;\n"
+    "          if (typeof nameOrChannels === 'string') event = channel('tracing:' + nameOrChannels + ':' + name);\n"
+    "          else if (nameOrChannels !== null && typeof nameOrChannels === 'object') {\n"
+    "            event = nameOrChannels[name];\n"
+    "            if (!(event instanceof Channel)) envArgumentError('nameOrChannels.' + name, 'an instance of Channel', event);\n"
+    "          } else envArgumentError('nameOrChannels', 'of type string or an instance of TracingChannel or Object', nameOrChannels);\n"
+    "          Object.defineProperty(this, name, { value: event });\n"
     "        }\n"
-    "        return false;\n"
-    "      },\n"
-    "      traceSync(fn, ctx, thisArg, ...args) { return fn.apply(thisArg, args); },\n"
-    "      tracePromise(fn, ctx, thisArg, ...args) { return fn.apply(thisArg, args); },\n"
-    "      traceCallback(fn, position, ctx, thisArg, ...args) { return fn.apply(thisArg, args); },\n"
-    "    });\n"
+    "      }\n"
+    "      get hasSubscribers() { return traceEvents.some((name) => this[name]?.hasSubscribers); }\n"
+    "      subscribe(handlers) {\n"
+    "        for (const name of traceEvents) if (handlers[name]) this[name]?.subscribe(handlers[name]);\n"
+    "      }\n"
+    "      unsubscribe(handlers) {\n"
+    "        let done = true;\n"
+    "        for (const name of traceEvents) if (handlers[name] && !this[name]?.unsubscribe(handlers[name])) done = false;\n"
+    "        return done;\n"
+    "      }\n"
+    "      traceSync(fn, context = {}, thisArg, ...args) {\n"
+    "        if (!this.hasSubscribers) return Reflect.apply(fn, thisArg, args);\n"
+    "        return this.start.runStores(context, () => {\n"
+    "          try { const result = Reflect.apply(fn, thisArg, args); context.result = result; return result; }\n"
+    "          catch (error) { context.error = error; this.error.publish(context); throw error; }\n"
+    "          finally { this.end.publish(context); }\n"
+    "        });\n"
+    "      }\n"
+    "      tracePromise(fn, context = {}, thisArg, ...args) {\n"
+    "        if (!this.hasSubscribers) return Reflect.apply(fn, thisArg, args);\n"
+    "        const resolve = (result) => {\n"
+    "          context.result = result;\n"
+    "          this.asyncStart.publish(context);\n"
+    "          this.asyncEnd.publish(context);\n"
+    "          return result;\n"
+    "        };\n"
+    "        const reject = (error) => {\n"
+    "          context.error = error;\n"
+    "          this.error.publish(context);\n"
+    "          this.asyncStart.publish(context);\n"
+    "          this.asyncEnd.publish(context);\n"
+    "          return Promise.reject(error);\n"
+    "        };\n"
+    "        return this.start.runStores(context, () => {\n"
+    "          try {\n"
+    "            let promise = Reflect.apply(fn, thisArg, args);\n"
+    "            if (!(promise instanceof Promise)) promise = Promise.resolve(promise);\n"
+    "            return Promise.prototype.then.call(promise, resolve, reject);\n"
+    "          } catch (error) { context.error = error; this.error.publish(context); throw error; }\n"
+    "          finally { this.end.publish(context); }\n"
+    "        });\n"
+    "      }\n"
+    "      traceCallback(fn, position = -1, context = {}, thisArg, ...args) {\n"
+    "        if (!this.hasSubscribers) return Reflect.apply(fn, thisArg, args);\n"
+    "        const { start, end, asyncStart, asyncEnd, error } = this;\n"
+    "        const callback = args.at(position);\n"
+    "        if (typeof callback !== 'function') envArgumentError('callback', 'of type function', callback);\n"
+    "        function wrappedCallback(err, result) {\n"
+    "          if (err) { context.error = err; error.publish(context); }\n"
+    "          else context.result = result;\n"
+    "          asyncStart.runStores(context, () => {\n"
+    "            try { return Reflect.apply(callback, this, arguments); }\n"
+    "            finally { asyncEnd.publish(context); }\n"
+    "          });\n"
+    "        }\n"
+    "        args.splice(position, 1, wrappedCallback);\n"
+    "        return start.runStores(context, () => {\n"
+    "          try { return Reflect.apply(fn, thisArg, args); }\n"
+    "          catch (err) { context.error = err; error.publish(context); throw err; }\n"
+    "          finally { end.publish(context); }\n"
+    "        });\n"
+    "      }\n"
+    "    }\n"
     "    const dc = {\n"
     "      channel,\n"
-    "      subscribe: (name, fn) => { channel(name).subscribe(fn); },\n"
-    "      unsubscribe: (name, fn) => channel(name).unsubscribe(fn),\n"
-    "      hasSubscribers: (name) => channel(name).hasSubscribers,\n"
-    "      tracingChannel,\n"
+    "      subscribe: (name, subscription) => channel(name).subscribe(subscription),\n"
+    "      unsubscribe: (name, subscription) => channel(name).unsubscribe(subscription),\n"
+    "      hasSubscribers: (name) => channels.get(name)?.hasSubscribers ?? false,\n"
+    "      tracingChannel: (nameOrChannels) => new TracingChannel(nameOrChannels),\n"
+    "      Channel,\n"
     "    };\n"
     "    dc.default = dc;\n"
     "    return dc;\n"
@@ -4394,7 +5273,10 @@ static const char isl_modules_bootstrap[] =
     "      if (key.startsWith('file://')) key = decodeURIComponent(key.slice(7));\n"
     /* The base file is the created require's parent, like Node: modules
      * it loads report it in their require stacks. */
-    "      return decorateRequire((spec) => requireKey(spec.startsWith('node:') ? spec : resolveFrom(key, spec), key), key);\n"
+    "      const parent = new Module(key);\n"
+    "      parent.filename = key;\n"
+    "      parent.paths = modulePathsFrom(parent.path);\n"
+    "      return decorateRequire((spec) => parent.require(spec), parent);\n"
     "    };\n"
     /* builtinModules/isBuiltin answer Node's QUESTION ("is this name a
      * Node builtin?") with Node's full list — resolution of unshimmed
@@ -4422,11 +5304,11 @@ static const char isl_modules_bootstrap[] =
      * converters riding the static scr_url.c implementations (Node's
      * exact rules), and the legacy parse/format/resolve trio over the
      * WHATWG parser. */
-    "    const fileURLToPath = (u) => {\n"
-    "      const s = typeof u === 'object' && u !== null && 'href' in u ? String(u.href) : String(u);\n"
-    "      return host.urlToPath(s);\n"
-    "    };\n"
-    "    const pathToFileURL = (p) => new globalThis.URL(host.urlFromPath(String(p)));\n"
+    /* Read user option getters in their engine so thrown values preserve
+     * identity. The path-to-URL public wrapper validates its path first. */
+    "    const fileURLToPath = (u, options) => host.urlToPath(u, { windows: options?.windows });\n"
+    "    const fileURLToPathBuffer = (u, options) => builtins.buffer().Buffer.from(host.urlToPathBuffer(u, { windows: options?.windows }));\n"
+    "    const pathToFileURL = (p, options) => new globalThis.URL(host.urlFromPath(p, typeof p === 'string' ? { windows: options?.windows } : undefined));\n"
     "    const parse = (input, parseQuery) => {\n"
     "      const out = { protocol: null, slashes: null, auth: null, host: null, port: null,\n"
     "        hostname: null, hash: null, search: null, query: null, pathname: null, path: null, href: String(input) };\n"
@@ -4488,7 +5370,7 @@ static const char isl_modules_bootstrap[] =
     "    const u = {\n"
     "      URL: globalThis.URL,\n"
     "      URLSearchParams: globalThis.URLSearchParams,\n"
-    "      fileURLToPath, pathToFileURL, parse, format, resolve,\n"
+    "      fileURLToPath, fileURLToPathBuffer, pathToFileURL, parse, format, resolve,\n"
     /* IDNA is not carried: ASCII hostnames pass through lowercased
      * (documented divergence for internationalized domains). */
     "      domainToASCII: (d) => String(d).toLowerCase(),\n"
@@ -4510,7 +5392,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"
@@ -4548,7 +5430,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"
@@ -5210,15 +6092,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"
@@ -5256,8 +6143,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"
@@ -5266,97 +6154,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"
@@ -5366,7 +6246,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
@@ -5584,12 +6464,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"
@@ -5607,8 +6594,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"
@@ -5634,10 +6621,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"
@@ -5652,7 +6635,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"
@@ -6553,7 +7536,12 @@ static const char isl_modules_bootstrap[] =
     "    const g = globalThis;\n"
     "    const w = {\n"
     "      ReadableStream: g.ReadableStream, TransformStream: g.TransformStream,\n"
-    "      TextDecoderStream: g.TextDecoderStream,\n"
+    "      ReadableStreamDefaultReader: g.ReadableStreamDefaultReader, ReadableStreamDefaultController: g.ReadableStreamDefaultController,\n"
+    "      TextDecoderStream: g.TextDecoderStream, TextEncoderStream: g.TextEncoderStream,\n"
+    "      TransformStreamDefaultController: g.TransformStreamDefaultController,\n"
+    "      WritableStream: g.WritableStream, WritableStreamDefaultWriter: g.WritableStreamDefaultWriter,\n"
+    "      WritableStreamDefaultController: g.WritableStreamDefaultController,\n"
+    "      CountQueuingStrategy: g.CountQueuingStrategy, ByteLengthQueuingStrategy: g.ByteLengthQueuingStrategy,\n"
     "    };\n"
     "    w.default = w;\n"
     "    return w;\n"
@@ -6738,6 +7726,44 @@ static const char isl_modules_bootstrap[] =
     "      generatedMessage: true,\n"
     "    });\n"
     "  };\n"
+    "  const noErrorRegexExec = RegExp.prototype.exec;\n"
+    "  const noErrorMatches = (actual, expected) => {\n"
+    "    if (typeof expected === 'function') {\n"
+    "      if (expected.prototype !== undefined && actual instanceof expected) return true;\n"
+    "      if (Object.prototype.isPrototypeOf.call(Error, expected)) return false;\n"
+    "      if (expected === Error && typeof actual === 'symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n"
+    "      return Reflect.apply(expected, {}, [actual]) === true;\n"
+    "    }\n"
+    "    if (expected instanceof RegExp) return Reflect.apply(noErrorRegexExec, expected, [String(actual)]) !== null;\n"
+    "    envArgumentError('expected', 'of type function or an instance of RegExp', expected);\n"
+    "  };\n"
+    "  const noErrorFailure = (actual, expected, message, operator) => {\n"
+    "    if (typeof expected === 'string') { message = expected; expected = undefined; }\n"
+    "    if (!expected || noErrorMatches(actual, expected)) {\n"
+    "      const kind = operator === 'doesNotReject' ? 'rejection' : 'exception';\n"
+    "      throw new AssertionError({ actual, expected, operator,\n"
+    "        message: 'Got unwanted ' + kind + (message ? ': ' + message : '.') + '\\nActual message: \"' + actual?.message + '\"',\n"
+    "      });\n"
+    "    }\n"
+    "    throw actual;\n"
+    "  };\n"
+    "  const waitForNoError = async (input) => {\n"
+    "    const isPromise = (p) => env.isPromise(p) || (p !== null && typeof p === 'object' && typeof p.then === 'function' && typeof p.catch === 'function');\n"
+    "    let result;\n"
+    "    if (typeof input !== 'function') {\n"
+    "      if (!isPromise(input)) envArgumentError('promiseFn', 'of type function or an instance of Promise', input);\n"
+    "      result = input;\n"
+    "    } else {\n"
+    "      result = input();\n"
+    "      if (!isPromise(result)) {\n"
+    "        const error = new TypeError('Expected instance of Promise to be returned from the \\\"promiseFn\\\" function but got ' + envReceivedType(result) + '.');\n"
+    "        error.code = 'ERR_INVALID_RETURN_VALUE';\n"
+    "        throw error;\n"
+    "      }\n"
+    "    }\n"
+    "    try { await result; } catch (actual) { return { didFail: true, actual }; }\n"
+    "    return { didFail: false };\n"
+    "  };\n"
     "  const assert = Object.assign(ok, {\n"
     "    AssertionError,\n"
     "    ok,\n"
@@ -6806,20 +7832,11 @@ static const char isl_modules_bootstrap[] =
     "      }\n"
     "    },\n"
     "    doesNotThrow(fn, expected, message) {\n"
-    "      if (typeof expected === \"string\") {\n"
-    "        message = expected;\n"
-    "        expected = undefined;\n"
-    "      }\n"
+    "      if (typeof fn !== 'function') envArgumentError('fn', 'of type function', fn);\n"
     "      try {\n"
     "        fn();\n"
     "      } catch (e) {\n"
-    "        if (expected === undefined || checkExpected(e, expected, message, \"doesNotThrow\")) {\n"
-    "          throw new AssertionError({\n"
-    "            message: \"Got unwanted exception\" + (message ? \": \" + message : \".\") + \"\\nActual message: \\\"\" + (e && e.message) + \"\\\"\",\n"
-    "            operator: \"doesNotThrow\",\n"
-    "          });\n"
-    "        }\n"
-    "        throw e;\n"
+    "        noErrorFailure(e, expected, message, 'doesNotThrow');\n"
     "      }\n"
     "    },\n"
     "    async rejects(promiseOrFn, expected, message) {\n"
@@ -6846,21 +7863,8 @@ static const char isl_modules_bootstrap[] =
     "      }\n"
     "    },\n"
     "    async doesNotReject(promiseOrFn, expected, message) {\n"
-    "      if (typeof expected === \"string\") {\n"
-    "        message = expected;\n"
-    "        expected = undefined;\n"
-    "      }\n"
-    "      try {\n"
-    "        await (typeof promiseOrFn === \"function\" ? promiseOrFn() : promiseOrFn);\n"
-    "      } catch (e) {\n"
-    "        if (expected === undefined || checkExpected(e, expected, message, \"doesNotReject\")) {\n"
-    "          throw new AssertionError({\n"
-    "            message: \"Got unwanted rejection\" + (message ? \": \" + message : \".\") + \"\\nActual message: \\\"\" + (e && e.message) + \"\\\"\",\n"
-    "            operator: \"doesNotReject\",\n"
-    "          });\n"
-    "        }\n"
-    "        throw e;\n"
-    "      }\n"
+    "      const result = await waitForNoError(promiseOrFn);\n"
+    "      if (result.didFail) noErrorFailure(result.actual, expected, message, 'doesNotReject');\n"
     "    },\n"
     "    match(string, regexp, message) {\n"
     "      if (!(regexp instanceof RegExp)) {\n"
@@ -6927,7 +7931,7 @@ static const char isl_modules_bootstrap[] =
     "  return assert;\n"
     "}\n"
     "    const u = builtins.util();\n"
-    "    const a = makeAssert({ isDeepStrictEqual: u.isDeepStrictEqual, inspect: u.inspect });\n"
+    "    const a = makeAssert({ isDeepStrictEqual: u.isDeepStrictEqual, inspect: u.inspect, isPromise: u.types.isPromise });\n"
     "    a.default = a;\n"
     "    return a;\n"
     "  });\n"
@@ -6942,6 +7946,21 @@ 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 envReceivedType = (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"
+    "    return received;\n"
+    "  };\n"
+    "  const envArgumentError = (name, expected, value) => {\n"
+    "    const received = envReceivedType(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"
@@ -7337,7 +8356,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"
@@ -7527,21 +8546,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"
@@ -7563,30 +8594,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"
@@ -7595,8 +8617,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"
@@ -7642,390 +8666,613 @@ static const char isl_modules_bootstrap[] =
     "    return fn;\n"
     "  };\n"
     "  const tagOf = (v) => Object.prototype.toString.call(v).slice(8, -1);\n"
-    "  const taggedTest = (tag) => (v) => tagOf(v) === tag && typeof v === \"object\";\n"
     "  const taTagGetter = Object.getOwnPropertyDescriptor(\n"
     "    Object.getPrototypeOf(Object.getPrototypeOf(new Uint8Array(0))), Symbol.toStringTag).get;\n"
-    "  const brandTA = (v) => {\n"
-    "    try {\n"
-    "      return taTagGetter.call(v) !== undefined;\n"
-    "    } catch (e) {\n"
-    "      return false;\n"
-    "    }\n"
-    "  };\n"
     "  const types = {\n"
-    "    isAnyArrayBuffer: (v) => tagOf(v) === \"ArrayBuffer\" || tagOf(v) === \"SharedArrayBuffer\",\n"
-    "    isArrayBufferView: (v) => ArrayBuffer.isView(v),\n"
-    "    isArgumentsObject: taggedTest(\"Arguments\"),\n"
-    "    isArrayBuffer: (v) => {\n"
-    "      try { Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, \"byteLength\").get.call(v); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isAsyncFunction: (v) => typeof v === \"function\" && tagOf(v) === \"AsyncFunction\",\n"
-    "    isBigInt64Array: (v) => tagOf(v) === \"BigInt64Array\",\n"
-    "    isBigUint64Array: (v) => tagOf(v) === \"BigUint64Array\",\n"
-    "    isBooleanObject: (v) => {\n"
-    "      try { Boolean.prototype.valueOf.call(v); return typeof v === \"object\"; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isBoxedPrimitive: (v) =>\n"
-    "      types.isStringObject(v) || types.isNumberObject(v) || types.isBooleanObject(v) ||\n"
-    "      types.isSymbolObject(v) || types.isBigIntObject(v),\n"
-    "    isBigIntObject: (v) => {\n"
-    "      try { BigInt.prototype.valueOf.call(v); return typeof v === \"object\"; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isCryptoKey: () => false,\n"
-    "    isDataView: (v) => {\n"
-    "      try { Object.getOwnPropertyDescriptor(DataView.prototype, \"byteLength\").get.call(v); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isDate: (v) => {\n"
-    "      try { Date.prototype.getTime.call(v); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isExternal: () => false,\n"
-    "    isFloat16Array: (v) => tagOf(v) === \"Float16Array\",\n"
-    "    isFloat32Array: (v) => tagOf(v) === \"Float32Array\",\n"
-    "    isFloat64Array: (v) => tagOf(v) === \"Float64Array\",\n"
-    "    isGeneratorFunction: (v) => typeof v === \"function\" && tagOf(v) === \"GeneratorFunction\",\n"
-    "    isGeneratorObject: (v) => typeof v === \"object\" && v !== null && tagOf(v) === \"Generator\",\n"
-    "    isInt8Array: (v) => tagOf(v) === \"Int8Array\",\n"
-    "    isInt16Array: (v) => tagOf(v) === \"Int16Array\",\n"
-    "    isInt32Array: (v) => tagOf(v) === \"Int32Array\",\n"
-    "    isKeyObject: () => false,\n"
-    "    isMap: (v) => {\n"
-    "      try { Object.getOwnPropertyDescriptor(Map.prototype, \"size\").get.call(v); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isMapIterator: (v) => tagOf(v) === \"Map Iterator\",\n"
-    "    isModuleNamespaceObject: (v) => typeof v === \"object\" && v !== null && tagOf(v) === \"Module\",\n"
-    "    isNativeError: (v) => v instanceof Error && (\n"
-    "      [\"Error\", \"EvalError\", \"RangeError\", \"ReferenceError\", \"SyntaxError\", \"TypeError\", \"URIError\", \"AggregateError\", \"SuppressedError\"].includes(tagOf(v))\n"
-    "    ),\n"
-    "    isNumberObject: (v) => {\n"
-    "      try { Number.prototype.valueOf.call(v); return typeof v === \"object\"; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isPromise: (v) => v instanceof Promise,\n"
-    "    isProxy: () => false,\n"
-    "    isRegExp: (v) => tagOf(v) === \"RegExp\",\n"
-    "    isSet: (v) => {\n"
-    "      try { Object.getOwnPropertyDescriptor(Set.prototype, \"size\").get.call(v); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isSetIterator: (v) => tagOf(v) === \"Set Iterator\",\n"
-    "    isSharedArrayBuffer: (v) => tagOf(v) === \"SharedArrayBuffer\",\n"
-    "    isStringObject: (v) => {\n"
-    "      try { String.prototype.valueOf.call(v); return typeof v === \"object\"; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isSymbolObject: (v) => {\n"
-    "      try { Symbol.prototype.valueOf.call(v); return typeof v === \"object\"; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isTypedArray: brandTA,\n"
-    "    isUint8Array: (v) => tagOf(v) === \"Uint8Array\",\n"
-    "    isUint8ClampedArray: (v) => tagOf(v) === \"Uint8ClampedArray\",\n"
-    "    isUint16Array: (v) => tagOf(v) === \"Uint16Array\",\n"
-    "    isUint32Array: (v) => tagOf(v) === \"Uint32Array\",\n"
-    "    isWeakMap: (v) => {\n"
-    "      try { WeakMap.prototype.has.call(v, {}); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
-    "    isWeakSet: (v) => {\n"
-    "      try { WeakSet.prototype.has.call(v, {}); return true; }\n"
-    "      catch (e) { return false; }\n"
-    "    },\n"
+    "    isAnyArrayBuffer: (v) => env.typeProbe(\"isAnyArrayBuffer\", v),\n"
+    "    isArrayBufferView: (v) => env.typeProbe(\"isArrayBufferView\", v),\n"
+    "    isArgumentsObject: (v) => env.typeProbe(\"isArgumentsObject\", v),\n"
+    "    isArrayBuffer: (v) => env.typeProbe(\"isArrayBuffer\", v),\n"
+    "    isAsyncFunction: (v) => env.typeProbe(\"isAsyncFunction\", v),\n"
+    "    isBigInt64Array: (v) => env.typeProbe(\"isBigInt64Array\", v),\n"
+    "    isBigUint64Array: (v) => env.typeProbe(\"isBigUint64Array\", v),\n"
+    "    isBooleanObject: (v) => env.typeProbe(\"isBooleanObject\", v),\n"
+    "    isBoxedPrimitive: (v) => env.typeProbe(\"isBoxedPrimitive\", v),\n"
+    "    isBigIntObject: (v) => env.typeProbe(\"isBigIntObject\", v),\n"
+    "    isCryptoKey: (v) => env.typeProbe(\"isCryptoKey\", v),\n"
+    "    isDataView: (v) => env.typeProbe(\"isDataView\", v),\n"
+    "    isDate: (v) => env.typeProbe(\"isDate\", v),\n"
+    "    isExternal: (v) => env.typeProbe(\"isExternal\", v),\n"
+    "    isFloat16Array: (v) => env.typeProbe(\"isFloat16Array\", v),\n"
+    "    isFloat32Array: (v) => env.typeProbe(\"isFloat32Array\", v),\n"
+    "    isFloat64Array: (v) => env.typeProbe(\"isFloat64Array\", v),\n"
+    "    isGeneratorFunction: (v) => env.typeProbe(\"isGeneratorFunction\", v),\n"
+    "    isGeneratorObject: (v) => env.typeProbe(\"isGeneratorObject\", v),\n"
+    "    isInt8Array: (v) => env.typeProbe(\"isInt8Array\", v),\n"
+    "    isInt16Array: (v) => env.typeProbe(\"isInt16Array\", v),\n"
+    "    isInt32Array: (v) => env.typeProbe(\"isInt32Array\", v),\n"
+    "    isKeyObject: (v) => env.typeProbe(\"isKeyObject\", v),\n"
+    "    isMap: (v) => env.typeProbe(\"isMap\", v),\n"
+    "    isMapIterator: (v) => env.typeProbe(\"isMapIterator\", v),\n"
+    "    isModuleNamespaceObject: (v) => env.typeProbe(\"isModuleNamespaceObject\", v),\n"
+    "    isNativeError: (v) => env.typeProbe(\"isNativeError\", v),\n"
+    "    isNumberObject: (v) => env.typeProbe(\"isNumberObject\", v),\n"
+    "    isPromise: (v) => env.typeProbe(\"isPromise\", v),\n"
+    "    isProxy: (v) => env.typeProbe(\"isProxy\", v),\n"
+    "    isRegExp: (v) => env.typeProbe(\"isRegExp\", v),\n"
+    "    isSet: (v) => env.typeProbe(\"isSet\", v),\n"
+    "    isSetIterator: (v) => env.typeProbe(\"isSetIterator\", v),\n"
+    "    isSharedArrayBuffer: (v) => env.typeProbe(\"isSharedArrayBuffer\", v),\n"
+    "    isStringObject: (v) => env.typeProbe(\"isStringObject\", v),\n"
+    "    isSymbolObject: (v) => env.typeProbe(\"isSymbolObject\", v),\n"
+    "    isTypedArray: (v) => env.typeProbe(\"isTypedArray\", v),\n"
+    "    isUint8Array: (v) => env.typeProbe(\"isUint8Array\", v),\n"
+    "    isUint8ClampedArray: (v) => env.typeProbe(\"isUint8ClampedArray\", v),\n"
+    "    isUint16Array: (v) => env.typeProbe(\"isUint16Array\", v),\n"
+    "    isUint32Array: (v) => env.typeProbe(\"isUint32Array\", v),\n"
+    "    isWeakMap: (v) => env.typeProbe(\"isWeakMap\", v),\n"
+    "    isWeakSet: (v) => env.typeProbe(\"isWeakSet\", v),\n"
     "  };\n"
-    "  const deepEquals = (a, b, memos) => {\n"
+    "  for (const [name, probe] of Object.entries(types)) {\n"
+    "    const wrapper = name === \"isTypedArray\" || /Array$/.test(name) && name !== \"isAnyArrayBuffer\" && name !== \"isArrayBuffer\";\n"
+    "    if (!wrapper && name !== \"isArrayBufferView\" && name !== \"isCryptoKey\" && name !== \"isKeyObject\") {\n"
+    "      Object.defineProperty(probe, \"name\", { value: \"\", configurable: true });\n"
+    "      Object.defineProperty(probe, \"length\", { value: 0, configurable: true });\n"
+    "    }\n"
+    "  }\n"
+    "  types.isArrayBufferView = ArrayBuffer.isView;\n"
+    "  Object.defineProperty(types.isCryptoKey, \"name\", { value: \"value\", configurable: true });\n"
+    "  Object.defineProperty(types.isKeyObject, \"name\", { value: \"value\", configurable: true });\n"
+    "  const deepConstructors = new Set([Array, ArrayBuffer, BigInt, Boolean, DataView, Date, Error, Function,\n"
+    "    Map, Number, Object, Promise, RegExp, Set, String, Symbol, WeakMap, WeakSet, Uint8Array,\n"
+    "    Uint8ClampedArray, Uint16Array, Uint32Array, Int8Array, Int16Array, Int32Array, Float32Array,\n"
+    "    Float64Array, BigInt64Array, BigUint64Array, Buffer]);\n"
+    "  if (typeof Float16Array !== \"undefined\") deepConstructors.add(Float16Array);\n"
+    "  const deepEquals = (a, b, skipPrototype, memos) => {\n"
     "    if (Object.is(a, b)) return true;\n"
-    "    const ta = typeof a;\n"
-    "    const tb = typeof b;\n"
-    "    if (ta !== tb) return false;\n"
-    "    if (ta === \"number\") return Number.isNaN(a) && Number.isNaN(b);\n"
-    "    if (ta !== \"object\" && ta !== \"function\") return false;\n"
-    "    if (a === null || b === null) return false;\n"
-    "    const tagA = tagOf(a);\n"
-    "    if (tagA !== tagOf(b)) return false;\n"
-    "    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;\n"
-    "    if (tagA === \"Date\") return Object.is(Date.prototype.getTime.call(a), Date.prototype.getTime.call(b));\n"
-    "    if (tagA === \"RegExp\") return String(a) === String(b);\n"
-    "    if (Array.isArray(a) && a.length !== b.length) return false;\n"
-    "    if (types.isTypedArray(a)) {\n"
-    "      if (a.length !== b.length) return false;\n"
-    "      if (tagA === \"Float32Array\" || tagA === \"Float64Array\" || tagA === \"Float16Array\") {\n"
-    "        for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;\n"
-    "      } else {\n"
-    "        for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n"
-    "      }\n"
-    "      return true;\n"
+    "    if (typeof a !== \"object\" || a === null || typeof b !== \"object\" || b === null) return false;\n"
+    "    if (!skipPrototype) {\n"
+    "      if (deepConstructors.has(a.constructor) ||\n"
+    "          (a.constructor !== undefined && !Object.prototype.hasOwnProperty.call(a, \"constructor\"))) {\n"
+    "        if (a.constructor !== b.constructor) return false;\n"
+    "      } else if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;\n"
+    "    }\n"
+    "    const array = Array.isArray(a);\n"
+    "    const view = ArrayBuffer.isView(a);\n"
+    "    const map = types.isMap(a);\n"
+    "    const set = types.isSet(a);\n"
+    "    const date = types.isDate(a);\n"
+    "    const regexp = types.isRegExp(a);\n"
+    "    const buffer = types.isAnyArrayBuffer(a);\n"
+    "    if (array !== Array.isArray(b) || view !== ArrayBuffer.isView(b) ||\n"
+    "        map !== types.isMap(b) || set !== types.isSet(b) || date !== types.isDate(b) ||\n"
+    "        regexp !== types.isRegExp(b) || buffer !== types.isAnyArrayBuffer(b)) return false;\n"
+    "    if (!view && tagOf(a) !== tagOf(b)) return false;\n"
+    "    if (array && a.length !== b.length) return false;\n"
+    "    if (view) {\n"
+    "      if (taTagGetter.call(a) !== taTagGetter.call(b) || a.byteLength !== b.byteLength) return false;\n"
+    "      const ua = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);\n"
+    "      const ub = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);\n"
+    "      for (let i = 0; i < ua.length; i++) if (ua[i] !== ub[i]) return false;\n"
     "    }\n"
-    "    if (tagA === \"ArrayBuffer\") {\n"
+    "    if (buffer) {\n"
+    "      if (a.byteLength !== b.byteLength) return false;\n"
     "      const ua = new Uint8Array(a);\n"
     "      const ub = new Uint8Array(b);\n"
-    "      if (ua.length !== ub.length) return false;\n"
     "      for (let i = 0; i < ua.length; i++) if (ua[i] !== ub[i]) return false;\n"
-    "      return true;\n"
     "    }\n"
-    "    if (a instanceof Error && (a.message !== b.message || a.name !== b.name)) return false;\n"
-    "    if (types.isBoxedPrimitive(a)) {\n"
-    "      return Object.is(\n"
-    "        (tagA === \"String\" ? String.prototype.valueOf : tagA === \"Number\" ? Number.prototype.valueOf\n"
-    "          : tagA === \"Boolean\" ? Boolean.prototype.valueOf : tagA === \"BigInt\" ? BigInt.prototype.valueOf\n"
-    "          : Symbol.prototype.valueOf).call(a),\n"
-    "        (tagA === \"String\" ? String.prototype.valueOf : tagA === \"Number\" ? Number.prototype.valueOf\n"
-    "          : tagA === \"Boolean\" ? Boolean.prototype.valueOf : tagA === \"BigInt\" ? BigInt.prototype.valueOf\n"
-    "          : Symbol.prototype.valueOf).call(b));\n"
-    "    }\n"
-    "    memos = memos || { a: new Map(), b: new Map(), position: 0 };\n"
-    "    const memoA = memos.a.get(a);\n"
-    "    if (memoA !== undefined) {\n"
-    "      const memoB = memos.b.get(b);\n"
-    "      if (memoB !== undefined) return memoA === memoB;\n"
-    "    }\n"
-    "    memos.position++;\n"
-    "    memos.a.set(a, memos.position);\n"
-    "    memos.b.set(b, memos.position);\n"
+    "    if (date && !Object.is(Date.prototype.getTime.call(a), Date.prototype.getTime.call(b))) return false;\n"
+    "    if (regexp && (a.source !== b.source || a.flags !== b.flags || a.lastIndex !== b.lastIndex)) return false;\n"
+    "    if (types.isPromise(a) || types.isPromise(b) || types.isWeakMap(a) || types.isWeakMap(b) ||\n"
+    "        types.isWeakSet(a) || types.isWeakSet(b)) return false;\n"
+    "    const boxed = types.isBoxedPrimitive(a);\n"
+    "    if (boxed !== types.isBoxedPrimitive(b)) return false;\n"
+    "    if (boxed) {\n"
+    "      const unbox = (v) => (types.isStringObject(v) ? String.prototype.valueOf :\n"
+    "        types.isNumberObject(v) ? Number.prototype.valueOf : types.isBooleanObject(v) ? Boolean.prototype.valueOf :\n"
+    "        types.isBigIntObject(v) ? BigInt.prototype.valueOf : Symbol.prototype.valueOf).call(v);\n"
+    "      if (!Object.is(unbox(a), unbox(b))) return false;\n"
+    "    }\n"
+    "    const error = a instanceof Error;\n"
+    "    if (error !== (b instanceof Error)) return false;\n"
+    "    if (typeof URL !== \"undefined\" && (a instanceof URL || b instanceof URL)) {\n"
+    "      if (!(a instanceof URL && b instanceof URL) || a.href !== b.href) return false;\n"
+    "    }\n"
+    "    const enumerable = (v, k) => Object.prototype.propertyIsEnumerable.call(v, k);\n"
+    "    // Typed view elements were compared by bytes. Object.is on float elements\n"
+    "    // would erase distinct NaN payloads that Node's strict comparison preserves.\n"
+    "    const keys = (v) => Reflect.ownKeys(v).filter((k) => enumerable(v, k) &&\n"
+    "      !((array || view) && typeof k === \"string\" && String(k >>> 0) === k && k !== \"4294967295\"));\n"
+    "    const keysA = keys(a);\n"
+    "    const keysB = keys(b);\n"
+    "    if (keysA.length !== keysB.length || keysA.some((k) => !enumerable(b, k))) return false;\n"
+    "    if (map || set) {\n"
+    "      if (a.size !== b.size) return false;\n"
+    "    }\n"
+    "    // Node 24's pair fast path for the first ancestor, then ancestor-set\n"
+    "    // matching at greater depth. Keep this state local to each traversal path.\n"
+    "    memos = memos || [];\n"
+    "    if (memos.length === 1) {\n"
+    "      if (memos[0][0] === a) return memos[0][1] === b;\n"
+    "      if (memos[0][1] === b) return false;\n"
+    "    } else if (memos.length > 1) {\n"
+    "      const seenA = memos.some((p) => p[0] === a || p[1] === a);\n"
+    "      const seenB = memos.some((p) => p[0] === b || p[1] === b);\n"
+    "      if (seenA || seenB) return seenA && seenB;\n"
+    "    }\n"
+    "    memos.push([a, b]);\n"
     "    try {\n"
-    "      if (tagA === \"Map\") {\n"
-    "        if (a.size !== b.size) return false;\n"
-    "        outer: for (const [k, v] of a) {\n"
-    "          if (b.has(k)) {\n"
-    "            if (deepEquals(v, b.get(k), memos)) continue;\n"
-    "          }\n"
-    "          for (const [k2, v2] of b) {\n"
-    "            if (deepEquals(k, k2, memos) && deepEquals(v, v2, memos)) continue outer;\n"
-    "          }\n"
-    "          return false;\n"
+    "      if (error) {\n"
+    "        for (const k of [\"name\", \"message\", \"cause\", \"errors\"]) {\n"
+    "          if (!enumerable(b, k) && !deepEquals(a[k], b[k], skipPrototype, memos)) return false;\n"
     "        }\n"
-    "        return true;\n"
-    "      }\n"
-    "      if (tagA === \"Set\") {\n"
-    "        if (a.size !== b.size) return false;\n"
-    "        outer2: for (const v of a) {\n"
-    "          if (b.has(v)) continue;\n"
-    "          for (const v2 of b) {\n"
-    "            if (deepEquals(v, v2, memos)) continue outer2;\n"
-    "          }\n"
-    "          return false;\n"
+    "        if (Object.prototype.hasOwnProperty.call(a, \"cause\") !== Object.prototype.hasOwnProperty.call(b, \"cause\")) return false;\n"
+    "      }\n"
+    "      let ordered = true;\n"
+    "      for (let i = 0; i < keysB.length; i++) {\n"
+    "        const k = keysB[i];\n"
+    "        ordered = ordered && keysA[i] === k;\n"
+    "        const descriptor = !ordered ? Object.getOwnPropertyDescriptor(a, k) : undefined;\n"
+    "        if (!ordered && (!descriptor || !descriptor.enumerable)) return false;\n"
+    "        const value = descriptor && descriptor.writable !== undefined ? descriptor.value : a[k];\n"
+    "        if (!deepEquals(value, b[k], skipPrototype, memos)) return false;\n"
+    "      }\n"
+    "      if (array) {\n"
+    "        for (let i = 0; i < a.length; i++) {\n"
+    "          if (b[i] === undefined) {\n"
+    "            if (!Object.prototype.hasOwnProperty.call(b, i)) {\n"
+    "              const indicesA = Object.keys(a);\n"
+    "              const indicesB = Object.keys(b);\n"
+    "              if (indicesA.length !== indicesB.length) return false;\n"
+    "              for (; i < indicesB.length; i++) {\n"
+    "                const k = indicesB[i];\n"
+    "                if ((a[k] === undefined && !Object.prototype.hasOwnProperty.call(a, k)) ||\n"
+    "                    !deepEquals(a[k], b[k], skipPrototype, memos)) return false;\n"
+    "              }\n"
+    "              return true;\n"
+    "            }\n"
+    "            if (a[i] !== undefined || !Object.prototype.hasOwnProperty.call(a, i)) return false;\n"
+    "          } else if (a[i] === undefined || !deepEquals(a[i], b[i], skipPrototype, memos)) return false;\n"
     "        }\n"
-    "        return true;\n"
-    "      }\n"
-    "      const keysA = Object.keys(a);\n"
-    "      const keysB = Object.keys(b);\n"
-    "      if (keysA.length !== keysB.length) return false;\n"
-    "      for (const k of keysA) {\n"
-    "        if (!Object.prototype.propertyIsEnumerable.call(b, k)) return false;\n"
-    "        if (!deepEquals(a[k], b[k], memos)) return false;\n"
     "      }\n"
-    "      const symsA = Object.getOwnPropertySymbols(a).filter((s) => Object.prototype.propertyIsEnumerable.call(a, s));\n"
-    "      const symsB = Object.getOwnPropertySymbols(b).filter((s) => Object.prototype.propertyIsEnumerable.call(b, s));\n"
-    "      if (symsA.length !== symsB.length) return false;\n"
-    "      for (const s of symsA) {\n"
-    "        if (!Object.prototype.propertyIsEnumerable.call(b, s)) return false;\n"
-    "        if (!deepEquals(a[s], b[s], memos)) return false;\n"
+    "      if (map || set) {\n"
+    "        const remaining = map ? Array.from(b.entries()) : Array.from(b.values());\n"
+    "        for (const item of a) {\n"
+    "          const index = remaining.findIndex((other) => map\n"
+    "            ? deepEquals(item[0], other[0], skipPrototype, memos) && deepEquals(item[1], other[1], skipPrototype, memos)\n"
+    "            : deepEquals(item, other, skipPrototype, memos));\n"
+    "          if (index === -1) return false;\n"
+    "          remaining.splice(index, 1);\n"
+    "        }\n"
     "      }\n"
     "      return true;\n"
     "    } finally {\n"
-    "      memos.a.delete(a);\n"
-    "      memos.b.delete(b);\n"
+    "      memos.pop();\n"
     "    }\n"
     "  };\n"
-    "  const isDeepStrictEqual = (a, b) => deepEquals(a, b, undefined);\n"
-    "  const ansiRe = /[\\u001b›][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\\\#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\\\#&.:=?%@~_]*)*)?(?:|\\u001b\\|œ))|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))/g;\n"
+    "  const isDeepStrictEqual = (a, b, skipPrototype) => deepEquals(a, b, !!skipPrototype, undefined);\n"
+    "  const ansiRe = /[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))/g;\n"
     "  const stripVTControlCharacters = (str) => {\n"
-    "    if (typeof str !== \"string\") {\n"
-    "      const e = new TypeError('The \"str\" argument must be of type string. Received ' + (str === null ? \"null\" : typeof str === \"object\" ? \"an instance of Object\" : typeof str === \"undefined\" ? \"undefined\" : \"type \" + typeof str));\n"
-    "      e.code = \"ERR_INVALID_ARG_TYPE\";\n"
-    "      throw e;\n"
-    "    }\n"
+    "    if (typeof str !== \"string\") envArgumentError(\"str\", \"of type string\", str);\n"
     "    return str.replace(ansiRe, \"\");\n"
     "  };\n"
-    "  const styleText = (fmt, text, options) => {\n"
-    "    if (typeof text !== \"string\") {\n"
-    "      const e = new TypeError('The \"text\" argument must be of type string. Received ' + (text === null ? \"null\" : typeof text === \"object\" ? \"an instance of Object\" : typeof text === \"undefined\" ? \"undefined\" : \"type \" + typeof text));\n"
-    "      e.code = \"ERR_INVALID_ARG_TYPE\";\n"
-    "      throw e;\n"
-    "    }\n"
-    "    const stream = options !== undefined && options !== null && options.stream !== undefined\n"
-    "      ? options.stream : env.stdout;\n"
-    "    let colorize = !!(stream && stream.isTTY);\n"
-    "    if (env.env.NO_COLOR !== undefined || env.env.NODE_DISABLE_COLORS !== undefined) colorize = false;\n"
-    "    if (env.env.FORCE_COLOR !== undefined && env.env.FORCE_COLOR !== \"0\") colorize = true;\n"
-    "    const formats = Array.isArray(fmt) ? fmt : [fmt];\n"
-    "    let left = \"\";\n"
-    "    let right = \"\";\n"
-    "    for (const f of formats) {\n"
-    "      const pair = inspect.colors[f];\n"
-    "      if (pair === undefined) {\n"
-    "        const e = new TypeError(\"The value \\\"\" + String(f) + \"\\\" is invalid for argument 'format'. Reason: must be one of: \" + Object.keys(inspect.colors).join(\", \"));\n"
-    "        e.code = \"ERR_INVALID_ARG_VALUE\";\n"
-    "        throw e;\n"
+    "  const styleAliases = { grey: 'gray', blackBright: 'gray', bgGrey: 'bgGray', bgBlackBright: 'bgGray', faint: 'dim', crossedout: 'strikethrough', strikeThrough: 'strikethrough', crossedOut: 'strikethrough', conceal: 'hidden', swapColors: 'inverse', swapcolors: 'inverse', doubleUnderline: 'doubleunderline' };\n"
+    "  for (const [name, target] of Object.entries(styleAliases)) Object.defineProperty(inspect.colors, name, {\n"
+    "    configurable: true, get: () => inspect.colors[target], set: (value) => { inspect.colors[target] = value; },\n"
+    "  });\n"
+    "  let styleCache;\n"
+    "  const getStyleCache = () => {\n"
+    "    if (styleCache === undefined) {\n"
+    "      styleCache = Object.create(null);\n"
+    "      for (const key of Object.getOwnPropertyNames(inspect.colors)) {\n"
+    "        const pair = inspect.colors[key];\n"
+    "        if (!pair) continue;\n"
+    "        styleCache[key] = { open: '\\u001b[' + pair[0] + 'm', close: '\\u001b[' + pair[1] + 'm', keepClose: pair[0] === 1 || pair[0] === 2 };\n"
     "      }\n"
-    "      left += \"\\u001b[\" + pair[0] + \"m\";\n"
-    "      right = \"\\u001b[\" + pair[1] + \"m\" + right;\n"
     "    }\n"
-    "    return colorize ? left + text + right : text;\n"
+    "    return styleCache;\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 replaceCloseCode = (text, style) => {\n"
+    "    let at = 0, index = text.indexOf(style.close), result = '';\n"
+    "    while (index !== -1 && index + style.close.length < text.length) {\n"
+    "      result += text.slice(at, index) + (style.keepClose ? style.close : '') + style.open;\n"
+    "      at = index + style.close.length;\n"
+    "      index = text.indexOf(style.close, at);\n"
+    "    }\n"
+    "    return result + text.slice(at);\n"
+    "  };\n"
+    "  let warnedColors = false;\n"
+    "  const terminalColors = () => {\n"
+    "    const e = env.env, force = e.FORCE_COLOR;\n"
+    "    if (force !== undefined) {\n"
+    "      const enabled = ['', '1', '2', '3', 'true'].includes(force);\n"
+    "      const disabled = e.NO_COLOR ? 'NO_COLOR' : e.NODE_DISABLE_COLORS ? 'NODE_DISABLE_COLORS' : undefined;\n"
+    "      if (enabled && disabled && !warnedColors) {\n"
+    "        env.emitWarning(\"The '\" + disabled + \"' env is ignored due to the 'FORCE_COLOR' env being set.\", 'Warning');\n"
+    "        warnedColors = true;\n"
+    "      }\n"
+    "      return enabled;\n"
+    "    }\n"
+    "    if (e.NO_COLOR || e.NODE_DISABLE_COLORS || e.TERM === 'dumb') return false;\n"
+    "    if (env.platform === 'win32' || e.TMUX || e.TF_BUILD !== undefined && e.AGENT_NAME !== undefined) return true;\n"
+    "    if (e.CI !== undefined) return ['APPVEYOR', 'BUILDKITE', 'CIRCLECI', 'DRONE', 'GITEA_ACTIONS', 'GITHUB_ACTIONS', 'GITLAB_CI', 'TRAVIS'].some((name) => e[name] !== undefined) || e.CI_NAME === 'codeship';\n"
+    "    if (e.TEAMCITY_VERSION !== undefined) return /^(9\\.(0*[1-9]\\d*)\\.|\\d{2,}\\.)/.test(e.TEAMCITY_VERSION);\n"
+    "    if (['iTerm.app', 'HyperTerm', 'MacTerm', 'Apple_Terminal'].includes(e.TERM_PROGRAM)) return true;\n"
+    "    if (e.COLORTERM === 'truecolor' || e.COLORTERM === '24bit') return true;\n"
+    "    if (e.TERM) {\n"
+    "      if (e.TERM.includes('truecolor') || e.TERM.startsWith('xterm-256')) return true;\n"
+    "      const term = e.TERM.toLowerCase();\n"
+    "      if (['eterm', 'cons25', 'console', 'cygwin', 'dtterm', 'gnome', 'hurd', 'jfbterm', 'konsole', 'kterm', 'mlterm', 'mosh', 'putty', 'st', 'rxvt-unicode-24bit', 'terminator', 'xterm-kitty'].includes(term) || /ansi|color|linux|direct|^con[0-9]*x[0-9]|^rxvt|^screen|^xterm|^vt100|^vt220/.test(term)) return true;\n"
+    "    }\n"
+    "    return !!e.COLORTERM;\n"
+    "  };\n"
+    "  const styleText = (format, text, options) => {\n"
+    "    const validateStream = options?.validateStream ?? true;\n"
+    "    const cache = getStyleCache();\n"
+    "    if (!validateStream && typeof format === 'string' && typeof text === 'string') {\n"
+    "      if (format === 'none') return text;\n"
+    "      const style = cache[format];\n"
+    "      if (style !== undefined) return style.open + replaceCloseCode(text, style) + style.close;\n"
+    "    }\n"
+    "    if (typeof text !== 'string') envArgumentError('text', 'of type string', text);\n"
+    "    if (options !== undefined && (options === null || typeof options !== 'object' || Array.isArray(options))) envArgumentError('options', 'of type object', options);\n"
+    "    if (typeof validateStream !== 'boolean') envArgumentError('options.validateStream', 'of type boolean', validateStream);\n"
+    "    let skipColorize = false;\n"
+    "    if (validateStream) {\n"
+    "      const stream = options?.stream ?? env.stdout;\n"
+    "      const node = stream && (stream._readableState || stream._writableState || typeof stream.write === 'function' && typeof stream.on === 'function' || typeof stream.pipe === 'function' && typeof stream.on === 'function');\n"
+    "      const readable = stream && !node && typeof stream.pipeThrough === 'function' && typeof stream.getReader === 'function' && typeof stream.cancel === 'function';\n"
+    "      const writable = stream && !node && typeof stream.getWriter === 'function' && typeof stream.abort === 'function';\n"
+    "      if (!node && !readable && !writable) envArgumentError('stream', 'an instance of ReadableStream, WritableStream, or Stream', stream);\n"
+    "      let colorize;\n"
+    "      if (env.env.FORCE_COLOR !== undefined) colorize = terminalColors();\n"
+    "      else colorize = stream?.isTTY && (typeof stream.getColorDepth === 'function' ? stream.getColorDepth() > 2 : stream === env.stdout || stream === env.stderr || stream === env.stdin ? terminalColors() : true);\n"
+    "      skipColorize = !colorize;\n"
+    "    }\n"
+    "    const formats = Array.isArray(format) ? format : [format];\n"
+    "    let open = '', close = '', processed = text;\n"
+    "    for (const key of formats) {\n"
+    "      if (key === 'none') continue;\n"
+    "      const style = cache[key];\n"
+    "      if (style === undefined && !Object.getOwnPropertyNames(inspect.colors).includes(key)) {\n"
+    "        const error = new TypeError(\"The argument 'format' must be one of: \" + Object.getOwnPropertyNames(inspect.colors).map((name) => \"'\" + name + \"'\").join(', ') + '. Received ' + inspect(key));\n"
+    "        error.code = 'ERR_INVALID_ARG_VALUE';\n"
+    "        throw error;\n"
+    "      }\n"
+    "      open += style.open; close = style.close + close;\n"
+    "      processed = replaceCloseCode(processed, style);\n"
+    "    }\n"
+    "    return skipColorize ? text : open + processed + close;\n"
+    "  };\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"
+    "  const toUSVString = (s) => {\n"
+    "    let primitive = s;\n"
+    "    const isObject = (v) => v !== null && (typeof v === 'object' || typeof v === 'function');\n"
+    "    if (isObject(s)) {\n"
+    "      const exotic = s[Symbol.toPrimitive];\n"
+    "      if (exotic !== undefined && exotic !== null) {\n"
+    "        if (typeof exotic !== 'function') {\n"
+    "          const kind = typeof exotic;\n"
+    "          const label = ['object', 'symbol', 'bigint'].includes(kind) ? kind : kind + ' ' + (kind === 'string' ? '\"' + exotic + '\"' : String(exotic));\n"
+    "          throw new TypeError(label + ' is not a function');\n"
+    "        }\n"
+    "        primitive = Reflect.apply(exotic, s, ['string']);\n"
+    "        if (isObject(primitive)) throw new TypeError('Cannot convert object to primitive value');\n"
+    "      } else {\n"
+    "        let converted = false;\n"
+    "        for (const name of ['toString', 'valueOf']) {\n"
+    "          const method = s[name];\n"
+    "          if (typeof method !== 'function') continue;\n"
+    "          primitive = Reflect.apply(method, s, []);\n"
+    "          if (!isObject(primitive)) { converted = true; break; }\n"
+    "        }\n"
+    "        if (!converted) throw new TypeError('Cannot convert object to primitive value');\n"
+    "      }\n"
+    "    }\n"
+    "    if (typeof primitive === 'symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n"
+    "    return `${primitive}`.replace(/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/g, \"�\");\n"
+    "  };\n"
     "  const _extend = (target, source) => {\n"
     "    if (source === null || typeof source !== \"object\") return target;\n"
     "    for (const k of Object.keys(source)) target[k] = source[k];\n"
     "    return target;\n"
     "  };\n"
+    "  // Node 24's MIME API uses HTTP whitespace and token grammar, not Unicode trimming.\n"
+    "  const mimeInvalidToken = /[^!#$%&'*+\\-.^_`|~A-Za-z0-9]/;\n"
+    "  const mimeInvalidValue = /[^\\t\\u0020-\\u007e\\u0080-\\u00ff]/;\n"
+    "  const mimeLeadingWhitespace = /^[\\r\\n\\t ]*/;\n"
+    "  const mimeTrailingWhitespace = /[\\r\\n\\t ]*$/;\n"
+    "  const mimeLower = (s) => s.replace(/[A-Z]/g, (c) => c.toLowerCase());\n"
+    "  const mimeError = (production, input, index) => {\n"
+    "    const error = new TypeError('The MIME syntax for a ' + production + ' in \"' + input + '\" is invalid' + (index === -1 ? '' : ' at ' + index));\n"
+    "    error.code = 'ERR_INVALID_MIME_SYNTAX';\n"
+    "    throw error;\n"
+    "  };\n"
+    "  const mimeValidateToken = (value, production, input = value) => {\n"
+    "    const index = value.search(mimeInvalidToken);\n"
+    "    if (!value.length || index !== -1) mimeError(production, input, index);\n"
+    "  };\n"
+    "  const mimeEncode = (value) => {\n"
+    "    if (value.length && value.search(mimeInvalidToken) === -1) return value;\n"
+    "    return '\"' + value.replace(/[\"\\\\]/g, (c) => '\\\\' + c) + '\"';\n"
+    "  };\n"
+    "  let mimeParamsFromSource;\n"
+    "  class MIMEParams {\n"
+    "    #data = new Map();\n"
+    "    #source = null;\n"
+    "    static {\n"
+    "      mimeParamsFromSource = (source) => {\n"
+    "        const params = new MIMEParams();\n"
+    "        params.#source = source;\n"
+    "        return params;\n"
+    "      };\n"
+    "    }\n"
+    "    #parse() {\n"
+    "      if (this.#source === null) return;\n"
+    "      const source = this.#source;\n"
+    "      const end = source.search(mimeTrailingWhitespace);\n"
+    "      let pos = 0;\n"
+    "      while (pos < end) {\n"
+    "        pos += source.slice(pos).match(mimeLeadingWhitespace)[0].length;\n"
+    "        const start = pos;\n"
+    "        while (pos < source.length && source[pos] !== ';' && source[pos] !== '=') pos++;\n"
+    "        const name = mimeLower(source.slice(start, pos));\n"
+    "        if (pos < end && source[pos++] === ';') continue;\n"
+    "        if (pos >= end) break;\n"
+    "        let value = '';\n"
+    "        if (source[pos] === '\"') {\n"
+    "          pos++;\n"
+    "          // Quoted values accept escaped characters and a missing closing quote.\n"
+    "          while (pos < source.length) {\n"
+    "            const char = source[pos++];\n"
+    "            if (char === '\"') break;\n"
+    "            value += char === '\\\\' && pos < source.length ? source[pos++] : char;\n"
+    "          }\n"
+    "        } else {\n"
+    "          const startValue = pos;\n"
+    "          while (pos < source.length && source[pos] !== ';') pos++;\n"
+    "          value = source.slice(startValue, pos).replace(mimeTrailingWhitespace, '');\n"
+    "          if (!value.length) continue;\n"
+    "        }\n"
+    "        // Parsing ignores invalid parameters and keeps the first duplicate.\n"
+    "        if (name.length && name.search(mimeInvalidToken) === -1 &&\n"
+    "            value.search(mimeInvalidValue) === -1 && !this.#data.has(name)) {\n"
+    "          this.#data.set(name, value);\n"
+    "        }\n"
+    "        pos++;\n"
+    "      }\n"
+    "      this.#source = null;\n"
+    "    }\n"
+    "    delete(name) { this.#parse(); this.#data.delete(name); }\n"
+    "    get(name) { this.#parse(); return this.#data.has(name) ? this.#data.get(name) : null; }\n"
+    "    has(name) { this.#parse(); return this.#data.has(name); }\n"
+    "    set(name, value) {\n"
+    "      this.#parse();\n"
+    "      name = `${name}`;\n"
+    "      value = `${value}`;\n"
+    "      mimeValidateToken(name, 'parameter name');\n"
+    "      const index = value.search(mimeInvalidValue);\n"
+    "      if (index !== -1) mimeError('parameter value', value, index);\n"
+    "      this.#data.set(name, value);\n"
+    "    }\n"
+    "    *entries() { this.#parse(); yield* this.#data.entries(); }\n"
+    "    *keys() { this.#parse(); yield* this.#data.keys(); }\n"
+    "    *values() { this.#parse(); yield* this.#data.values(); }\n"
+    "    toString() {\n"
+    "      this.#parse();\n"
+    "      let result = '';\n"
+    "      for (const [name, value] of this.#data) {\n"
+    "        if (result.length) result += ';';\n"
+    "        result += name + '=' + mimeEncode(value);\n"
+    "      }\n"
+    "      return result;\n"
+    "    }\n"
+    "  }\n"
+    "  const mimeParamsStringify = MIMEParams.prototype.toString;\n"
+    "  Object.defineProperty(MIMEParams.prototype, Symbol.iterator, {\n"
+    "    value: MIMEParams.prototype.entries, writable: true, configurable: true,\n"
+    "  });\n"
+    "  Object.defineProperty(MIMEParams.prototype, 'toJSON', {\n"
+    "    value: mimeParamsStringify, writable: true, configurable: true,\n"
+    "  });\n"
+    "  class MIMEType {\n"
+    "    #type;\n"
+    "    #subtype;\n"
+    "    #params;\n"
+    "    constructor(input) {\n"
+    "      input = `${input}`;\n"
+    "      const start = input.match(mimeLeadingWhitespace)[0].length;\n"
+    "      const slash = input.indexOf('/', start);\n"
+    "      const type = input.slice(start, slash === -1 ? input.length : slash);\n"
+    "      mimeValidateToken(type, 'type', input);\n"
+    "      if (slash === -1) mimeError('type', input, -1);\n"
+    "      const semicolon = input.indexOf(';', slash + 1);\n"
+    "      const subtype = input.slice(slash + 1, semicolon === -1 ? input.length : semicolon).replace(mimeTrailingWhitespace, '');\n"
+    "      mimeValidateToken(subtype, 'subtype', input);\n"
+    "      this.#type = mimeLower(type);\n"
+    "      this.#subtype = mimeLower(subtype);\n"
+    "      this.#params = mimeParamsFromSource(semicolon === -1 ? '' : input.slice(semicolon + 1));\n"
+    "    }\n"
+    "    get type() { return this.#type; }\n"
+    "    set type(value) {\n"
+    "      value = `${value}`;\n"
+    "      mimeValidateToken(value, 'type');\n"
+    "      this.#type = mimeLower(value);\n"
+    "    }\n"
+    "    get subtype() { return this.#subtype; }\n"
+    "    set subtype(value) {\n"
+    "      value = `${value}`;\n"
+    "      mimeValidateToken(value, 'subtype');\n"
+    "      this.#subtype = mimeLower(value);\n"
+    "    }\n"
+    "    get essence() { return this.#type + '/' + this.#subtype; }\n"
+    "    get params() { return this.#params; }\n"
+    "    toString() {\n"
+    "      // Capture the serializer so user overrides cannot change MIME serialization.\n"
+    "      const params = mimeParamsStringify.call(this.#params);\n"
+    "      return this.#type + '/' + this.#subtype + (params.length ? ';' + params : '');\n"
+    "    }\n"
+    "  }\n"
+    "  Object.defineProperty(MIMEType.prototype, 'toJSON', {\n"
+    "    value: MIMEType.prototype.toString, writable: true, configurable: true,\n"
+    "  });\n"
     "  const util = {\n"
+    "    getSystemErrorMap: () => new Map(host.systemErrorEntries()),\n"
+    "    getSystemErrorName: (err) => {\n"
+    "      if (typeof err !== 'number') envArgumentError('err', 'of type number', err);\n"
+    "      return host.systemErrorInfo(err, false);\n"
+    "    },\n"
+    "    getSystemErrorMessage: (err) => {\n"
+    "      if (typeof err !== 'number') envArgumentError('err', 'of type number', err);\n"
+    "      return host.systemErrorInfo(err, true);\n"
+    "    },\n"
     "    format, formatWithOptions, inspect, inherits, promisify, callbackify,\n"
     "    deprecate, debuglog, debug: debuglog, types, isDeepStrictEqual,\n"
-    "    stripVTControlCharacters, styleText, parseArgs, toUSVString, _extend,\n"
+    "    stripVTControlCharacters, styleText, parseArgs, toUSVString, _extend, MIMEType, MIMEParams,\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"
     "  return util;\n"
     "}\n"
     "    const util = makeUtil({\n"
+    "      typeProbe: host.typeProbe,\n"
     "      promiseState: (p) => host.promiseState(p),\n"
     "      writeErr: (s) => host.write(2, s),\n"
     "      env: builtins.process().env,\n"
@@ -8040,7 +9287,6 @@ static const char isl_modules_bootstrap[] =
      * same object; require('util/types') === require('util').types). */
     "  builtins['util/types'] = memo(() => {\n"
     "    const t = builtins.util().types;\n"
-    "    t.default = t;\n"
     "    return t;\n"
     "  });\n"
     "  builtins.child_process = memo(() => {\n"
@@ -8791,9 +10037,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"
@@ -8807,30 +10052,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"
@@ -9224,9 +10533,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"
@@ -9337,15 +10691,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"
@@ -9363,7 +10711,8 @@ static const char isl_modules_bootstrap[] =
     "    const spec = String(raw);\n"
     "    const bare = spec.startsWith('node:') ? spec.slice(5) : spec;\n"
     "    if (builtinModules.includes(bare) && (spec.startsWith('node:') || bare !== 'test')) return 'node:' + bare;\n"
-    "    const base = from.startsWith('/') ? new URL('file://' + from).href : from;\n"
+    "    const filePath = (s) => s.startsWith('/') || /^[A-Za-z]:[\\\\/]/.test(s) || s.startsWith('\\\\\\\\');\n"
+    "    const base = filePath(from) ? host.urlFromPath(from) : from;\n"
     "    if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(spec) || spec.startsWith('./') || spec.startsWith('../') || spec.startsWith('/')) {\n"
     "      return new URL(spec, base).href;\n"
     "    }\n"
@@ -9373,7 +10722,7 @@ static const char isl_modules_bootstrap[] =
     "      err.code = 'ERR_MODULE_NOT_FOUND';\n"
     "      throw err;\n"
     "    }\n"
-    "    return to.startsWith('/') ? new URL('file://' + to).href : to;\n"
+    "    return filePath(to) ? host.urlFromPath(to) : to;\n"
     "  };\n"
     "  return (key, name) => {\n"
     "    const exports = requireKey(key);\n"
@@ -9405,11 +10754,21 @@ static void isl_modules_boot(void) {
     abort();
   }
   JSValue host = JS_NewObject(isl_ctx);
+  JS_SetPropertyStr(isl_ctx, host, "typeProbe", JS_NewCFunction(isl_ctx, isl_host_type_probe, "typeProbe", 2));
   /* JS_SetPropertyStr consumes the function values. */
   JS_SetPropertyStr(isl_ctx, host, "source", JS_NewCFunction(isl_ctx, isl_host_source, "source", 1));
   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, "systemErrorEntries", JS_NewCFunction(isl_ctx, isl_host_system_error_entries, "systemErrorEntries", 0));
+  JS_SetPropertyStr(isl_ctx, host, "systemErrorInfo", JS_NewCFunction(isl_ctx, isl_host_system_error_info, "systemErrorInfo", 2));
+  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));
@@ -9428,11 +10787,13 @@ 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));
-  JS_SetPropertyStr(isl_ctx, host, "urlToPath", JS_NewCFunction(isl_ctx, isl_host_url_to_path, "urlToPath", 1));
-  JS_SetPropertyStr(isl_ctx, host, "urlFromPath", JS_NewCFunction(isl_ctx, isl_host_url_from_path, "urlFromPath", 1));
+  JS_SetPropertyStr(isl_ctx, host, "urlToPath", JS_NewCFunction(isl_ctx, isl_host_url_to_path, "urlToPath", 2));
+  JS_SetPropertyStr(isl_ctx, host, "urlToPathBuffer", JS_NewCFunction(isl_ctx, isl_host_url_to_path_buffer, "urlToPathBuffer", 2));
+  JS_SetPropertyStr(isl_ctx, host, "urlFromPath", JS_NewCFunction(isl_ctx, isl_host_url_from_path, "urlFromPath", 2));
   JS_SetPropertyStr(isl_ctx, host, "hrtime", JS_NewCFunction(isl_ctx, isl_host_hrtime, "hrtime", 0));
   JS_SetPropertyStr(isl_ctx, host, "versions", JS_NewCFunction(isl_ctx, isl_host_versions, "versions", 0));
   JS_SetPropertyStr(isl_ctx, host, "ids", JS_NewCFunction(isl_ctx, isl_host_ids, "ids", 0));
@@ -9809,30 +11170,22 @@ ScrJsval *scr_jsval_from_bytes(const ScrBytes *b) {
  * installs a minimal class: construction re-parses through the SAME
  * WHATWG parser the static URL uses (scr_url.c, via a host function), so
  * a marshaled URL and `new URL(href)` in embedded code agree exactly.
- * href/protocol/pathname are the components the native accessors expose;
- * the other component reads and ALL component writes throw a clear
- * TypeError instead of silently diverging from the live re-serializing
- * accessors a real URL has (SEMANTICS.md). If a URL global already exists
+ * Component reads and writes share the native parser and setter
+ * state overrides. If a URL global already exists
  * (a future web-prelude one, or embedded code's own), it wins — the
  * marshal constructs through whatever globalThis.URL is. */
-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);
-  scr_str_release(in);
-  if (!u) return isl_throw_pending(ctx); /* the parser's catchable TypeError */
+static JSValue isl_url_components(JSContext *ctx, ScrUrl *u) {
   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));
@@ -9841,123 +11194,147 @@ 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;
 }
 
+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");
+  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);
+  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);
+  }
+  return isl_url_components(ctx, u);
+}
+
+static JSValue isl_url_set_host(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv) {
+  (void)this_val;
+  if (argc < 3) return JS_ThrowTypeError(ctx, "Invalid URL");
+  ScrStr *href = isl_arg_str(ctx, argv[0]);
+  if (!href) return JS_EXCEPTION;
+  ScrStr *field = isl_arg_str(ctx, argv[1]);
+  if (!field) { scr_str_release(href); return JS_EXCEPTION; }
+  ScrStr *value = isl_arg_str(ctx, argv[2]);
+  if (!value) { scr_str_release(href); scr_str_release(field); return JS_EXCEPTION; }
+  ScrUrl *u = scr_url_new(href);
+  scr_str_release(href);
+  bool applied = u && scr_url_set_component(u, field, value);
+  scr_str_release(field);
+  scr_str_release(value);
+  if (!u || scr_exc_pending()) {
+    scr_url_release(u);
+    return isl_throw_pending(ctx);
+  }
+  if (!applied) { scr_url_release(u); return JS_NULL; }
+  return isl_url_components(ctx, u);
+}
+
 static const char isl_url_src[] =
-    "(function (parse) {\n"
+    "(function (parse, mutate) {\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"
+    "  const fields = ['href', 'protocol', 'pathname', 'host', 'hostname', 'search', 'origin', 'username', 'password', 'hash', 'port'];\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"
-    /* 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
-     * recomposes href around the old query, and the searchParams getter
-     * hands out ONE URLSearchParams whose mutators write back through
-     * it. The other components stay parse-time snapshots. */
-    "      Object.defineProperty(this, '_href', { value: c[0], writable: true });\n"
-    "      Object.defineProperty(this, '_search', { value: c[5], writable: true });\n"
-    "      const self = this;\n"
-    "      Object.defineProperty(this, 'href', { enumerable: true, get: () => self._href });\n"
-    "      Object.defineProperty(this, 'search', {\n"
-    "        enumerable: true,\n"
-    "        get: () => self._search,\n"
-    "        set: (v) => {\n"
-    "          self._applySearch(String(v));\n"
-    "          if (self._sp !== undefined) {\n"
-    "            self._sp._pairs.length = 0;\n"
-    "            for (const [k, val] of new globalThis.URLSearchParams(self._search)) self._sp._pairs.push([k, val]);\n"
-    "          }\n"
-    "        },\n"
-    "      });\n"
-    "      def(this, 'protocol', c[1]);\n"
-    "      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"
-    "    }\n"
-    /* The search half of the live coupling: normalize the assigned
-     * query, splice it into href between the pre-query part and the
-     * fragment. */
-    "    _applySearch(v) {\n"
-    "      let s = String(v);\n"
-    "      if (s !== '' && !s.startsWith('?')) s = '?' + s;\n"
-    "      if (s === '?') s = '';\n"
-    "      const base = this._href.split('#')[0].split('?')[0];\n"
-    "      this._search = s;\n"
-    "      this._href = base + s + this.hash;\n"
-    "    }\n"
-    /* searchParams: ONE URLSearchParams per URL (identity stable, like
-     * the spec) whose mutators — append/set/delete/sort — write the
-     * serialized list back into search/href. Reads AND writes agree with
-     * Node for the query component; the other components stay parse-time
-     * snapshots. */
+    "      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"
+    "      Object.defineProperty(this, '_components', { value: c, writable: true });\n"
+    "      for (let i = 0; i < fields.length; i++) {\n"
+    "        const name = fields[i];\n"
+    "        const descriptor = { enumerable: true, get: () => this._components[i] };\n"
+    "        if (name !== 'origin') descriptor.set = (v) => this._set(name, v);\n"
+    "        Object.defineProperty(this, name, descriptor);\n"
+    "      }\n"
+    "    }\n"
+    "    _set(name, value) {\n"
+    "      const href = this.href;\n"
+    "      const ignored = name === 'pathname' && !href.slice(this.protocol.length).startsWith('/');\n"
+    "      const converted = text(value);\n"
+    "      if (ignored) return;\n"
+    "      const components = mutate(name === 'href' ? this.href : href, name, converted);\n"
+    "      if (components === null) return;\n"
+    "      this._components = components;\n"
+    "      if ((name === 'search' || name === 'href') && this._sp !== undefined) {\n"
+    "        this._sp._pairs.length = 0;\n"
+    "        for (const [k, v] of new globalThis.URLSearchParams(this.search)) this._sp._pairs.push([k, v]);\n"
+    "      }\n"
+    "    }\n"
     "    get searchParams() {\n"
     "      if (this._sp === undefined) {\n"
     "        const sp = new globalThis.URLSearchParams(this.search);\n"
     "        const sync = () => {\n"
     "          const q = sp.toString();\n"
-    "          this._applySearch(q === '' ? '' : '?' + q);\n"
+    "          this._set('search', q === '' ? '' : '?' + q);\n"
     "        };\n"
     "        for (const m of ['append', 'set', 'delete', 'sort']) {\n"
     "          const orig = sp[m].bind(sp);\n"
-    "          Object.defineProperty(sp, m, {\n"
-    "            value: (...args) => { const r = orig(...args); sync(); return r; },\n"
-    "          });\n"
+    "          Object.defineProperty(sp, m, { value: (...args) => { const r = orig(...args); sync(); return r; } });\n"
     "        }\n"
     "        Object.defineProperty(this, '_sp', { value: sp });\n"
     "      }\n"
     "      return this._sp;\n"
     "    }\n"
+    "    get href() { throw new TypeError('Receiver must be an instance of class URL'); }\n"
     "    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"
@@ -9976,8 +11353,11 @@ 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 r = JS_Call(isl_ctx, installer, JS_UNDEFINED, 1, &parse);
+    JSValue parse = JS_NewCFunction(isl_ctx, isl_url_parse_host, "__scr_url_parse", 3);
+    JSValue mutate = JS_NewCFunction(isl_ctx, isl_url_set_host, "__scr_url_set", 3);
+    JSValue args[2] = {parse, mutate};
+    JSValue r = JS_Call(isl_ctx, installer, JS_UNDEFINED, 2, args);
+    JS_FreeValue(isl_ctx, mutate);
     JS_FreeValue(isl_ctx, parse);
     JS_FreeValue(isl_ctx, installer);
     if (JS_IsException(r)) {