@scriptc/cli-darwin-arm64 0.2.2 → 0.2.4

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);
@@ -2903,6 +3025,29 @@ static JSValue isl_host_env_delete(JSContext *ctx, JSValueConst this_val, int ar
   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;
@@ -3311,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
@@ -3686,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
@@ -3756,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
@@ -3778,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"
@@ -3813,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"
@@ -3832,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"
@@ -4895,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"
@@ -4950,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
@@ -4978,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"
@@ -5044,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"
@@ -7210,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"
@@ -7395,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"
@@ -7463,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"
@@ -7503,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"
@@ -7584,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"
@@ -7599,13 +7946,17 @@ static const char isl_modules_bootstrap[] =
      * isDeepStrictEqual, stripVTControlCharacters, styleText,
      * parseArgs, toUSVString). The host supplies what JS cannot see:
      * promise state (JS_PromiseState), the pid, and fd writes. */
-    "  const envArgumentError = (name, expected, value) => {\n"
+    "  const 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"
@@ -8315,230 +8666,283 @@ 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"
-    "  };\n"
-    "  const deepEquals = (a, b, memos) => {\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"
+    "  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"
+    "    }\n"
+    "    return styleCache;\n"
+    "  };\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"
-    "      left += \"\\u001b[\" + pair[0] + \"m\";\n"
-    "      right = \"\\u001b[\" + pair[1] + \"m\" + right;\n"
+    "      open += style.open; close = style.close + close;\n"
+    "      processed = replaceCloseCode(processed, style);\n"
     "    }\n"
-    "    return colorize ? left + text + right : text;\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"
@@ -8674,16 +9078,190 @@ static const char isl_modules_bootstrap[] =
     "    }\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"
@@ -8694,6 +9272,7 @@ static const char isl_modules_bootstrap[] =
     "  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"
@@ -8708,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"
@@ -10133,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"
@@ -10143,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"
@@ -10175,6 +10754,7 @@ 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));
@@ -10185,6 +10765,8 @@ static void isl_modules_boot(void) {
   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));
@@ -10209,8 +10791,9 @@ static void isl_modules_boot(void) {
   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));
@@ -10587,33 +11170,11 @@ 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");
-  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);
-  }
+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);
@@ -10652,14 +11213,61 @@ static JSValue isl_url_parse_host(JSContext *ctx, JSValueConst this_val,
   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"
     "    constructor(input, base) {\n"
     "      if (arguments.length === 0) throw URL._missing();\n"
@@ -10673,70 +11281,43 @@ static const char isl_url_src[] =
     "      return error;\n"
     "    }\n"
     "    _init(c) {\n"
-    /* href and search are LIVE-COUPLED (the one WHATWG mutation loop the
-     * a real CLI's API client drives: url.searchParams.set('teamId', …)
-     * then fetch(url)): both live in writable slots, the search setter
-     * 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, 'origin', c[6]);\n"
-    "      def(this, 'username', c[7]);\n"
-    "      def(this, 'password', c[8]);\n"
-    "      def(this, 'hash', c[9]);\n"
-    "      def(this, 'port', c[10]);\n"
-    "    }\n"
-    /* The search half of the live coupling: normalize the assigned
-     * query, splice it into href between the pre-query part and the
-     * 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. */
+    "      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"
@@ -10773,7 +11354,10 @@ static void isl_install_url_class(void) {
       abort(); /* fixed source; failing to parse is a build defect */
     }
     JSValue parse = JS_NewCFunction(isl_ctx, isl_url_parse_host, "__scr_url_parse", 3);
-    JSValue r = JS_Call(isl_ctx, installer, JS_UNDEFINED, 1, &parse);
+    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)) {