@ai-ecoverse/slicc-kernel 1.124.12 → 1.124.13

package/dist/node.js

@@ -1557,8 +1557,8 @@ function uplinkLink(conn, onReset) {
     open = false;
     conn.close();
   };
-  void inbound(conn, rx).catch(() => {
-    onReset();
+  void inbound(conn, rx).catch((err) => {
+    onReset(err);
     close();
     tx.closeRead();
   }).finally(() => rx.closeWrite());
@@ -1649,7 +1649,7 @@ var KernelSocket = class _KernelSocket {
   state = "open";
   dialing;
   failed;
-  reset = false;
+  reset;
   local;
   peer;
   peerCred;
@@ -1688,19 +1688,20 @@ var KernelSocket = class _KernelSocket {
     const { rx } = this.connection();
     if (this.readShut || max <= 0) return new Uint8Array(0);
     const bytes = await pipeCall(() => rx.read(max, signal));
-    if (bytes.length === 0 && this.reset) throw new KernelError("ECONNRESET");
+    if (bytes.length === 0 && this.reset) throw this.reset;
     return bytes;
   }
   async peek(max, signal) {
     const { rx } = this.connection();
     if (this.readShut || max <= 0) return new Uint8Array(0);
     const bytes = await pipeCall(() => rx.peek(max, signal));
-    if (bytes.length === 0 && this.reset) throw new KernelError("ECONNRESET");
+    if (bytes.length === 0 && this.reset) throw this.reset;
     return bytes;
   }
   async write(bytes, signal) {
     const { tx } = this.connection();
     if (this.writeShut) throw new KernelError("EPIPE");
+    if (this.reset?.code === "EPROTO") throw this.reset;
     return pipeCall(() => tx.write(bytes, signal));
   }
   poll() {
@@ -1885,8 +1886,8 @@ var KernelSocket = class _KernelSocket {
         this.dialing = void 0;
         this.switch = conn;
         this.attach(
-          uplinkLink(conn, () => {
-            this.reset = true;
+          uplinkLink(conn, (err) => {
+            this.reset = err instanceof KernelError && err.code === "EPROTO" ? err : new KernelError("ECONNRESET");
             this.changes.wake();
           })
         );
@@ -5993,16 +5994,24 @@ var UnlinkedKeeper = class {
     gated();
     const held = /* @__PURE__ */ new Map();
     const hidden = /* @__PURE__ */ new Map();
-    for (; ; ) {
-      await take();
-      const now = this.heldWithin(target);
-      const next3 = paths.filter((path) => now.has(path) && !held.has(path));
-      if (next3.length === 0) break;
-      for (const path of next3) {
-        held.set(path, now.get(path));
-        const at = await this.hide(path);
-        if (at !== void 0) hidden.set(path, at);
+    const moved2 = [];
+    try {
+      for (; ; ) {
+        await take();
+        const now = this.heldWithin(target);
+        const next3 = paths.filter((path) => now.has(path) && !held.has(path));
+        if (next3.length === 0) break;
+        for (const path of next3) {
+          const holders = now.get(path);
+          held.set(path, holders);
+          for (const holder of holders) moved2.push(holder.moving?.(path) ?? (() => void 0));
+          const at = await this.hide(path);
+          if (at !== void 0) hidden.set(path, at);
+        }
       }
+    } catch (err) {
+      for (const settle of moved2) settle();
+      throw err;
     }
     sealed();
     const done4 = () => {
@@ -6015,6 +6024,7 @@ var UnlinkedKeeper = class {
       files.set(path, file);
       for (const holder of holders) holder.keep(path, file);
     }
+    for (const settle of moved2) settle();
     return {
       moved: new Set(hidden.keys()),
       commit: () => {
@@ -7070,7 +7080,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.12" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.124.13" : "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
@@ -14824,6 +14834,8 @@ function realmCa(owner, store) {
 
 // src/kernel/net/tls-engine.ts
 var TLS_CLIENT_INSECURE_SKIP_VERIFY = 1;
+var TLS_CLIENT_NO_SNI = 2;
+var TLS_CLIENT_VERIFY_CHAIN_ONLY = 4;
 var SCRATCH = 64 * 1024;
 var EOF = -1;
 var TlsError = class extends Error {
@@ -14880,10 +14892,22 @@ var TlsEngine = class {
       this.m._free(ptr);
     }
   }
+  withSecret(bytes, fn) {
+    const ptr = this.put(bytes);
+    try {
+      return fn(ptr);
+    } finally {
+      this.m.HEAPU8.fill(0, ptr, ptr + bytes.length + 1);
+      this.m._free(ptr);
+    }
+  }
   intoScratch(fn) {
     const n = fn(this.scratch, SCRATCH);
     return n > 0 ? this.taken(n) : n;
   }
+  get sessionControls() {
+    return typeof this.m._tls_client_cert === "function";
+  }
   get client() {
     return typeof this.m._tls_client_new === "function" ? this.m : void 0;
   }
@@ -15036,6 +15060,27 @@ var TlsSession = class {
     const out = this.engine.intoScratch((p, max) => this.c._tls_alpn(this.ptr, p, max));
     return out instanceof Uint8Array ? new TextDecoder().decode(out) : void 0;
   }
+  ownCert(chain2, key, pass2) {
+    const set3 = this.m._tls_client_cert;
+    const keyLen = key[0] === 45 ? key.length + 1 : key.length;
+    const ret = this.engine.withBytes(
+      chain2,
+      (c) => this.engine.withSecret(
+        key,
+        (k) => this.engine.withSecret(
+          pass2,
+          (p) => set3(this.ptr, c, chain2.length, k, keyLen, pass2.length > 0 ? p : 0, pass2.length)
+        )
+      )
+    );
+    if (ret !== 0) throw this.engine.error(ret, "client certificate");
+  }
+  get ciphersuite() {
+    return this.m._tls_ciphersuite(this.ptr);
+  }
+  get nameMismatch() {
+    return this.m._tls_name_mismatch(this.ptr) === 1;
+  }
   peerChain() {
     const chain2 = [];
     const count2 = this.c._tls_peer_count(this.ptr);
@@ -16340,11 +16385,11 @@ async function runChild(req, deps) {
     if (pid !== 0) kill();
     decided.resolve();
   };
-  const controls = [];
+  const controls2 = [];
   const capture = () => {
     const { promise, resolve: resolve2 } = Promise.withResolvers();
     const control = { shut: false, ended: resolve2, eof: promise };
-    controls.push(control);
+    controls2.push(control);
     return { capture: true, max, overflow: () => stop("ENOBUFS"), control };
   };
   const decided = Promise.withResolvers();
@@ -16378,11 +16423,11 @@ async function runChild(req, deps) {
   let status;
   try {
     status = await reaped(deps, pid);
-    const open = controls.filter((c) => c.opened);
+    const open = controls2.filter((c) => c.opened);
     await Promise.race([Promise.all(open.map((c) => c.eof)), decided.promise]);
   } finally {
     cancel?.();
-    for (const control of controls) control.shut = true;
+    for (const control of controls2) control.shut = true;
   }
   const out = deps.children.captured(pid, 1);
   const err = deps.children.captured(pid, 2);
@@ -16964,6 +17009,47 @@ function encodeReceived(got) {
   return out;
 }
 
+// src/kernel/net/tls-ciphers.ts
+var SUITES = [
+  [4865, "TLS_AES_128_GCM_SHA256", "TLS_AES_128_GCM_SHA256", "TLSv1.3"],
+  [4866, "TLS_AES_256_GCM_SHA384", "TLS_AES_256_GCM_SHA384", "TLSv1.3"],
+  [4867, "TLS_CHACHA20_POLY1305_SHA256", "TLS_CHACHA20_POLY1305_SHA256", "TLSv1.3"],
+  [4868, "TLS_AES_128_CCM_SHA256", "TLS_AES_128_CCM_SHA256", "TLSv1.3"],
+  [4869, "TLS_AES_128_CCM_8_SHA256", "TLS_AES_128_CCM_8_SHA256", "TLSv1.3"],
+  [49195, "ECDHE-ECDSA-AES128-GCM-SHA256", "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", "TLSv1.2"],
+  [49196, "ECDHE-ECDSA-AES256-GCM-SHA384", "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", "TLSv1.2"],
+  [49199, "ECDHE-RSA-AES128-GCM-SHA256", "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", "TLSv1.2"],
+  [49200, "ECDHE-RSA-AES256-GCM-SHA384", "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", "TLSv1.2"],
+  [52392, "ECDHE-RSA-CHACHA20-POLY1305", "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", "TLSv1.2"],
+  [
+    52393,
+    "ECDHE-ECDSA-CHACHA20-POLY1305",
+    "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
+    "TLSv1.2"
+  ],
+  [49187, "ECDHE-ECDSA-AES128-SHA256", "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", "TLSv1.2"],
+  [49188, "ECDHE-ECDSA-AES256-SHA384", "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384", "TLSv1.2"],
+  [49191, "ECDHE-RSA-AES128-SHA256", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", "TLSv1.2"],
+  [49192, "ECDHE-RSA-AES256-SHA384", "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384", "TLSv1.2"],
+  [49161, "ECDHE-ECDSA-AES128-SHA", "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", "TLSv1.0"],
+  [49162, "ECDHE-ECDSA-AES256-SHA", "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", "TLSv1.0"],
+  [49171, "ECDHE-RSA-AES128-SHA", "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", "TLSv1.0"],
+  [49172, "ECDHE-RSA-AES256-SHA", "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", "TLSv1.0"],
+  [156, "AES128-GCM-SHA256", "TLS_RSA_WITH_AES_128_GCM_SHA256", "TLSv1.2"],
+  [157, "AES256-GCM-SHA384", "TLS_RSA_WITH_AES_256_GCM_SHA384", "TLSv1.2"],
+  [158, "DHE-RSA-AES128-GCM-SHA256", "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256", "TLSv1.2"],
+  [159, "DHE-RSA-AES256-GCM-SHA384", "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", "TLSv1.2"]
+];
+function cipherOf(id2, protocol) {
+  const known = SUITES.find(([n]) => n === id2);
+  const hex3 = `0x${id2.toString(16).padStart(4, "0").toUpperCase()}`;
+  return {
+    name: known?.[1] ?? hex3,
+    standardName: known?.[2] ?? hex3,
+    version: known?.[3] ?? protocol
+  };
+}
+
 // src/kernel/net/tls-client.ts
 var WRITE_CHUNK = 16 * 1024;
 var BADCERT = [
@@ -16980,6 +17066,15 @@ function verifyCode(flags2) {
   if (flags2 === -1) return "UNABLE_TO_VERIFY_LEAF_SIGNATURE";
   return BADCERT.find(([bit]) => (flags2 & bit) !== 0)?.[1] ?? "UNABLE_TO_VERIFY_LEAF_SIGNATURE";
 }
+function isIP(name2) {
+  return ipv4Bytes(name2) !== void 0 || name2.includes(":") && ipv6Groups(name2) !== void 0;
+}
+function clientFlags(o) {
+  return (o.insecure ? TLS_CLIENT_INSECURE_SKIP_VERIFY : 0) | (o.sni === false ? TLS_CLIENT_NO_SNI : 0) | (o.checkHostname === false ? TLS_CLIENT_VERIFY_CHAIN_ONLY : 0);
+}
+function openSession(o) {
+  return o.engine.clientSession(o.store, o.servername, o.alpn, clientFlags(o));
+}
 var Ciphertext = class {
   queue = [];
   ended = false;
@@ -17052,17 +17147,39 @@ async function handshake(conn, o, session, inbox) {
     }
   }
 }
+function controlsOf(o, session, protocol) {
+  if (!o.engine.sessionControls) return {};
+  const checked = o.checkHostname !== false && !o.insecure;
+  return {
+    cipher: cipherOf(session.ciphersuite, protocol),
+    clientCertificate: o.clientCertificate === true,
+    sni: o.sni !== false && !isIP(o.servername),
+    hostnameChecked: checked,
+    ...o.insecure ? {} : { hostnameMatches: checked || !session.nameMismatch }
+  };
+}
 function infoOf(o, session) {
   const flags2 = session.verifyResult;
   const code = verifyCode(flags2);
+  const protocol = session.version === 772 ? "TLSv1.3" : "TLSv1.2";
   return {
-    protocol: session.version === 772 ? "TLSv1.3" : "TLSv1.2",
+    protocol,
     alpnProtocol: session.alpn ?? false,
     authorized: code === void 0,
     ...code ? { authorizationError: code, authorizationText: o.engine.verifyInfo(flags2).trim() } : {},
-    peerCertificates: session.peerChain()
+    peerCertificates: session.peerChain(),
+    ...controlsOf(o, session, protocol)
   };
 }
+var FATAL_ALERT = -30592;
+function alerted(err) {
+  if (err.code === FATAL_ALERT)
+    return new KernelError(
+      "EPROTO",
+      `ERR_SSL_FATAL_ALERT: the server ended the session: ${err.message}`
+    );
+  return new KernelError("EPROTO", `ERR_SSL_PROTOCOL_ERROR: ${err.message}`);
+}
 function plaintext(conn, session, inbox) {
   let freed = false;
   let writeClosed = false;
@@ -17077,7 +17194,12 @@ function plaintext(conn, session, inbox) {
     async read() {
       for (; ; ) {
         if (freed) return null;
-        const got = session.read();
+        let got;
+        try {
+          got = session.read();
+        } catch (err) {
+          throw alerted(err);
+        }
         await send(conn, session);
         if (got instanceof Uint8Array) return got;
         if (got === "eof") return null;
@@ -17105,8 +17227,7 @@ function plaintext(conn, session, inbox) {
   };
 }
 async function tlsClient(conn, o, taken = new Uint8Array(0)) {
-  const flags2 = o.insecure ? TLS_CLIENT_INSECURE_SKIP_VERIFY : 0;
-  const session = o.engine.clientSession(o.store, o.servername, o.alpn, flags2);
+  const session = o.session ?? openSession(o);
   const inbox = new Ciphertext(conn, session);
   inbox.hand(taken);
   try {
@@ -17119,10 +17240,10 @@ async function tlsClient(conn, o, taken = new Uint8Array(0)) {
 }
 
 // src/kernel/net/tls-uplink.ts
-var isIP = (text) => ipv4Bytes(text) !== void 0 || text.includes(":") && ipv6Groups(text) !== void 0;
+var isIP2 = (text) => ipv4Bytes(text) !== void 0 || text.includes(":") && ipv6Groups(text) !== void 0;
 var LABEL2 = /^(?!-)[A-Za-z0-9-]{1,63}(?<!-)$/;
 function serverName(name2) {
-  if (isIP(name2.replace(/^\[|\]$/g, ""))) return name2.replace(/^\[|\]$/g, "");
+  if (isIP2(name2.replace(/^\[|\]$/g, ""))) return name2.replace(/^\[|\]$/g, "");
   const bare = name2.endsWith(".") ? name2.slice(0, -1) : name2;
   if (bare.length === 0 || bare.length > 253 || !bare.split(".").every((l) => LABEL2.test(l))) {
     throw new KernelError(
@@ -17172,9 +17293,66 @@ function sessionOf(info, servername) {
       authorizationText: info.authorizationText
     } : {},
     servername,
-    peerCertificates: info.peerCertificates.map(encode)
+    peerCertificates: info.peerCertificates.map(encode),
+    ...controls(info)
   };
 }
+function controls(info) {
+  if (!info.cipher) return {};
+  return {
+    cipher: info.cipher,
+    clientCertificate: info.clientCertificate === true,
+    sni: info.sni !== false,
+    hostnameChecked: info.hostnameChecked === true,
+    ...info.hostnameMatches === void 0 ? {} : { hostnameMatches: info.hostnameMatches }
+  };
+}
+var KEY_ERRORS = [
+  [-3, "ERR_OSSL_X509_KEY_VALUES_MISMATCH"],
+  [-15232, "ERR_OSSL_BAD_DECRYPT"],
+  [-15360, "ERR_OSSL_CRYPTO_INTERRUPTED_OR_CANCELLED"]
+];
+function keyRefused(err) {
+  const code = err instanceof TlsError ? err.code : 0;
+  const name2 = KEY_ERRORS.find(([n]) => n === code)?.[1] ?? "ERR_OSSL_UNSUPPORTED";
+  const text = code === -3 ? "the key does not match the certificate" : err.message;
+  return new KernelError("EPROTO", `${name2}: ${text}`);
+}
+function takeCert(req) {
+  const cert = req.clientCert;
+  if (!cert) return void 0;
+  delete req.clientCert;
+  if (!Array.isArray(cert.chain) || cert.chain.length === 0 || typeof cert.key !== "string")
+    throw new KernelError("EINVAL", "ERR_INVALID_ARG_VALUE: cert and key go together");
+  let ders;
+  let key;
+  try {
+    ders = cert.chain.map(base64Der);
+    key = base64Der(cert.key);
+  } catch {
+    throw new KernelError("EINVAL", "ERR_INVALID_ARG_VALUE: cert or key is not base64");
+  }
+  const chain2 = new Uint8Array(ders.reduce((n, d) => n + d.length, 0));
+  let at = 0;
+  for (const der of ders) {
+    chain2.set(der, at);
+    at += der.length;
+  }
+  const pass2 = new TextEncoder().encode(cert.passphrase ?? "");
+  return { chain: chain2, key, pass: pass2 };
+}
+function withCert(session, cert) {
+  if (!cert) return;
+  try {
+    session.ownCert(cert.chain, cert.key, cert.pass);
+  } catch (err) {
+    throw keyRefused(err);
+  }
+}
+function wipe(cert) {
+  cert?.key.fill(0);
+  cert?.pass.fill(0);
+}
 async function setUp(support, req) {
   const engine = await support.engine();
   if (!engine.client)
@@ -17192,21 +17370,66 @@ async function setUp(support, req) {
   }
   return { engine, store: own, own };
 }
-function secure(support, req, servername) {
-  return async (raw) => {
-    const { engine, store, own } = await setUp(support, req);
+async function prepare(support, req, servername) {
+  const cert = takeCert(req);
+  try {
+    return await prepareWith(support, req, servername, cert);
+  } catch (err) {
+    if (err instanceof KernelError) throw err;
+    throw new KernelError("ENOTSUP", err instanceof Error ? err.message : String(err));
+  } finally {
+    wipe(cert);
+  }
+}
+async function prepareWith(support, req, servername, cert) {
+  if (req.checkHostname === false && req.insecure === true) {
+    throw new KernelError(
+      "EINVAL",
+      "ERR_INVALID_ARG_VALUE: checkHostname: false needs rejectUnauthorized"
+    );
+  }
+  const { engine, store, own } = await setUp(support, req);
+  const options = {
+    engine,
+    store,
+    servername,
+    alpn: req.alpn ?? [],
+    insecure: req.insecure === true,
+    ...req.sni === false ? { sni: false } : {},
+    ...req.checkHostname === false ? { checkHostname: false } : {},
+    clientCertificate: cert !== void 0
+  };
+  let session;
+  try {
+    const controls2 = req.sni === false || req.checkHostname === false || cert !== void 0;
+    if (controls2 && !engine.sessionControls) {
+      throw new KernelError("ENOTSUP", "the installed tls engine has no client certificates");
+    }
+    session = openSession(options);
+    withCert(session, cert);
+    return { options: { ...options, session }, own };
+  } catch (err) {
+    session?.free();
+    own?.release();
+    throw err;
+  }
+}
+function secure(prepared) {
+  let ran = false;
+  const make = async (raw) => {
+    ran = true;
     try {
-      return await tlsClient(raw, {
-        engine,
-        store,
-        servername,
-        alpn: req.alpn ?? [],
-        insecure: req.insecure === true
-      });
+      return await tlsClient(raw, prepared.options);
     } finally {
-      own?.release();
+      prepared.own?.release();
     }
   };
+  const abandon = () => {
+    if (ran) return;
+    prepared.options.session.free();
+    prepared.own?.release();
+  };
+  return { make, abandon };
 }
 function supportOf(net) {
   const support = net.tlsClient;
@@ -17215,7 +17438,7 @@ function supportOf(net) {
 }
 async function uplinkAddress(proc, host) {
   const bare = host.replace(/^\[|\]$/g, "");
-  if (isIP(bare)) return bare;
+  if (isIP2(bare)) return bare;
   const [first] = await proc.resolve(host, 0, () => proc.blocking());
   if (!first) throw new KernelError("ENOENT", `ENOTFOUND: ${host}`);
   return first;
@@ -17229,18 +17452,26 @@ async function connectSecure(proc, socket, host, port, req) {
     throw new KernelError("ENOTSUP", "TLS in the kernel needs a destination the uplink routes");
   const support = supportOf(proc.net);
   let info;
-  const make = secure(support, req, servername);
-  await socket.connectSecure({ family: "inet", host: address, port }, route, async (conn) => {
-    info = await conn.upgrade(make);
-  });
+  const { make, abandon } = secure(await prepare(support, req, servername));
+  try {
+    await socket.connectSecure({ family: "inet", host: address, port }, route, async (conn) => {
+      info = await conn.upgrade(make);
+    });
+  } finally {
+    abandon();
+  }
   return sessionOf(info, servername);
 }
 async function upgradeSecure(proc, socket, req) {
   const peer = socket.peer;
   const host = req.servername || (peer?.family === "inet" ? peer.host : "");
   const servername = serverName(host);
-  const info = await socket.upgradeSecure(secure(supportOf(proc.net), req, servername));
-  return sessionOf(info, servername);
+  const { make, abandon } = secure(await prepare(supportOf(proc.net), req, servername));
+  try {
+    return sessionOf(await socket.upgradeSecure(make), servername);
+  } finally {
+    abandon();
+  }
 }
 
 // src/kernel/unix-dgram.ts
@@ -17602,17 +17833,23 @@ var NOT_HTTP_PORTS = /* @__PURE__ */ new Set([
   8883
 ]);
 var HOST_NAME = /^[A-Za-z0-9.-]+$|^\[?[0-9A-Fa-f:.]+\]?$/;
+function sessionControls(req) {
+  return req.sni === false || req.checkHostname === false || req.clientCert !== void 0;
+}
 function wantsKernel(req) {
   if (req.path === "kernel") return true;
   if (req.path === "transport") return false;
-  return Array.isArray(req.ca) || req.alpn !== void 0 && req.alpn.length > 0 && !req.alpn.includes("http/1.1") || NOT_HTTP_PORTS.has(req.port);
+  return Array.isArray(req.ca) || sessionControls(req) || req.alpn !== void 0 && req.alpn.length > 0 && !req.alpn.includes("http/1.1") || NOT_HTTP_PORTS.has(req.port);
 }
 async function secureConnect(req, proc) {
   if (!Number.isInteger(req.port) || req.port < 1 || req.port > 65535)
     throw new KernelError("EINVAL");
   const kernelPath = wantsKernel(req) && await uplinked(proc, req.host);
   if (!kernelPath) {
-    if (req.path === "kernel" || Array.isArray(req.ca)) throw new KernelError("ENOTSUP");
+    if (req.path === "kernel" || Array.isArray(req.ca) || sessionControls(req)) {
+      delete req.clientCert;
+      throw new KernelError("ENOTSUP");
+    }
     return { ...tlsOverTransport(req, proc), path: "transport", substitutes: true };
   }
   const socket = proc.net.socket("inet");
@@ -17746,13 +17983,17 @@ var VfsNode = class {
     const ranged2 = await this.prepare();
     await ranged2?.pin();
   }
+  moving = /* @__PURE__ */ new Set();
   async load() {
     if (this.revoked) throw new KernelError("EIO");
-    if (!this.data) {
+    while (!this.data) {
+      const at = this.path;
       try {
-        this.data = await this.fs.readFileBuffer(this.path);
+        this.data = await this.fs.readFileBuffer(at);
       } catch (err) {
         if (!isMissing(err)) throw err;
+        while (this.moving.size > 0) await Promise.all(this.moving);
+        if (this.path !== at) continue;
         this.data = new Uint8Array(0);
         this.missing = true;
       }
@@ -18106,6 +18347,16 @@ var VfsNodes = class {
     this.byPath.set(file.hidden, node);
     this.kept.set(node, file);
   }
+  moving(path) {
+    const node = this.byPath.get(path);
+    if (!node) return () => void 0;
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    node.moving.add(promise);
+    return () => {
+      node.moving.delete(promise);
+      resolve2();
+    };
+  }
   unkeep(path, file) {
     const node = this.byPath.get(file.hidden);
     if (!node) return;
@@ -21393,7 +21644,7 @@ function register(automaton, sources, ids, bytes, source) {
   }
   sources[id2].push(source);
 }
-function prepare(secrets) {
+function prepare2(secrets) {
   const main = new Automaton();
   const wrap = new Automaton();
   const sources = [];
@@ -21544,7 +21795,7 @@ function merge(into, from) {
   }
 }
 function compile(secrets, options = {}) {
-  const c = prepare(secrets.map((secret) => ({ ...secret })));
+  const c = prepare2(secrets.map((secret) => ({ ...secret })));
   const decoder4 = new TextDecoder();
   const idleMs = options.idleMs ?? 250;
   const scrubBytes = (input) => {
@@ -26549,7 +26800,7 @@ function cronLocks() {
 import { AsyncLocalStorage } from "node:async_hooks";
 import { subscribe } from "node:diagnostics_channel";
 import { lookup as lookup2 } from "node:dns/promises";
-import { isIP as isIP2 } from "node:net";
+import { isIP as isIP3 } from "node:net";
 var DEVTOOLS_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
 var METADATA_V6 = [64768, 3778, 0, 0, 0, 0, 0, 596].join(":");
 var resolveHost = async (host) => (await lookup2(host, { all: true, verbatim: true })).map((a) => a.address);
@@ -26561,7 +26812,7 @@ function ipv4Place(address) {
 }
 function placeOf(address) {
   const plain2 = address.replace(/^\[(.*)\]$/, "$1").toLowerCase();
-  const kind = isIP2(plain2);
+  const kind = isIP3(plain2);
   if (kind === 4) return ipv4Place(plain2);
   if (kind !== 6) return void 0;
   const words2 = hextets2(plain2);
@@ -26614,7 +26865,7 @@ function connectRefusal(address, port, place) {
 }
 async function addressesOf(host, resolve2) {
   const plain2 = host.replace(/^\[(.*)\]$/, "$1");
-  if (isIP2(plain2)) return [plain2];
+  if (isIP3(plain2)) return [plain2];
   if (loopbackName2(plain2)) return ["127.0.0.1"];
   return resolve2(plain2).catch(() => []);
 }
@@ -26949,7 +27200,7 @@ function isMemoryRoot(handle) {
 
 // src/node/ws-diagnose.ts
 import { lookup as lookup3 } from "node:dns/promises";
-import { isIP as isIP3, connect as tcp } from "node:net";
+import { isIP as isIP4, connect as tcp } from "node:net";
 import { connect as tls } from "node:tls";
 var PROBE_MS = 3e3;
 var PASSED = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ETIMEDOUT", "ECONNRESET"]);
@@ -26971,7 +27222,7 @@ function abortable(work, signal) {
 }
 function probe(secure2, host, port, ms, signal) {
   return new Promise((resolve2) => {
-    const socket = secure2 ? tls({ host, port, ...isIP3(host) ? {} : { servername: host } }) : tcp({ host, port });
+    const socket = secure2 ? tls({ host, port, ...isIP4(host) ? {} : { servername: host } }) : tcp({ host, port });
     const stop = () => done4("ABORTED");
     const done4 = (code) => {
       clearTimeout(timer);