@ai-ecoverse/slicc-kernel 1.129.0 → 1.130.0

package/dist/node.js

@@ -3913,8 +3913,8 @@ var Integrity = class {
     }
   }
   async expected(path) {
-    const answer = await this.lookup(path);
-    return typeof answer === "string" ? answer.toLowerCase() : void 0;
+    const answer2 = await this.lookup(path);
+    return typeof answer2 === "string" ? answer2.toLowerCase() : void 0;
   }
   say(event) {
     try {
@@ -4247,12 +4247,12 @@ var RemoteWatch = class {
   }
   greeted(peer) {
     this.arrived(peer);
-    const answer = () => {
+    const answer2 = () => {
       this.channel.postMessage({ here: this.tab, to: peer });
       if (this.mine.length > 0) void this.announce(this.mine);
     };
-    if (this.quiet) void this.quiet().then(answer, answer);
-    else answer();
+    if (this.quiet) void this.quiet().then(answer2, answer2);
+    else answer2();
   }
   announced({ tab, paths, seq: seq2 }) {
     const from = tab;
@@ -7392,7 +7392,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.129.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.130.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -16301,11 +16301,11 @@ function carriesUdp(uplink) {
   return uplink.traits.udp === true && typeof uplink.udp === "function";
 }
 function answerOf(result) {
-  const answer = Array.isArray(result) ? { addresses: result } : result;
-  const addresses = Array.isArray(answer?.addresses) ? answer.addresses.filter((a) => typeof a === "string") : [];
+  const answer2 = Array.isArray(result) ? { addresses: result } : result;
+  const addresses = Array.isArray(answer2?.addresses) ? answer2.addresses.filter((a) => typeof a === "string") : [];
   return {
     addresses,
-    ...typeof answer?.ttl === "number" && answer.ttl >= 0 ? { ttl: answer.ttl } : {}
+    ...typeof answer2?.ttl === "number" && answer2.ttl >= 0 ? { ttl: answer2.ttl } : {}
   };
 }
 var NEVER = new Routes(true);
@@ -16383,9 +16383,9 @@ var Resolver = class {
   async lookup(name2, family, id2, abandoned) {
     const uplink = this.uplink;
     const timeout = AbortSignal.any([AbortSignal.timeout(this.timeoutMs), abandoned]);
-    let answer;
+    let answer2;
     try {
-      answer = answerOf(
+      answer2 = answerOf(
         await Promise.race([
           uplink.resolve(name2, family, timeout),
           new Promise(
@@ -16396,8 +16396,8 @@ var Resolver = class {
     } catch {
       return [];
     }
-    const addresses = answer.addresses.filter((a) => this.usable(name2, a, family));
-    if (addresses.length > 0) this.remember(id2, addresses, answer.ttl);
+    const addresses = answer2.addresses.filter((a) => this.usable(name2, a, family));
+    if (addresses.length > 0) this.remember(id2, addresses, answer2.ttl);
     return addresses;
   }
   usable(name2, address, family) {
@@ -21053,8 +21053,8 @@ var WasmProcess = class {
   spares(sig) {
     const { caught, ignored } = this.signalMasks();
     const bit = isSignal(sig) ? sigbit(sig) : 0;
-    const answer = (ignored & bit) !== 0 ? "ignore" : (caught & bit) !== 0 ? "spare" : "terminate";
-    return { ok: true, kind: "json", json: answer };
+    const answer2 = (ignored & bit) !== 0 ? "ignore" : (caught & bit) !== 0 ? "spare" : "terminate";
+    return { ok: true, kind: "json", json: answer2 };
   }
   async killSelf(sig, target, probe2) {
     if (!this.options.exitSignal) throw new KernelError("ENOSYS");
@@ -22171,10 +22171,10 @@ var WasmProcess = class {
       cwd: typeof req.cwd === "string" && req.cwd.startsWith("/") ? req.cwd : "/",
       ...typeof req.term === "string" ? { term: req.term } : {}
     };
-    const answer = await sudo(call, this.blockingSignal(cancelled));
-    if (!("grant" in answer)) return answer;
+    const answer2 = await sudo(call, this.blockingSignal(cancelled));
+    if (!("grant" in answer2)) return answer2;
     if (this.dying) throw new KernelError("EINTR");
-    const { file, argv, env, cwd, cred, caller } = answer.grant;
+    const { file, argv, env, cwd, cred, caller } = answer2.grant;
     const stdio = [{ fd: 0 }, { fd: 1 }, { fd: 2 }];
     return {
       pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
@@ -22334,6 +22334,153 @@ var WASM_THREAD_SPAWN = "wasm-thread-spawn";
 var WASM_THREAD_INIT = "wasm-thread-init";
 var WASM_THREAD_EXIT = "wasm-thread-exit";
 var WASM_MAX_THREADS = 256;
+var JS_THREAD_SPAWN = "js-thread-spawn";
+var JS_THREAD_INIT = "js-thread-init";
+var JS_THREAD_EXIT = "js-thread-exit";
+var JS_MAX_THREADS = 256;
+var JS_DEFAULT_THREADS = 16;
+var JS_THREAD_NO_MEMORY = 256;
+var JS_THREAD_CRASHED = 257;
+
+// src/kernel/js-threads.ts
+var JS_OOM = /out of memory|Array buffer allocation failed|Cannot allocate Wasm memory|could not allocate memory|ERR_WORKER_OUT_OF_MEMORY/i;
+var ENDING = { ok: false, errno: "EINTR", message: "the thread is ending" };
+var MAIN_ONLY = { ok: true, kind: "void" };
+function track(ops, req, result) {
+  if (req.op === "async-submit" && result.ok && result.kind === "json") {
+    if (typeof result.json === "number") ops.set(result.json, req.token);
+  } else if (req.op === "async-cancel" || req.op === "async-take" && (result.ok || result.errno !== "EAGAIN")) {
+    ops.delete(req.id);
+  }
+}
+function cores() {
+  const n = globalThis.navigator?.hardwareConcurrency;
+  return typeof n === "number" && Number.isInteger(n) && n > 0 ? n : 0;
+}
+function jsThreadCap(env) {
+  const asked = Number.parseInt(env.SLICC_JS_THREADS ?? "", 10);
+  if (asked >= 1) return Math.min(asked, JS_MAX_THREADS);
+  return Math.min(JS_MAX_THREADS, Math.max(JS_DEFAULT_THREADS, 2 * cores()));
+}
+function codeOf4(code) {
+  if (code === JS_THREAD_NO_MEMORY || code === JS_THREAD_CRASHED) return code;
+  return typeof code === "number" && Number.isInteger(code) ? code & 255 : JS_THREAD_CRASHED;
+}
+function answer(control, message3) {
+  control.postMessage(message3);
+}
+var JsThreads = class {
+  deps;
+  live = /* @__PURE__ */ new Map();
+  headers = /* @__PURE__ */ new Map();
+  frozen = false;
+  last = 0;
+  closed = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get size() {
+    return this.live.size;
+  }
+  spawn(msg) {
+    const { control, port } = msg;
+    if (this.closed || this.live.size >= this.deps.cap) {
+      answer(
+        control,
+        this.closed ? { errno: "ESRCH", message: "the process is ending" } : { errno: "EAGAIN", message: `more than ${this.deps.cap} threads` }
+      );
+      control.close();
+      port.close();
+      return;
+    }
+    const tid = ++this.last;
+    const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
+    const header4 = new Int32Array(sab, 0, SAB_HEADER_I32);
+    if (this.frozen) Atomics.store(header4, SAB_I_STOP, 1);
+    const worker = this.deps.createWorker();
+    const clock = this.deps.clocks.thread(tid + 1, sab);
+    let ended = false;
+    const end = (code) => {
+      if (ended) return;
+      ended = true;
+      this.live.delete(tid);
+      this.headers.delete(tid);
+      this.deps.wakes.delete(header4);
+      for (const [id2, token] of ops) {
+        void this.deps.dispatch({ op: "async-cancel", id: id2, token });
+      }
+      ops.clear();
+      worker.removeEventListener("message", onMessage);
+      worker.removeEventListener("error", onError);
+      control.removeEventListener("message", onControl);
+      responder.dispose();
+      lane.dispose();
+      this.deps.clocks.threadEnded(tid + 1);
+      worker.terminate();
+      answer(control, { exited: code });
+      control.close();
+    };
+    const ops = /* @__PURE__ */ new Map();
+    const dispatch2 = async (req, block) => {
+      if (isWasmSyscall(req) && req.op === "proc-exit") {
+        queueMicrotask(() => end(req.status & 255));
+        return ENDING;
+      }
+      if (isWasmSyscall(req) && req.op === "sig-mask") return MAIN_ONLY;
+      const result = await this.deps.dispatch(req, block);
+      if (!ended) track(ops, req, result);
+      return result;
+    };
+    const responder = this.deps.attach(worker, sab, this.deps.clocks.timed(clock, dispatch2));
+    const lane = this.deps.openLane(dispatch2);
+    const onMessage = (event) => {
+      const data = event.data;
+      if (data?.type === JS_THREAD_EXIT) end(codeOf4(data.code));
+      else if (data?.type === JS_THREAD_SPAWN) this.spawn(event.data);
+      else if (data?.type === WASM_PROCESS_ERROR) this.crashed(String(data.message), end);
+    };
+    const onError = (event) => {
+      event.preventDefault();
+      this.crashed(String(event.message ?? "worker error"), end);
+    };
+    const onControl = (event) => {
+      if (event.data?.terminate === true) end(1);
+    };
+    worker.addEventListener("message", onMessage);
+    worker.addEventListener("error", onError);
+    control.addEventListener("message", onControl);
+    control.start();
+    this.live.set(tid, end);
+    this.headers.set(tid, header4);
+    this.deps.wakes.add(header4);
+    const init = {
+      ...this.deps.init(sab, lane.lane),
+      type: JS_THREAD_INIT,
+      thread: { tid, port, data: msg.data }
+    };
+    try {
+      worker.postMessage(init, [lane.lane.port, port, ...msg.transfer ?? []]);
+    } catch {
+      end(JS_THREAD_CRASHED);
+      return;
+    }
+    answer(control, { tid });
+  }
+  crashed(message3, end) {
+    end(JS_OOM.test(message3) ? JS_THREAD_NO_MEMORY : JS_THREAD_CRASHED);
+  }
+  stopped(stopped) {
+    this.frozen = stopped;
+    for (const header4 of this.headers.values()) {
+      Atomics.store(header4, SAB_I_STOP, stopped ? 1 : 0);
+      Atomics.notify(header4, SAB_I_STOP);
+    }
+  }
+  close() {
+    this.closed = true;
+    for (const end of [...this.live.values()]) end(1);
+  }
+};
 
 // src/kernel/host.ts
 var CRASHED = 70;
@@ -22436,6 +22583,7 @@ function threadSignalsOf(sab) {
 function threadCancel(thread) {
   return unblocked(thread.header) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
 }
+var asyncFanout = /* @__PURE__ */ new WeakMap();
 function notifiers(header4) {
   return {
     onPending(sig) {
@@ -22443,8 +22591,10 @@ function notifiers(header4) {
       Atomics.notify(header4, SAB_I_SIGNALS);
     },
     onAsync() {
-      Atomics.add(header4, SAB_I_ASYNC, 1);
-      Atomics.notify(header4, SAB_I_ASYNC);
+      for (const at of [header4, ...asyncFanout.get(header4) ?? []]) {
+        Atomics.add(at, SAB_I_ASYNC, 1);
+        Atomics.notify(at, SAB_I_ASYNC);
+      }
     }
   };
 }
@@ -22675,6 +22825,7 @@ function spawnWasmProcess(opts) {
     dispatch: clocks.timed(void 0, dispatch2)
   });
   const lane = opts.program.abi === "js" ? openLane(token, dispatch2) : void 0;
+  const jsThreads = jsThreadsOf(opts, process2, token, dispatch2, clocks, header4);
   const { promise: exited, resolve: settle } = Promise.withResolvers();
   let done4 = false;
   let endedBy;
@@ -22688,6 +22839,7 @@ function spawnWasmProcess(opts) {
     worker.removeEventListener("message", onMessage);
     worker.removeEventListener("error", onError);
     for (const tid of [...threads.keys()]) endThread(tid);
+    jsThreads?.close();
     responder.dispose();
     lane?.dispose();
     revokeSyncFsToken(token);
@@ -22711,6 +22863,8 @@ function spawnWasmProcess(opts) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_THREAD_SPAWN && data.thread) {
       spawnThread(data.thread);
+    } else if (data?.type === JS_THREAD_SPAWN && jsThreads) {
+      jsThreads.spawn(data);
     }
   };
   const onMessage = (event) => handle(event.data);
@@ -22784,13 +22938,35 @@ function spawnWasmProcess(opts) {
     termsig: () => endedBy,
     onState: (listener) => process2.onState(listener),
     memory: () => Atomics.load(header4, SAB_I_MEMORY) * 65536,
+    ...processViews(process2, opts, header4),
+    writesBack: () => opts.program.abi === "wasi" && !done4,
+    ...clockViews(clocks)
+  };
+}
+function jsThreadsOf(opts, process2, token, dispatch2, clocks, header4) {
+  if (opts.program.abi !== "js") return void 0;
+  const wakes = /* @__PURE__ */ new Set();
+  asyncFanout.set(header4, wakes);
+  const threads = new JsThreads({
+    wakes,
+    cap: jsThreadCap(opts.env),
+    createWorker: opts.createWorker,
+    init: (sab, lane) => processInit(opts, sab, process2.umask, copyCred(process2.cred), lane),
+    openLane: (laneDispatch) => openLane(token, laneDispatch),
+    attach: (worker, sab, threadDispatch) => attachSyncSabResponder(worker, sab, token, { dispatch: threadDispatch }),
+    dispatch: dispatch2,
+    clocks
+  });
+  process2.onState((state) => threads.stopped(state === "stopped"));
+  return threads;
+}
+function processViews(process2, opts, header4) {
+  return {
     ignoredSignals: (fork) => process2.inheritable(fork),
     blockedSignals: () => opts.program.abi === "wasi" ? loadBlocked(header4) : [0, 0],
     signalMasks: () => process2.signalMasks(),
     umask: () => process2.umask,
-    cred: () => copyCred(process2.cred),
-    writesBack: () => opts.program.abi === "wasi" && !done4,
-    ...clockViews(clocks)
+    cred: () => copyCred(process2.cred)
   };
 }
 function clockViews(clocks) {
@@ -24108,8 +24284,8 @@ var FSA_CAPABILITIES = {
   ranges: true,
   sessions: true
 };
-var codeOf4 = (err) => err?.code;
-var denied = (err) => codeOf4(err) === "EACCES" || err?.name === "NotAllowedError";
+var codeOf5 = (err) => err?.code;
+var denied = (err) => codeOf5(err) === "EACCES" || err?.name === "NotAllowedError";
 function attrOf(st) {
   return {
     kind: st.isDirectory ? "directory" : st.isSymbolicLink ? "symlink" : "file",
@@ -24131,7 +24307,7 @@ function kernelFsHandlers(fs) {
     try {
       return await fs.stat(path);
     } catch (err) {
-      if (codeOf4(err) === "ENOENT") return void 0;
+      if (codeOf5(err) === "ENOENT") return void 0;
       throw err;
     }
   }
@@ -24324,7 +24500,7 @@ function parseFstab(text) {
   });
   return lines2;
 }
-function codeOf5(err) {
+function codeOf6(err) {
   const code = err?.code;
   return typeof code === "string" ? code : "EIO";
 }
@@ -24362,18 +24538,18 @@ async function mountLine({ line, spec, invalid }, mount, signal, retries, discar
       break;
     } catch (err) {
       failed3 = err;
-      if (FINAL.has(codeOf5(err)) || attempt === retries.length) break;
+      if (FINAL.has(codeOf6(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf5(failed3);
+  const code = codeOf6(failed3);
   return { line, target: spec.target, code, error: String(failed3?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
 var HOSTFS_IO = 16 * 1024 * 1024;
-var codeOf6 = (err) => err?.code;
-var unreachable = (err) => codeOf6(err) === "ENOTCONN";
+var codeOf7 = (err) => err?.code;
+var unreachable = (err) => codeOf7(err) === "ENOTCONN";
 function rel(path) {
   return path.replace(/^\/+/, "");
 }
@@ -24550,7 +24726,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     try {
       return { opened: await opening2(), restore: void 0 };
     } catch (err) {
-      if (!flags2.write || codeOf6(err) !== "EACCES") throw err;
+      if (!flags2.write || codeOf7(err) !== "EACCES") throw err;
       const was = await client.call("stat", { path: rel(path) });
       const mode = was.mode ?? 0;
       if (mode & 128) throw err;
@@ -24975,7 +25151,7 @@ var PortTransport = class {
   }
 };
 var errorOf = (err) => ({
-  code: typeof codeOf6(err) === "string" ? codeOf6(err) : "EIO",
+  code: typeof codeOf7(err) === "string" ? codeOf7(err) : "EIO",
   message: err?.message ?? String(err)
 });
 function serveHostfsPort(port, transport) {
@@ -24989,14 +25165,14 @@ function serveHostfsPort(port, transport) {
   };
   const send2 = (reply, transfer = []) => port.postMessage(reply, transfer);
   const pending = /* @__PURE__ */ new Set();
-  const track = (work) => {
+  const track2 = (work) => {
     pending.add(work);
     const done4 = () => pending.delete(work);
     work.then(done4, done4);
     return work;
   };
-  const answer = async (name2, body) => {
-    const result = await track(transport.call(name2, body));
+  const answer2 = async (name2, body) => {
+    const result = await track2(transport.call(name2, body));
     const opened2 = result?.fh;
     if (name2 === "open" && typeof opened2 === "number") handles.add(opened2);
     if (name2 === "release") handles.delete(body?.fh);
@@ -25010,7 +25186,7 @@ function serveHostfsPort(port, transport) {
     if (op === "ping") return send2({ id: id2, pong: true });
     if (op === "bye") return stop();
     if (op === "cleanup")
-      return void Promise.allSettled([...pending]).then(() => answer(data.name, data.body)).catch(() => {
+      return void Promise.allSettled([...pending]).then(() => answer2(data.name, data.body)).catch(() => {
       });
     if (op === "unwatch") return watches.get(id2)?.abort();
     if (op === "watch") {
@@ -25032,7 +25208,7 @@ function serveHostfsPort(port, transport) {
     }
     try {
       if (op === "read") {
-        const read = await track(
+        const read = await track2(
           transport.read(
             data.fh,
             data.offset,
@@ -25044,13 +25220,13 @@ function serveHostfsPort(port, transport) {
         return send2({ id: id2, bytes }, [bytes.buffer]);
       }
       if (op === "write") {
-        await track(
+        await track2(
           transport.write(data.fh, data.offset, data.bytes)
         );
         return send2({ id: id2 });
       }
       if (op !== "call") throw fsError2("EINVAL", `unknown hostfs port op ${op}`);
-      send2({ id: id2, result: await answer(data.name, data.body) });
+      send2({ id: id2, result: await answer2(data.name, data.body) });
     } catch (err) {
       send2({ id: id2, error: errorOf(err) });
     }
@@ -25842,14 +26018,14 @@ var Sudo = class {
     if (this.pending.has(cred.ruid)) return failed2("EBUSY", "sudo: another request is pending");
     this.pending.add(cred.ruid);
     try {
-      const answer = await this.ask(caller, self, target, parsed2.command, path, cwd, signal);
-      if (typeof answer !== "string") return answer;
+      const answer2 = await this.ask(caller, self, target, parsed2.command, path, cwd, signal);
+      if (typeof answer2 !== "string") return answer2;
       if (await this.canonical(call.cwd) !== cwd || !await this.reachable(cred, cwd)) {
         return failed2("EACCES", `sudo: ${call.cwd} changed while the request waited`);
       }
       const changed = await this.untrusted(path, cwd, word);
       if (changed) return changed;
-      if (answer === "always" && !await this.remember(self, target, cwd, argv)) {
+      if (answer2 === "always" && !await this.remember(self, target, cwd, argv)) {
         return failed2("EIO", "sudo: the rule could not be recorded");
       }
       return grant();
@@ -25904,11 +26080,11 @@ ${lines2}
     );
     try {
       const answered = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
-      const answer = await Promise.race([answered, aborted2]);
-      if (answer === "aborted" || control.signal.aborted) {
+      const answer2 = await Promise.race([answered, aborted2]);
+      if (answer2 === "aborted" || control.signal.aborted) {
         return control.signal.reason === "expired" ? failed2("ETIMEDOUT", "sudo: the request expired") : failed2("EINTR", "sudo: the request was withdrawn");
       }
-      return answer === "once" || answer === "always" ? answer : failed2("EACCES", "sudo: approval denied");
+      return answer2 === "once" || answer2 === "always" ? answer2 : failed2("EACCES", "sudo: approval denied");
     } finally {
       clearTimeout(timer);
       requester.removeEventListener("abort", withdraw);
@@ -26819,7 +26995,7 @@ var Launcher = class {
     try {
       return await this.planOne(req, ctx);
     } catch (err) {
-      const code = codeOf7(err);
+      const code = codeOf8(err);
       const searched = bare && req.search !== false && (code === "ENOENT" || code === "ENOEXEC");
       if (!searched || await this.commandAt(req.file, ctx.scope)) throw err;
       const found = await this.onPath(req, ctx);
@@ -26836,7 +27012,7 @@ var Launcher = class {
       try {
         return await this.planOne({ ...req, file }, ctx);
       } catch (err) {
-        const code = codeOf7(err);
+        const code = codeOf8(err);
         if (code === "EACCES") denied2 = true;
         else if (code !== "ENOENT" && code !== "ENOTDIR") throw err;
       }
@@ -26846,7 +27022,7 @@ var Launcher = class {
   }
   async planOne(req, { ppid, cred, scope }) {
     const refused3 = (err) => {
-      throw codeOf7(err) === "EACCES" ? new SpawnError("EACCES") : err;
+      throw codeOf8(err) === "EACCES" ? new SpawnError("EACCES") : err;
     };
     const file = await this.execFile(req.file, req.cwd, this.execGuard(cred, ppid)).catch(refused3);
     const planned = await this.plan(file, req.argv, req.cwd, scope, req.argv0);
@@ -28356,7 +28532,7 @@ var Launcher = class {
 function cronLocks() {
   return globalThis.navigator?.locks;
 }
-function codeOf7(err) {
+function codeOf8(err) {
   return err?.code;
 }
 
@@ -28769,7 +28945,7 @@ import { connect as tls } from "node:tls";
 var PROBE_MS = 3e3;
 var PASSED = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ETIMEDOUT", "ECONNRESET"]);
 var NO_NAME = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN", "EAI_NONAME", "EAI_FAIL", "ENODATA"]);
-function codeOf8(e) {
+function codeOf9(e) {
   const code = e?.code;
   return typeof code === "string" ? code : void 0;
 }
@@ -28798,7 +28974,7 @@ function probe(secure2, host, port, ms, signal) {
     signal?.addEventListener("abort", stop, { once: true });
     socket.once(secure2 ? "secureConnect" : "connect", () => done4("EPROTO"));
     socket.once("error", (e) => {
-      const code = codeOf8(e) ?? "";
+      const code = codeOf9(e) ?? "";
       done4(PASSED.has(code) ? code : "EPROTO");
     });
   });
@@ -28813,7 +28989,7 @@ async function diagnose(url, ms = PROBE_MS, signal) {
     await abortable(lookup3(host), signal);
   } catch (e) {
     if (signal?.aborted) throw signal.reason;
-    return NO_NAME.has(codeOf8(e) ?? "") ? "EAI_NONAME" : void 0;
+    return NO_NAME.has(codeOf9(e) ?? "") ? "EAI_NONAME" : void 0;
   }
   const code = await probe(secure2, host, port, ms, signal);
   signal?.throwIfAborted();
@@ -28832,7 +29008,7 @@ function diagnosing(transport, check = byDefault) {
       try {
         return await open(request);
       } catch (e) {
-        if (request.signal.aborted || !(e instanceof Error) || codeOf8(e)) throw e;
+        if (request.signal.aborted || !(e instanceof Error) || codeOf9(e)) throw e;
         const code = await abortable(
           check(request.url, request.signal).catch(() => void 0),
           request.signal