@ai-ecoverse/slicc-kernel 1.158.1 → 1.159.0

package/dist/node-process-worker.js

@@ -1668,7 +1668,7 @@ var init_wasi_threads = __esm({
         this.beforeSpawn?.();
         const tid = Atomics.add(this.ids, LAST_TID, 1) + 1;
         const modules = this.modules?.();
-        const blocked = this.blocked?.();
+        const blocked2 = this.blocked?.();
         this.port.postMessage({
           type: WASM_THREAD_SPAWN,
           thread: {
@@ -1677,7 +1677,7 @@ var init_wasi_threads = __esm({
             memory: this.memory,
             ids: this.ids.buffer,
             ...modules ? { modules } : {},
-            ...anyBlocked(blocked) ? { blocked } : {}
+            ...anyBlocked(blocked2) ? { blocked: blocked2 } : {}
           }
         });
         return tid;
@@ -1843,8 +1843,8 @@ function localWait(wait2, blocks = true) {
 function localCpuNanos() {
   if (!local || !localSab) return void 0;
   const now = epochMicros();
-  const blocked = Number(Atomics.load(local, BLOCKED)) + localIdle(localSab, now).idle;
-  return BigInt(Math.max(0, now - localStart - blocked)) * 1000n;
+  const blocked2 = Number(Atomics.load(local, BLOCKED)) + localIdle(localSab, now).idle;
+  return BigInt(Math.max(0, now - localStart - blocked2)) * 1000n;
 }
 function localIdle(sab, now) {
   const state = Number(Atomics.load(slots(sab), IDLE));
@@ -2640,14 +2640,14 @@ function typeOf(info) {
 function device(info) {
   return info.meta && "device" in info.meta ? info.meta : void 0;
 }
-function readDevice(info, max, random) {
+function readDevice(info, max, random2) {
   if (typeOf(info) === "directory") throw new JsCallError("EISDIR", "read");
   const dev = device(info);
   if (!dev) return void 0;
   if (dev.access === "write") throw new JsCallError("EBADF", "read");
   if (dev.device === "null") return new Uint8Array(0);
   const out = new Uint8Array(Math.min(max, CHUNK));
-  if (dev.device === "urandom") random(out);
+  if (dev.device === "urandom") random2(out);
   return out;
 }
 function writeDevice(info) {
@@ -3217,11 +3217,11 @@ function remainingMs(deadline, now) {
 }
 function semImports(host) {
   const { mem } = host;
-  const call2 = (req) => host.o.kernel.call(req);
+  const call3 = (req) => host.o.kernel.call(req);
   const name2 = (ptr, len) => mem.string(ptr, len);
   return {
     sem_open: (np, nl, oflag, mode, value2, out) => {
-      const handle = call2({
+      const handle = call3({
         op: "sem-open",
         name: name2(np, nl),
         create: (oflag & SEM_CREAT) !== 0,
@@ -3231,9 +3231,9 @@ function semImports(host) {
       });
       mem.view().setUint32(out, handle, true);
     },
-    sem_close: (handle) => void call2({ op: "sem-close", handle }),
-    sem_unlink: (np, nl) => void call2({ op: "sem-unlink", name: name2(np, nl) }),
-    sem_post: (handle) => void call2({ op: "sem-post", handle }),
+    sem_close: (handle) => void call3({ op: "sem-close", handle }),
+    sem_unlink: (np, nl) => void call3({ op: "sem-unlink", name: name2(np, nl) }),
+    sem_post: (handle) => void call3({ op: "sem-post", handle }),
     sem_wait: (handle, how, clock, deadline) => {
       const kind = HOW[how];
       if (!kind) throw new WasiError("EINVAL");
@@ -3243,9 +3243,9 @@ function semImports(host) {
         if (clock !== CLOCK.REALTIME && clock !== CLOCK.MONOTONIC) throw new WasiError("EINVAL");
         timeoutMs2 = remainingMs(deadline, host.now(clock));
       }
-      call2({ op: "sem-wait", handle, how: kind, timeoutMs: timeoutMs2 });
+      call3({ op: "sem-wait", handle, how: kind, timeoutMs: timeoutMs2 });
     },
-    sem_getvalue: (handle, out) => void mem.view().setInt32(out, call2({ op: "sem-getvalue", handle }), true)
+    sem_getvalue: (handle, out) => void mem.view().setInt32(out, call3({ op: "sem-getvalue", handle }), true)
   };
 }
 var SEM_CREAT, SEM_EXCL, HOW, NS_PER_MS;
@@ -3309,8 +3309,8 @@ var init_wasi_cred = __esm({
       call;
       shared;
       signals;
-      constructor(call2, shared, signals = UNGATED) {
-        this.call = call2;
+      constructor(call3, shared, signals = UNGATED) {
+        this.call = call3;
         this.shared = shared;
         this.signals = signals;
       }
@@ -3565,8 +3565,8 @@ var init_wasi_fds = __esm({
         return this.install({ type: "dir", path: normalize(path), preopen: name2 });
       }
       preopens(cwd, root) {
-        const here = normalize(cwd);
-        const dot = { type: "dir", path: here, preopen: "." };
+        const here2 = normalize(cwd);
+        const dot = { type: "dir", path: here2, preopen: "." };
         const out = [dot];
         let names = [];
         try {
@@ -3588,7 +3588,7 @@ var init_wasi_fds = __esm({
         if (root) {
           out.push(
             { type: "dir", path: "/", preopen: "/" },
-            { type: "dir", path: here, preopen: "./" }
+            { type: "dir", path: here2, preopen: "./" }
           );
           dot.twin = 3 + out.length - 1;
         }
@@ -4332,10 +4332,10 @@ var init_wasi_fds = __esm({
         return fd;
       }
       restartable;
-      restarting(call2) {
+      restarting(call3) {
         for (; ; ) {
           try {
-            return call2();
+            return call3();
           } catch (err) {
             if (err.code !== "EINTR" || !this.restartable?.()) throw err;
           }
@@ -4477,11 +4477,11 @@ var init_wasi_memory = __esm({
         return at;
       }
       putStrings(list, ptrs, buf) {
-        const encoder5 = new TextEncoder();
+        const encoder6 = new TextEncoder();
         const v = this.view();
         let at = buf;
         list.forEach((s, i) => {
-          const b = encoder5.encode(s);
+          const b = encoder6.encode(s);
           v.setUint32(ptrs + i * 4, at, true);
           this.bytes(at, b.length).set(b);
           v.setUint8(at + b.length, 0);
@@ -4489,12 +4489,12 @@ var init_wasi_memory = __esm({
         });
       }
       putSizes(list, countPtr, sizePtr) {
-        const encoder5 = new TextEncoder();
+        const encoder6 = new TextEncoder();
         const v = this.view();
         v.setUint32(countPtr, list.length, true);
         v.setUint32(
           sizePtr,
-          list.reduce((n, s) => n + encoder5.encode(s).length + 1, 0),
+          list.reduce((n, s) => n + encoder6.encode(s).length + 1, 0),
           true
         );
       }
@@ -4752,8 +4752,8 @@ var init_wasi_sigmask = __esm({
         return true;
       }
       pending() {
-        const own = Atomics.load(this.header, SAB_I_SIGNALS);
-        return libcBits(own | (this.process ? Atomics.load(this.process, SAB_I_SIGNALS) : 0));
+        const own2 = Atomics.load(this.header, SAB_I_SIGNALS);
+        return libcBits(own2 | (this.process ? Atomics.load(this.process, SAB_I_SIGNALS) : 0));
       }
     };
   }
@@ -4843,7 +4843,7 @@ function timeoutMs(ns) {
 }
 function wasixEpollImports(host) {
   const { mem, fds, o } = host;
-  const call2 = (req) => o.kernel.call(req);
+  const call3 = (req) => o.kernel.call(req);
   const kernelFd = (fd, refusal2) => {
     const e = fds.find(fd);
     if (!e) throw new WasiError("EBADF");
@@ -4860,7 +4860,7 @@ function wasixEpollImports(host) {
   };
   return {
     epoll_create: (out) => {
-      const fd = call2({ op: "epoll-create" });
+      const fd = call3({ op: "epoll-create" });
       fds.adopt(fd, "stream", false);
       mem.view().setUint32(out, fd, true);
     },
@@ -4872,7 +4872,7 @@ function wasixEpollImports(host) {
       if (how !== "del" && event === 0) throw new WasiError("EINVAL");
       const events = event === 0 ? 0 : mem.view().getUint32(event, true);
       const data = event === 0 ? [] : [...mem.bytes(event + DATA_OFFSET, DATA_SIZE)];
-      call2({ op: "epoll-ctl", epfd, how, fd, events, data });
+      call3({ op: "epoll-ctl", epfd, how, fd, events, data });
     },
     epoll_wait: (epfd, ptr, maxevents, timeout, out) => {
       mem.view().setUint32(out, 0, true);
@@ -4880,7 +4880,7 @@ function wasixEpollImports(host) {
       kernelFd(epfd, "EINVAL");
       const max = Math.min(maxevents | 0, MAX_EVENTS);
       const ms = host.entered ? 0 : timeoutMs(timeout);
-      const events = call2({ op: "epoll-wait", epfd, max, timeoutMs: ms });
+      const events = call3({ op: "epoll-wait", epfd, max, timeoutMs: ms });
       if (host.entered && events.length === 0 && timeoutMs(timeout) !== 0) return E.INTR;
       writeEvents2(ptr, events);
       mem.view().setUint32(out, events.length, true);
@@ -4889,7 +4889,7 @@ function wasixEpollImports(host) {
     fd_event: (initial, flags, out) => {
       const value2 = BigInt.asUintN(64, initial);
       if (value2 > EVENTFD_MAX) throw new WasiError("EINVAL");
-      const fd = call2({
+      const fd = call3({
         op: "eventfd-open",
         initial: value2.toString(),
         semaphore: (flags & EVENTFD_SEMAPHORE) !== 0
@@ -5140,12 +5140,12 @@ function optionalAddr(view, ptr) {
 }
 function datagramCalls(host) {
   const { mem, o } = host;
-  const call2 = (req) => o.kernel.call(req);
+  const call3 = (req) => o.kernel.call(req);
   return {
     recvFrom(fd, nonblock, iovs, n, riflags, outLen, outFlags, outAddr) {
       const max = Math.min(mem.capacity(iovs, n), MAX_DATAGRAM);
       const peek = (riflags & RIFLAG_PEEK) !== 0;
-      const raw = call2({ op: "sock-recvfrom", fd, max, peek, nonblock });
+      const raw = call3({ op: "sock-recvfrom", fd, max, peek, nonblock });
       const got = decodeReceived(raw);
       const view = mem.view();
       view.setUint32(outLen, mem.scatter(iovs, n, got.bytes), true);
@@ -5158,7 +5158,7 @@ function datagramCalls(host) {
       const named = optionalAddr(mem.view(), addr);
       const to = named && absolute(host.cwd, named);
       const body = mem.gather(iovs, n);
-      const sent = call2({ op: "sock-sendto", fd, body, ...to ? { addr: to } : {}, nonblock });
+      const sent = call3({ op: "sock-sendto", fd, body, ...to ? { addr: to } : {}, nonblock });
       mem.view().setUint32(out, sent, true);
       return E.SUCCESS;
     }
@@ -5166,7 +5166,7 @@ function datagramCalls(host) {
 }
 function wasixSocketImports(host, preview1) {
   const { mem, fds, o } = host;
-  const call2 = (req) => o.kernel.call(req);
+  const call3 = (req) => o.kernel.call(req);
   const socket = (fd) => {
     const e = fds.get(fd);
     if (e.type !== "kernel" || fds.kind(fd, e) !== "socket") throw new WasiError("ENOTSOCK");
@@ -5185,7 +5185,7 @@ function wasixSocketImports(host, preview1) {
   return {
     sock_open: (af, type, _proto, out) => {
       const req = openRequest2(af, type);
-      const fd = call2(req);
+      const fd = call3(req);
       fds.adopt(fd, "socket", false, "type" in req);
       mem.view().setUint32(out, fd, true);
     },
@@ -5193,7 +5193,7 @@ function wasixSocketImports(host, preview1) {
       const req = pairRequest(af, type);
       mem.view().setUint32(out1, 0, true);
       mem.view().setUint32(out2, 0, true);
-      const [a, b] = call2(req);
+      const [a, b] = call3(req);
       fds.adopt(a, "socket", false, "type" in req);
       fds.adopt(b, "socket", false, "type" in req);
       mem.view().setUint32(out1, a, true);
@@ -5201,31 +5201,31 @@ function wasixSocketImports(host, preview1) {
     },
     sock_bind: (fd, addr) => {
       socket(fd);
-      call2({ op: "sock-bind", fd, addr: absolute(host.cwd, readAddr(mem.view(), addr)) });
+      call3({ op: "sock-bind", fd, addr: absolute(host.cwd, readAddr(mem.view(), addr)) });
     },
     sock_listen: (fd, backlog) => {
       socket(fd);
-      call2({ op: "sock-listen", fd, backlog });
+      call3({ op: "sock-listen", fd, backlog });
     },
     sock_connect: (fd, addr) => {
       const e = socket(fd);
       const to = absolute(host.cwd, readAddr(mem.view(), addr));
-      call2({ op: "sock-connect", fd, addr: to, nonblock: e.nonblock });
+      call3({ op: "sock-connect", fd, addr: to, nonblock: e.nonblock });
     },
     sock_accept_v2: (fd, flags, outFd, outAddr) => {
       const e = socket(fd);
-      const r = call2({ op: "sock-accept", fd, nonblock: e.nonblock });
+      const r = call3({ op: "sock-accept", fd, nonblock: e.nonblock });
       fds.adopt(r.fd, "socket", (flags & FDFLAGS.NONBLOCK) !== 0);
       mem.view().setUint32(outFd, r.fd, true);
       writeAddr(mem.view(), outAddr, r.peer);
     },
     sock_addr_local: (fd, out) => {
       socket(fd);
-      writeAddr(mem.view(), out, call2({ op: "sock-name", fd, peer: false }));
+      writeAddr(mem.view(), out, call3({ op: "sock-name", fd, peer: false }));
     },
     sock_addr_peer: (fd, out) => {
       socket(fd);
-      writeAddr(mem.view(), out, call2({ op: "sock-name", fd, peer: true }));
+      writeAddr(mem.view(), out, call3({ op: "sock-name", fd, peer: true }));
     },
     sock_recv_from: (fd, iovs, n, riflags, outLen, outFlags, outAddr) => {
       if (datagrams(fd)) {
@@ -5241,7 +5241,7 @@ function wasixSocketImports(host, preview1) {
         outFlags
       );
       if (r !== E.SUCCESS) return r;
-      writeAddr(mem.view(), outAddr, call2({ op: "sock-name", fd, peer: true }));
+      writeAddr(mem.view(), outAddr, call3({ op: "sock-name", fd, peer: true }));
       return E.SUCCESS;
     },
     sock_send_to: (fd, iovs, n, flags, addr, out) => {
@@ -5261,24 +5261,24 @@ function wasixSocketImports(host, preview1) {
     sock_get_opt_flag: (fd, opt, out) => {
       socket(fd);
       const pair = option(opt);
-      const v = pair ? call2({ op: "sock-getopt", fd, level: pair[0], name: pair[1] }) : 0;
+      const v = pair ? call3({ op: "sock-getopt", fd, level: pair[0], name: pair[1] }) : 0;
       mem.view().setUint8(out, v ? 1 : 0);
     },
     sock_set_opt_flag: (fd, opt, flag) => {
       socket(fd);
       const pair = option(opt);
-      if (pair) call2({ op: "sock-setopt", fd, level: pair[0], name: pair[1], value: flag ? 1 : 0 });
+      if (pair) call3({ op: "sock-setopt", fd, level: pair[0], name: pair[1], value: flag ? 1 : 0 });
     },
     sock_get_opt_size: (fd, opt, out) => {
       socket(fd);
       const pair = option(opt);
-      const v = pair ? call2({ op: "sock-getopt", fd, level: pair[0], name: pair[1] }) : 0;
+      const v = pair ? call3({ op: "sock-getopt", fd, level: pair[0], name: pair[1] }) : 0;
       mem.view().setBigUint64(out, BigInt(v), true);
     },
     sock_set_opt_size: (fd, opt, size) => {
       socket(fd);
       const pair = option(opt);
-      if (pair) call2({ op: "sock-setopt", fd, level: pair[0], name: pair[1], value: Number(size) });
+      if (pair) call3({ op: "sock-setopt", fd, level: pair[0], name: pair[1], value: Number(size) });
     },
     sock_get_opt_time: (fd, _opt, out) => {
       socket(fd);
@@ -5287,7 +5287,7 @@ function wasixSocketImports(host, preview1) {
     sock_set_opt_time: (fd) => void socket(fd),
     sock_send_file: () => E.NOSYS,
     resolve: (name2, len, _port, addrs, naddrs, out) => {
-      const found = call2({ op: "sock-resolve", name: mem.string(name2, len), family: 0 });
+      const found = call3({ op: "sock-resolve", name: mem.string(name2, len), family: 0 });
       const ips = found.map(ipBytes).filter((ip) => ip !== void 0);
       if (ips.length === 0) throw new WasiError("ENOENT");
       if (naddrs < 1) throw new WasiError("EINVAL");
@@ -5339,7 +5339,7 @@ var init_wasix_sockets = __esm({
 });
 
 // src/process/wasi/wasi-host.ts
-function idOf(value2) {
+function idOf2(value2) {
   return value2 >>> 0 === 4294967295 ? void 0 : value2 >>> 0;
 }
 function linkedOf(st) {
@@ -5499,7 +5499,7 @@ var init_wasi_host = __esm({
       o;
       constructor(o) {
         const { kernel } = o;
-        const call2 = (req) => {
+        const call3 = (req) => {
           if (req.op !== "fd-promote") this.fds.flushEarly();
           return kernel.call(req);
         };
@@ -5513,7 +5513,7 @@ var init_wasi_host = __esm({
             };
           }
         });
-        this.o = { ...o, kernel: { sys, call: call2 } };
+        this.o = { ...o, kernel: { sys, call: call3 } };
         this.startCwd = o.cwd;
         this.fds = new WasiFds(this.o.kernel, o.fs);
         if (o.held) this.fds.held = o.held;
@@ -5593,9 +5593,9 @@ var init_wasi_host = __esm({
         };
         const modeOf2 = (st) => (st.mode ?? 0) & 4095;
         const chown = (path, uid, gid, follow3, handle) => {
-          const { chown: own } = this.o.fs;
-          if (!own) throw new WasiError("ENOSYS");
-          own.call(this.o.fs, path, idOf(uid), idOf(gid), follow3, handle);
+          const { chown: own2 } = this.o.fs;
+          if (!own2) throw new WasiError("ENOSYS");
+          own2.call(this.o.fs, path, idOf2(uid), idOf2(gid), follow3, handle);
         };
         const caller = () => {
           const cred = this.creds.get();
@@ -6921,13 +6921,13 @@ function importsContext({
   instance
 }) {
   const { fs } = host.o;
-  const call2 = (req) => value(raw(req));
+  const call3 = (req) => value(raw(req));
   const pathOf = (fd) => {
     const e = host.fds.get(fd);
     if (e.type === "file") return e.file.path;
     if (e.type === "dir") return e.path;
     if (e.type === "kernel" && host.fds.kind(fd, e) === "file") {
-      return call2({ op: "fd-vfs-stat", fd }).path;
+      return call3({ op: "fd-vfs-stat", fd }).path;
     }
     return void 0;
   };
@@ -6935,7 +6935,7 @@ function importsContext({
     const e = host.fds.get(fd);
     if (e.type === "file") return { path: e.file.path, size: e.file.size() };
     if (e.type === "kernel" && host.fds.kind(fd, e) === "file") {
-      return call2({ op: "fd-vfs-stat", fd });
+      return call3({ op: "fd-vfs-stat", fd });
     }
     return { path: pathOf(fd) };
   };
@@ -6947,7 +6947,7 @@ function importsContext({
   const owners = fs.owners === true;
   const live = () => {
     if (!owners) return { uid: UID, gid: UID };
-    const cred = call2({ op: "proc-cred" });
+    const cred = call3({ op: "proc-cred" });
     return { uid: cred.euid, gid: cred.egid };
   };
   const fds = {
@@ -6998,7 +6998,7 @@ function importsContext({
       const path = requirePath(fd);
       host.fds.promote(fd);
       try {
-        call2({ op: "lock", path, exclusive, fd });
+        call3({ op: "lock", path, exclusive, fd });
       } catch (err) {
         if (code(err) === "EAGAIN") return E.AGAIN;
         throw err;
@@ -7006,7 +7006,7 @@ function importsContext({
       return E.SUCCESS;
     },
     unlock(fd) {
-      call2({ op: "unlock", path: requirePath(fd), fd });
+      call3({ op: "unlock", path: requirePath(fd), fd });
     }
   };
   const ctx = {
@@ -7023,15 +7023,15 @@ function importsContext({
       }
     }),
     fds,
-    syscall: (req) => req.op === "proc-umask" ? host.umask(req.mask) : call2(req),
-    net: network(raw, call2),
-    ...processes(host, call2, tid !== MAIN_TID),
+    syscall: (req) => req.op === "proc-umask" ? host.umask(req.mask) : call3(req),
+    net: network(raw, call3),
+    ...processes(host, call3, tid !== MAIN_TID),
     async: {
-      submit: (req) => call2({ op: "async-submit", req }),
+      submit: (req) => call3({ op: "async-submit", req }),
       wait(timeoutMs2) {
         for (; ; ) {
           try {
-            return call2({
+            return call3({
               op: "async-wait",
               ...timeoutMs2 !== void 0 ? { timeoutMs: timeoutMs2 } : {}
             });
@@ -7047,10 +7047,10 @@ function importsContext({
         if (!result.ok) return { error: result.errno };
         return { value: value(result) };
       },
-      resolve: (v) => call2({ op: "async-resolve", value: v }),
-      hold: () => call2({ op: "async-hold" }),
+      resolve: (v) => call3({ op: "async-resolve", value: v }),
+      hold: () => call3({ op: "async-hold" }),
       cancel: (id) => void raw({ op: "async-cancel", id }),
-      close: () => void call2({ op: "async-close" })
+      close: () => void call3({ op: "async-close" })
     },
     errno: (err) => wasiErrnoOf(code(err))
   };
@@ -7065,12 +7065,12 @@ function loopbackHost(host) {
   if (typeof host === "string" && LOOPBACK2.test(host)) return host;
   throw new WasiError("EINVAL");
 }
-function network(raw, call2) {
+function network(raw, call3) {
   return {
     connect({ host, port: port3, nonblock = false }) {
       const to = loopbackHost(host);
       if (!Number.isInteger(port3) || port3 < 1 || port3 > 65535) throw new WasiError("EINVAL");
-      const fd = call2({ op: "sock-open", domain: "inet" });
+      const fd = call3({ op: "sock-open", domain: "inet" });
       const addr = { family: "inet", host: to, port: port3 };
       const r = raw({ op: "sock-connect", fd, addr, ...nonblock ? { nonblock: true } : {} });
       if (r.ok || nonblock && r.errno === "EINPROGRESS") return fd;
@@ -7078,18 +7078,18 @@ function network(raw, call2) {
       throw new WasiError(r.errno);
     },
     ready(fd) {
-      const sel = call2({ op: "fd-select", read: [], write: [fd], timeoutMs: 0 });
+      const sel = call3({ op: "fd-select", read: [], write: [fd], timeoutMs: 0 });
       if (!sel.write.includes(fd)) return E.INPROGRESS;
-      return call2({ op: "sock-getopt", fd, level: SOL_SOCKET, name: SO_ERROR });
+      return call3({ op: "sock-getopt", fd, level: SOL_SOCKET, name: SO_ERROR });
     }
   };
 }
-function processes(host, call2, inThread) {
-  const close = (fd) => void call2({ op: "fd-close", fd });
+function processes(host, call3, inThread) {
+  const close = (fd) => void call3({ op: "fd-close", fd });
   const slot2 = (n, how, mine, theirs) => {
     if (how === "inherit") return { fd: n };
     if (how === "null") return { none: true };
-    const [read2, write2] = call2({ op: "fd-pipe" });
+    const [read2, write2] = call3({ op: "fd-pipe" });
     mine[n] = n === 0 ? write2 : read2;
     theirs.push(n === 0 ? read2 : write2);
     return { fd: n === 0 ? read2 : write2 };
@@ -7111,7 +7111,7 @@ function processes(host, call2, inThread) {
           stdio,
           ...inThread ? {} : { restart: true }
         };
-        const pid = restarted(() => call2(req));
+        const pid = restarted(() => call3(req));
         const out = { pid };
         STDIO2.forEach((name2, n) => {
           if (mine[n] !== void 0) out[name2] = mine[n];
@@ -7128,7 +7128,7 @@ function processes(host, call2, inThread) {
     wait(pid) {
       for (; ; ) {
         try {
-          const [, status2] = call2({ op: "proc-wait", pid, nohang: false });
+          const [, status2] = call3({ op: "proc-wait", pid, nohang: false });
           host.o.fs.invalidate?.();
           const signal = status2 & 127;
           return signal ? { status: 128 + signal, signal } : { status: status2 >> 8 & 255 };
@@ -7138,7 +7138,7 @@ function processes(host, call2, inThread) {
       }
     },
     kill(pid, sig) {
-      call2({ op: "proc-kill", pid, sig });
+      call3({ op: "proc-kill", pid, sig });
     }
   };
 }
@@ -7245,7 +7245,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.158.1" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.159.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7377,14 +7377,14 @@ function fdsOf(fds) {
     return { fd, kernel: from };
   });
 }
-function groupOf(o, call2) {
-  const { pgid, session } = o;
+function groupOf(o, call3) {
+  const { pgid, session: session2 } = o;
   const valid = pgid === void 0 || Number.isInteger(pgid) && pgid >= 0;
-  if (!valid || session !== void 0 && typeof session !== "boolean") {
-    throw new JsCallError("EINVAL", call2);
+  if (!valid || session2 !== void 0 && typeof session2 !== "boolean") {
+    throw new JsCallError("EINVAL", call3);
   }
-  if (session && pgid !== void 0) throw new JsCallError("EINVAL", call2);
-  return session ? { session: true } : pgid !== void 0 ? { pgid } : {};
+  if (session2 && pgid !== void 0) throw new JsCallError("EINVAL", call3);
+  return session2 ? { session: true } : pgid !== void 0 ? { pgid } : {};
 }
 function deathOf(signal, defaults) {
   if (signal === void 0) return {};
@@ -7393,9 +7393,9 @@ function deathOf(signal, defaults) {
   }
   return { deathSignal: defaults.signal(signal) };
 }
-function argv0Of(argv0, call2) {
+function argv0Of(argv0, call3) {
   if (argv0 === void 0) return {};
-  if (typeof argv0 !== "string") throw new JsCallError("EINVAL", call2);
+  if (typeof argv0 !== "string") throw new JsCallError("EINVAL", call3);
   return { argv0 };
 }
 async function closeAll(io, fds) {
@@ -7791,11 +7791,11 @@ async function pumpFrom(kernel, handle, reader, signal) {
 function fetchOp(kernel) {
   const traits = /* @__PURE__ */ new Map();
   const traitsOf = (url) => {
-    const own = local2(url);
-    const known = traits.get(own) ?? kernel.json({ op: "net-traits", url });
-    traits.set(own, known);
+    const own2 = local2(url);
+    const known = traits.get(own2) ?? kernel.json({ op: "net-traits", url });
+    traits.set(own2, known);
     known.catch(() => {
-      traits.delete(own);
+      traits.delete(own2);
     });
     return known;
   };
@@ -8076,13 +8076,13 @@ function keyText(key, what) {
   throw new JsCallError("EINVAL", what, "ERR_INVALID_ARG_TYPE: key must be a string or bytes");
 }
 function serveRequest(tls) {
-  const own = clientCert(tls, "listen").clientCert;
+  const own2 = clientCert(tls, "listen").clientCert;
   if (tls.select !== void 0 && typeof tls.select !== "function")
     throw new JsCallError("EINVAL", "listen", "ERR_INVALID_ARG_TYPE: select must be a function");
-  if (!own && !tls.select)
+  if (!own2 && !tls.select)
     throw new JsCallError("EINVAL", "listen", "ERR_INVALID_ARG_VALUE: a server needs cert and key");
   return {
-    ...own ? { cert: own } : {},
+    ...own2 ? { cert: own2 } : {},
     ...tls.select ? { select: true } : {},
     ...tls.ca !== void 0 ? { ca: caList(tls.ca) } : {},
     ...tls.requestCert ? { requestCert: true } : {},
@@ -8171,9 +8171,9 @@ function withAlert(err) {
   const alert = ALERT.exec(err.detail ?? "")?.[1];
   return alert === void 0 ? err : Object.assign(err, { alert: Number(alert) });
 }
-async function secureCall(call2, what = "connect") {
+async function secureCall(call3, what = "connect") {
   try {
-    return await call2();
+    return await call3();
   } catch (err) {
     const e = err;
     const code2 = e.code === "EPROTO" && e.detail ? TLS_CODE.exec(e.detail)?.[1] : void 0;
@@ -8226,14 +8226,14 @@ async function selected(pick, offer, ms) {
   }
 }
 async function serveOn(kernel, conn, req, signal = NEVER, pick, ms = HANDSHAKE_TIMEOUT_MS) {
-  const call2 = (body) => secureCall(async () => {
+  const call3 = (body) => secureCall(async () => {
     const r = await kernel.blocking(body, signal);
     return r.ok && r.kind === "json" ? r.json : {};
   }, "accept");
-  let wire = await call2({ op: "sock-tls-serve", fd: conn.fd, ...req });
+  let wire = await call3({ op: "sock-tls-serve", fd: conn.fd, ...req });
   while (wire.select) {
     const { wire: choice, thrown } = await selected(pick, wire.select, ms);
-    wire = await call2({ op: "sock-tls-select", fd: conn.fd, ...choice }).catch((err) => {
+    wire = await call3({ op: "sock-tls-select", fd: conn.fd, ...choice }).catch((err) => {
       throw thrown ?? err;
     });
   }
@@ -8346,15 +8346,15 @@ function listenerOf(ops, fd, at, handshakes, tls) {
   };
 }
 async function contextOf(kernel, io, options) {
-  const own = clientCert(options ?? {}, "tlsContext").clientCert;
-  if (!own)
+  const own2 = clientCert(options ?? {}, "tlsContext").clientCert;
+  if (!own2)
     throw new JsCallError(
       "EINVAL",
       "tlsContext",
       "ERR_INVALID_ARG_VALUE: a context needs cert and key"
     );
   const fd = await secureCall(
-    () => kernel.json({ op: "sock-tls-context", cert: own }),
+    () => kernel.json({ op: "sock-tls-context", cert: own2 }),
     "tlsContext"
   );
   let closed;
@@ -8375,6 +8375,13 @@ function resetOf(kernel, fd, closed, close) {
     await close();
   };
 }
+function adoptOf(kernel, connection, listening, name2) {
+  return async (fd) => {
+    const req = { op: "sock-getopt", fd, level: SOL_SOCKET2, name: SO_ACCEPTCONN };
+    if (await kernel.json(req) !== 1) return connection(fd);
+    return listening(fd, await name2(fd, false));
+  };
+}
 function netOps(kernel, io, sync) {
   const name2 = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
   const connection = async (fd) => {
@@ -8475,9 +8482,9 @@ function netOps(kernel, io, sync) {
       const done = await kernel.blocking(req, options.signal ?? NEVER);
       return done.ok && done.kind === "json" ? done.json : void 0;
     });
-    const session = sessionOf(r);
-    if (options.socket) return Object.assign(Object.create(options.socket), { tls: session });
-    return Object.assign(await connection(r.fd), { tls: session });
+    const session2 = sessionOf(r);
+    if (options.socket) return Object.assign(Object.create(options.socket), { tls: session2 });
+    return Object.assign(await connection(r.fd), { tls: session2 });
   };
   const lookup2 = async (name3, options = {}) => {
     const family = options.family ?? 0;
@@ -8496,11 +8503,6 @@ function netOps(kernel, io, sync) {
     });
     return [...r.ok && r.kind === "json" ? r.json : []];
   };
-  const inetAt = (options) => ({
-    family: "inet",
-    host: options.host ?? "127.0.0.1",
-    port: port(options.port ?? 0)
-  });
   const listenSync = (options = {}) => {
     const lane = sync;
     const addr = inetAt(options);
@@ -8520,6 +8522,7 @@ function netOps(kernel, io, sync) {
   return {
     sync: { listen: listenSync },
     resolve: lookup2,
+    adopt: adoptOf(kernel, connection, listener, name2),
     listen: async (options = {}) => {
       const tls = options.tls ? serveRequest(options.tls) : void 0;
       return opened2(async (fd) => {
@@ -8542,7 +8545,7 @@ function netOps(kernel, io, sync) {
     }
   };
 }
-var PEM, TLS_CODE, ALERT, SHUT_RD, SHUT_WR, LOOPBACK3, IPV4, NEVER, SOL_SOCKET2, SO_ERROR2, ALERTS, HANDSHAKE_TIMEOUT_MS, HANDSHAKES_MAX;
+var PEM, TLS_CODE, ALERT, SHUT_RD, SHUT_WR, LOOPBACK3, IPV4, NEVER, SOL_SOCKET2, SO_ERROR2, SO_ACCEPTCONN, ALERTS, HANDSHAKE_TIMEOUT_MS, HANDSHAKES_MAX, inetAt;
 var init_js_net = __esm({
   "src/process/js/js-net.ts"() {
     "use strict";
@@ -8558,6 +8561,7 @@ var init_js_net = __esm({
     NEVER = new AbortController().signal;
     SOL_SOCKET2 = 1;
     SO_ERROR2 = 4;
+    SO_ACCEPTCONN = 30;
     ALERTS = {
       unrecognized_name: 112,
       no_application_protocol: 120,
@@ -8567,6 +8571,11 @@ var init_js_net = __esm({
     };
     HANDSHAKE_TIMEOUT_MS = 12e4;
     HANDSHAKES_MAX = 64;
+    inetAt = (options) => ({
+      family: "inet",
+      host: options.host ?? "127.0.0.1",
+      port: port(options.port ?? 0)
+    });
   }
 });
 
@@ -8692,13 +8701,13 @@ function needsLoad(s, view, path) {
   s.seen = view?.now();
   return true;
 }
-function loadedWatch(bridge, call2, path, st) {
+function loadedWatch(bridge, call3, path, st) {
   const view = bridge.changes;
-  return view && linkedWatch({ view, stat: () => call2(() => bridge.stat(path())) }, st);
+  return view && linkedWatch({ view, stat: () => call3(() => bridge.stat(path())) }, st);
 }
-function rangedFileOf(bridge, call2, path, io) {
+function rangedFileOf(bridge, call3, path, io) {
   const seen = bridge.changes?.now();
-  const stat = () => call2(() => bridge.stat(path()));
+  const stat = () => call3(() => bridge.stat(path()));
   const st = stat();
   const watch = bridge.changes && linkedWatch({ view: bridge.changes, ino: st.ino, seen, stat }, st);
   return new RangedFile(io, path(), st.size, st.version, watch);
@@ -8740,7 +8749,7 @@ function cachedStat(node, dir, view) {
   }
   return s.stat !== void 0 && (!dir || s.statAt === syncCallCount());
 }
-function searchParents(Fs, node, bridge, call2) {
+function searchParents(Fs, node, bridge, call3) {
   const cred = Fs.sliccCred;
   if (!cred) return;
   let cur = node.parent;
@@ -8749,12 +8758,12 @@ function searchParents(Fs, node, bridge, call2) {
     if (st && st.uid !== void 0 && st.mode !== void 0) {
       const perm = { uid: st.uid, gid: st.gid ?? 0, mode: st.mode & 4095 };
       if (!permits(cred, perm, X_OK, true)) {
-        call2(() => bridge.access?.(liveNodePath(cur), X_OK, "eaccess"));
+        call3(() => bridge.access?.(liveNodePath(cur), X_OK, "eaccess"));
         cur.live.stat = void 0;
         return;
       }
     } else {
-      call2(() => bridge.access?.(liveNodePath(cur), X_OK, "eaccess"));
+      call3(() => bridge.access?.(liveNodePath(cur), X_OK, "eaccess"));
       return;
     }
     if (cur === cur.parent) break;
@@ -8764,7 +8773,7 @@ function searchParents(Fs, node, bridge, call2) {
 function linkedStates(bridgeOf) {
   const opens = /* @__PURE__ */ new Map();
   const byId = /* @__PURE__ */ new Map();
-  const idOf4 = (st) => st?.ino === void 0 || (st.nlink ?? 1) < 2 ? void 0 : `${st.dev}:${st.ino}`;
+  const idOf5 = (st) => st?.ino === void 0 || (st.nlink ?? 1) < 2 ? void 0 : `${st.dev}:${st.ino}`;
   function know(s, id) {
     s.id = id;
     if (!byId.has(id)) byId.set(id, s);
@@ -8778,14 +8787,14 @@ function linkedStates(bridgeOf) {
       return;
     }
     opens.set(s, node);
-    const id = idOf4(s.stat);
+    const id = idOf5(s.stat);
     if (id !== void 0) know(s, id);
   }
   function sharedWith(node) {
     const st = node.live.stat;
     if (st?.ino === void 0) return void 0;
     const id = `${st.dev}:${st.ino}`;
-    if (!byId.has(id) && idOf4(st) !== void 0) {
+    if (!byId.has(id) && idOf5(st) !== void 0) {
       for (const [s2, other] of opens) {
         if (s2.id !== void 0 || s2.orphan) continue;
         let st2;
@@ -8793,7 +8802,7 @@ function linkedStates(bridgeOf) {
           st2 = bridgeOf(other).lstat(liveNodePath(other));
         } catch {
         }
-        const known = idOf4(st2);
+        const known = idOf5(st2);
         if (known !== void 0) know(s2, known);
       }
     }
@@ -8801,7 +8810,7 @@ function linkedStates(bridgeOf) {
     return s && s !== node.live && !stale(s) ? s : void 0;
   }
   const holder = (node) => opens.get(node.live) ?? node;
-  return { opening: opening2, sharedWith, know, idOf: idOf4, holder };
+  return { opening: opening2, sharedWith, know, idOf: idOf5, holder };
 }
 function filled(s, stat, asked) {
   Object.assign(s, { stat, statAt: syncCallCount(), seenAt: syncEpoch(), ...asked });
@@ -8861,7 +8870,7 @@ function relinked(Fs, moving, to) {
   Fs.hashAddNode?.(moving);
   moving.live.stat = void 0;
 }
-function renameFollower(Fs, bridgeOf, call2) {
+function renameFollower(Fs, bridgeOf, call3) {
   const open = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Map();
   const follow3 = (node, missing2 = false) => {
@@ -8877,7 +8886,7 @@ function renameFollower(Fs, bridgeOf, call2) {
       seen.set(bridge, now);
       return false;
     }
-    const reply = call2(
+    const reply = call3(
       () => ask(
         since,
         held2.map((n) => liveNodePath(n))
@@ -8980,7 +8989,7 @@ function createHelpers(Fs, ops) {
   const dirty = /* @__PURE__ */ new Set();
   const handled = /* @__PURE__ */ new Set();
   const linked = linkedStates(bridgeOf);
-  const renames = renameFollower(Fs, bridgeOf, (fn) => call2(fn));
+  const renames = renameFollower(Fs, bridgeOf, (fn) => call3(fn));
   function markDirty(node) {
     node.live.dirty = true;
     dirty.add(node);
@@ -9000,7 +9009,7 @@ function createHelpers(Fs, ops) {
       }
     }
   }
-  function call2(fn) {
+  function call3(fn) {
     try {
       return fn();
     } catch (err) {
@@ -9009,7 +9018,7 @@ function createHelpers(Fs, ops) {
   }
   function metadataCall(fn) {
     try {
-      call2(fn);
+      call3(fn);
     } catch (err) {
       if (err.errno !== wasiErrno("ENOSYS")) throw err;
     }
@@ -9029,7 +9038,7 @@ function createHelpers(Fs, ops) {
     const view = bridgeOf(node).changes;
     if (!cachedStat(node, Fs.isDir(node.mode), view)) {
       const asked = { statGen: view?.now(), filledAt: performance.now() };
-      const st = call2(() => bridgeOf(node).lstat(liveNodePath(linked.holder(node))));
+      const st = call3(() => bridgeOf(node).lstat(liveNodePath(linked.holder(node))));
       if (!adopted(node, st, asked)) return node.live.bound;
     }
     return node.live.stat;
@@ -9042,9 +9051,9 @@ function createHelpers(Fs, ops) {
     const s = node.live;
     if (!needsLoad(s, bridgeOf(node).changes, () => liveNodePath(linked.holder(node)))) return;
     const path = () => liveNodePath(linked.holder(node));
-    const bytes = call2(() => fileIo(node).readFile(path()));
+    const bytes = call3(() => fileIo(node).readFile(path()));
     Object.assign(s, { data: bytes, len: bytes.length, loaded: true });
-    s.watch = loadedWatch(bridgeOf(node), call2, path, s.stat ?? { size: bytes.length });
+    s.watch = loadedWatch(bridgeOf(node), call3, path, s.stat ?? { size: bytes.length });
   }
   function rangedOf(node) {
     const s = node.live;
@@ -9057,7 +9066,7 @@ function createHelpers(Fs, ops) {
       pwrite: (_, at, bytes, transfer) => file().pwrite(path(), at, bytes, transfer),
       truncate: (_, size) => file().truncate(path(), size)
     };
-    s.ranged = rangedFileOf(bridge, call2, path, io);
+    s.ranged = rangedFileOf(bridge, call3, path, io);
     return s.ranged;
   }
   function ensureCapacity(node, need) {
@@ -9073,7 +9082,7 @@ function createHelpers(Fs, ops) {
     const s = node.live;
     if (!s.dirty || stale(s) || !(s.data || s.ranged)) return;
     const whole = () => s.data.slice(0, s.len);
-    const write2 = () => s.ranged ? call2(() => s.ranged?.flush()) : call2(() => fileIo(node).writeFile(liveNodePath(linked.holder(node)), whole(), true));
+    const write2 = () => s.ranged ? call3(() => s.ranged?.flush()) : call3(() => fileIo(node).writeFile(liveNodePath(linked.holder(node)), whole(), true));
     followingOnce(write2, () => renames.follow(node, true));
     s.dirty = false;
     s.stat = void 0;
@@ -9105,16 +9114,16 @@ function createHelpers(Fs, ops) {
     const path = liveNodePath(node);
     const bridge = bridgeOf(node);
     if (statOf(node).ranged && bridge.truncate) {
-      call2(() => bridge.truncate?.(path, size));
+      call3(() => bridge.truncate?.(path, size));
       s.stat = void 0;
       return;
     }
     const bytes = new Uint8Array(size);
     if (size > 0) {
-      const cur = call2(() => bridgeOf(node).readFile(path));
+      const cur = call3(() => bridgeOf(node).readFile(path));
       bytes.set(cur.subarray(0, Math.min(size, cur.length)));
     }
-    call2(() => bridgeOf(node).writeFile(path, bytes));
+    call3(() => bridgeOf(node).writeFile(path, bytes));
     s.stat = void 0;
   }
   return {
@@ -9123,7 +9132,7 @@ function createHelpers(Fs, ops) {
     handled,
     linked,
     ...renames,
-    call: call2,
+    call: call3,
     metadataCall,
     makeNode,
     statOf,
@@ -9165,7 +9174,7 @@ function orphaned(h, node, st) {
   if (id !== void 0) h.linked.know(s, id);
 }
 function createNodeOps(h) {
-  const { Fs, bridgeOf, call: call2, metadataCall, makeNode, statOf, childPath, flushNode, truncate } = h;
+  const { Fs, bridgeOf, call: call3, metadataCall, makeNode, statOf, childPath, flushNode, truncate } = h;
   const { ensureLoaded } = h;
   const setTimes = (node, path, atime, mtime) => {
     const now = Fs.sliccTouch === true;
@@ -9192,7 +9201,7 @@ function createNodeOps(h) {
         node.live.stat = void 0;
       const cached2 = owned && cachedStat(node, Fs.isDir(node.mode), bridgeOf(node).changes);
       const st = statOf(node);
-      if (cached2) searchParents(Fs, node, bridgeOf(node), call2);
+      if (cached2) searchParents(Fs, node, bridgeOf(node), call3);
       const s = node.live;
       const size = Fs.isDir(node.mode) ? 4096 : s.ranged?.size() ?? (s.loaded ? s.len : st.size);
       const mtime = new Date(st.mtimeMs ?? 0);
@@ -9240,7 +9249,7 @@ function createNodeOps(h) {
       const listed2 = parent.live.listed?.get(name2);
       parent.live.listed?.delete(name2);
       const asked = listed2 ? listing(parent.live) : asking(bridgeOf(parent));
-      const st = listed2 ?? call2(() => bridgeOf(parent).lstat(childPath(parent, name2)));
+      const st = listed2 ?? call3(() => bridgeOf(parent).lstat(childPath(parent, name2)));
       return answeredAt(makeNode(parent, name2, st), asked);
     },
     mknod(parent, name2, mode) {
@@ -9249,17 +9258,17 @@ function createNodeOps(h) {
       const bridge = bridgeOf(parent);
       const perm = bridge.owners ? mode & PERM_MASK : void 0;
       if (Fs.isDir(mode) && perm !== void 0) {
-        call2(() => bridge.mkdir(path, perm));
+        call3(() => bridge.mkdir(path, perm));
       } else if (Fs.isDir(mode)) {
-        call2(() => bridge.mkdir(path));
+        call3(() => bridge.mkdir(path));
         const masked = mode & PERM_MASK & ~UMASK2;
         if (masked !== DEFAULT_DIR_PERM) metadataCall(() => bridge.chmod(path, masked));
       } else if (Fs.isFile(mode)) {
-        call2(
+        call3(
           () => bridge.create ? bridge.create(path, perm, opening.get(h.Fs) > 0) : bridge.writeFile(path, new Uint8Array(0))
         );
       } else if ((mode & S_IFMT2) === S_IFIFO2 && bridge.mkfifo) {
-        call2(() => bridge.mkfifo?.(path, mode & PERM_MASK));
+        call3(() => bridge.mkfifo?.(path, mode & PERM_MASK));
       } else {
         throw new Fs.ErrnoError(wasiErrno("EPERM"));
       }
@@ -9301,17 +9310,17 @@ function createNodeOps(h) {
         if (ranged) ranged.pin();
         else ensureLoaded(open);
       }
-      call2(() => bridgeOf(parent).unlink(childPath(parent, name2)));
+      call3(() => bridgeOf(parent).unlink(childPath(parent, name2)));
       if (open && st) orphaned(h, open, st);
     },
     rmdir(parent, name2) {
       parent.live.listed = void 0;
-      call2(() => bridgeOf(parent).rmdir(childPath(parent, name2)));
+      call3(() => bridgeOf(parent).rmdir(childPath(parent, name2)));
     },
     readdir(node) {
       const listedAt = performance.now();
       const listedGen = bridgeOf(node).changes?.now();
-      const listed2 = call2(() => bridgeOf(node).readdirStat(liveNodePath(node)));
+      const listed2 = call3(() => bridgeOf(node).readdirStat(liveNodePath(node)));
       node.live.listed = /* @__PURE__ */ new Map();
       Object.assign(node.live, { listedAt, listedGen });
       for (const [name2, st] of listed2) if (st) node.live.listed.set(name2, st);
@@ -9320,7 +9329,7 @@ function createNodeOps(h) {
     symlink(parent, newName, target) {
       parent.live.listed = void 0;
       const path = childPath(parent, newName);
-      call2(() => bridgeOf(parent).symlink(target, path));
+      call3(() => bridgeOf(parent).symlink(target, path));
       return makeNode(parent, newName, {
         isFile: false,
         isDirectory: false,
@@ -9333,9 +9342,9 @@ function createNodeOps(h) {
       const bridge = bridgeOf(node);
       const path = liveNodePath(node);
       if (bridge.links && Fs.sliccReading !== node) {
-        call2(() => bridge.access?.(path, 0, "follow", true));
+        call3(() => bridge.access?.(path, 0, "follow", true));
       }
-      return call2(() => bridge.readlink(path));
+      return call3(() => bridge.readlink(path));
     }
   };
 }
@@ -9684,13 +9693,13 @@ function liveRoot(Fs, bridge) {
   const memfs = root.memfs ?? root.node_ops;
   const live = plugin.node_ops;
   root.memfs = memfs;
-  const own = (name2) => Object.hasOwn(root.contents ?? {}, name2);
+  const own2 = (name2) => Object.hasOwn(root.contents ?? {}, name2);
   root.node_ops = {
     ...memfs,
     lookup: (parent, name2) => live.lookup(parent, name2),
     mknod: (parent, name2, mode, dev) => live.mknod(parent, name2, mode, dev),
     unlink: (parent, name2) => live.unlink(parent, name2),
-    rmdir: (parent, name2) => (own(name2) ? memfs : live).rmdir(parent, name2),
+    rmdir: (parent, name2) => (own2(name2) ? memfs : live).rmdir(parent, name2),
     symlink: (parent, name2, target) => live.symlink(parent, name2, target),
     rename: (node, dir, name2) => (node.live ? live : memfs).rename(node, dir, name2),
     readdir(node) {
@@ -9834,14 +9843,14 @@ function guardRenames(Fs) {
     rename(from, to);
   };
 }
-function idOf2(value2) {
+function idOf3(value2) {
   return value2 === -1 || value2 === 4294967295 ? void 0 : value2 >>> 0;
 }
 function chownHeld(Fs, node, s, uid, gid) {
   const bridge = node.mount.opts.bridge;
   const handle = s.handle;
   try {
-    bridge.chown?.(liveNodePath(node), idOf2(uid), idOf2(gid), false, handle);
+    bridge.chown?.(liveNodePath(node), idOf3(uid), idOf3(gid), false, handle);
   } catch (err) {
     throw toErrno(Fs, err);
   }
@@ -9863,7 +9872,7 @@ function useLiveChown(Fs) {
     const node = typeof path === "string" ? Fs.lookupPath(path, { follow: !dontFollow }).node : path;
     if (!node.live || node.live.orphan) return chown(path, uid, gid, dontFollow);
     try {
-      node.mount.opts.bridge.chown?.(liveNodePath(node), idOf2(uid), idOf2(gid));
+      node.mount.opts.bridge.chown?.(liveNodePath(node), idOf3(uid), idOf3(gid));
     } catch (err) {
       throw toErrno(Fs, err);
     }
@@ -10289,8 +10298,8 @@ function kernelTimer(setitimer, timer) {
 }
 function syscallOf(glue, name2, value2) {
   const names = Object.keys(IMPORT_NAMES);
-  const own = names.find((key) => glue[key] !== void 0 && glue[key] === value2);
-  if (own) return own;
+  const own2 = names.find((key) => glue[key] !== void 0 && glue[key] === value2);
+  if (own2) return own2;
   return typeof value2 === "function" ? names.find((key) => glue[key] !== void 0 && IMPORT_NAMES[key] === name2) : void 0;
 }
 function wrapCloexecSyscalls(imports, glue, deps) {
@@ -10314,9 +10323,9 @@ function pathOpensLinks(Fs) {
   fs.mayOpen = (node, flags) => flags & O_PATH2 && isLink.call(fs, node.mode) ? 0 : mayOpen.call(fs, node, flags);
 }
 function importKey(namespace, name2, glue) {
-  const own = glue?.[name2];
-  if (typeof own === "function") {
-    const found = Object.keys(namespace).find((k) => namespace[k] === own);
+  const own2 = glue?.[name2];
+  if (typeof own2 === "function") {
+    const found = Object.keys(namespace).find((k) => namespace[k] === own2);
     if (found !== void 0) return found;
   }
   const literal = LITERALS[name2];
@@ -10354,12 +10363,12 @@ function kernelUmask(imports, deps) {
     glue,
     (mknodat) => (dirfd, path, mode, dev) => mknodat(dirfd, path, mode & ~umask, dev)
   );
-  wrapImport(imports, "umask", glue, (own) => {
-    own(umask);
+  wrapImport(imports, "umask", glue, (own2) => {
+    own2(umask);
     return (mask) => {
       const old = umask;
       umask = mask & 511;
-      own(umask);
+      own2(umask);
       deps.set(umask);
       return old;
     };
@@ -10424,8 +10433,8 @@ function namespaces(imports) {
   return [...seen];
 }
 function keyOf(namespace, name2, glue) {
-  const own = glue?.[name2];
-  const found = typeof own === "function" ? Object.keys(namespace).find((k) => namespace[k] === own) : void 0;
+  const own2 = glue?.[name2];
+  const found = typeof own2 === "function" ? Object.keys(namespace).find((k) => namespace[k] === own2) : void 0;
   return found ?? (typeof namespace[name2] === "function" ? name2 : void 0);
 }
 function syncFsync(imports, fs, glue) {
@@ -10659,12 +10668,12 @@ function useFifoOpens(Fs, attach) {
 function useDevRemoval(Fs) {
   const fs = Fs;
   for (const name2 of ["unlink", "rmdir"]) {
-    const remove = fs[name2];
-    if (typeof remove !== "function") continue;
+    const remove2 = fs[name2];
+    if (typeof remove2 !== "function") continue;
     fs[name2] = (path) => {
       const refused3 = devRemoval(absoluteOf(path, Fs.cwd()), fs.sliccCred);
       if (refused3) throw new Fs.ErrnoError(wasiErrno(refused3));
-      remove.call(Fs, path);
+      remove2.call(Fs, path);
     };
   }
 }
@@ -10802,12 +10811,12 @@ function cString(memory, at) {
 function baseOf3(Fs, dirfd) {
   return dirfd === AT_FDCWD2 ? Fs.cwd?.() ?? "/" : Fs.getStream?.(dirfd)?.path ?? "/";
 }
-function readonlyRefusal(Fs, memory, call2) {
-  if (!(call2.amode & W_ACCESS)) return 0;
+function readonlyRefusal(Fs, memory, call3) {
+  if (!(call3.amode & W_ACCESS)) return 0;
   try {
-    const name2 = cString(memory, call2.path);
-    const abs = name2.startsWith("/") ? name2 : `${baseOf3(Fs, call2.dirfd)}/${name2}`;
-    const follow3 = (call2.flags & AT_SYMLINK_NOFOLLOW2) === 0;
+    const name2 = cString(memory, call3.path);
+    const abs = name2.startsWith("/") ? name2 : `${baseOf3(Fs, call3.dirfd)}/${name2}`;
+    const follow3 = (call3.flags & AT_SYMLINK_NOFOLLOW2) === 0;
     const { node } = Fs.lookupPath.call(Fs, abs, {
       follow: follow3
     });
@@ -10819,15 +10828,15 @@ function readonlyRefusal(Fs, memory, call2) {
     return 0;
   }
 }
-function kernelChecks(Fs, memory, call2) {
-  const name2 = cString(memory, call2.path);
-  const abs = name2.startsWith("/") ? name2 : `${baseOf3(Fs, call2.dirfd)}/${name2}`;
+function kernelChecks(Fs, memory, call3) {
+  const name2 = cString(memory, call3.path);
+  const abs = name2.startsWith("/") ? name2 : `${baseOf3(Fs, call3.dirfd)}/${name2}`;
   const lookupPath = Fs.lookupPath;
-  const { node } = lookupPath.call(Fs, abs, { follow: (call2.flags & AT_SYMLINK_NOFOLLOW2) === 0 });
+  const { node } = lookupPath.call(Fs, abs, { follow: (call3.flags & AT_SYMLINK_NOFOLLOW2) === 0 });
   const bridge = node.live ? node.mount.opts.bridge : void 0;
   if (!bridge?.owners || !bridge.access) return 0;
-  const kind = call2.flags & AT_EACCESS2 ? "eaccess" : "access";
-  bridge.access(liveNodePath(node), call2.amode, kind, (call2.flags & AT_SYMLINK_NOFOLLOW2) !== 0);
+  const kind = call3.flags & AT_EACCESS2 ? "eaccess" : "access";
+  bridge.access(liveNodePath(node), call3.amode, kind, (call3.flags & AT_SYMLINK_NOFOLLOW2) !== 0);
   return 0;
 }
 function goneCwdGetcwd(imports, fs, glue) {
@@ -10835,18 +10844,18 @@ function goneCwdGetcwd(imports, fs, glue) {
     imports,
     "getcwd",
     glue,
-    (own) => (...args) => fs()?.sliccCwdGone?.() === true ? -44 : own(...args),
+    (own2) => (...args) => fs()?.sliccCwdGone?.() === true ? -44 : own2(...args),
     true
   );
 }
 function kernelAccess(imports, fs, memory, glue) {
-  wrapImport(imports, "faccessat", glue, (own) => (dirfd, path, amode, flags) => {
+  wrapImport(imports, "faccessat", glue, (own2) => (dirfd, path, amode, flags) => {
     const Fs = fs();
     const heap = memory();
-    const call2 = { dirfd, path, amode: amode & 7, flags };
-    const refused3 = Fs?.lookupPath && heap ? readonlyRefusal(Fs, heap, call2) : 0;
+    const call3 = { dirfd, path, amode: amode & 7, flags };
+    const refused3 = Fs?.lookupPath && heap ? readonlyRefusal(Fs, heap, call3) : 0;
     if (refused3 !== 0) return refused3;
-    const rc = own(dirfd, path, amode, flags);
+    const rc = own2(dirfd, path, amode, flags);
     if (rc !== 0 || !Fs?.lookupPath || !heap) return rc;
     try {
       return kernelChecks(Fs, heap, { dirfd, path, amode: amode & 7, flags });
@@ -10860,10 +10869,10 @@ function kernelLink(imports, fs, memory, glue) {
     imports,
     "linkat",
     glue,
-    (own) => (olddirfd, oldpath, newdirfd, newpath, flags) => {
+    (own2) => (olddirfd, oldpath, newdirfd, newpath, flags) => {
       const Fs = fs();
       const heap = memory();
-      if (!Fs?.lookupPath || !heap) return own(olddirfd, oldpath, newdirfd, newpath, flags);
+      if (!Fs?.lookupPath || !heap) return own2(olddirfd, oldpath, newdirfd, newpath, flags);
       const at = (dirfd, ptr) => {
         const name2 = cString(heap, ptr);
         return name2.startsWith("/") ? name2 : `${baseOf3(Fs, dirfd)}/${name2}`;
@@ -10876,7 +10885,7 @@ function kernelLink(imports, fs, memory, glue) {
       } catch (err) {
         return -errnoOf2(err);
       }
-      return own(olddirfd, oldpath, newdirfd, newpath, flags);
+      return own2(olddirfd, oldpath, newdirfd, newpath, flags);
     },
     true
   );
@@ -10903,28 +10912,28 @@ function devCreations(imports, fs, memory, glue) {
     imports,
     "openat",
     glue,
-    (own) => (dirfd, path, flags, varargs) => flags & O_CREAT && check(dirfd, path) || own(dirfd, path, flags, varargs),
+    (own2) => (dirfd, path, flags, varargs) => flags & O_CREAT && check(dirfd, path) || own2(dirfd, path, flags, varargs),
     true
   );
   wrapImport(
     imports,
     "mkdirat",
     glue,
-    (own) => (dirfd, path, mode) => check(dirfd, path) || own(dirfd, path, mode),
+    (own2) => (dirfd, path, mode) => check(dirfd, path) || own2(dirfd, path, mode),
     true
   );
   wrapImport(
     imports,
     "mknodat",
     glue,
-    (own) => (dirfd, path, mode, dev) => check(dirfd, path) || own(dirfd, path, mode, dev),
+    (own2) => (dirfd, path, mode, dev) => check(dirfd, path) || own2(dirfd, path, mode, dev),
     true
   );
   wrapImport(
     imports,
     "symlinkat",
     glue,
-    (own) => (target, dirfd, path) => check(dirfd, path) || own(target, dirfd, path),
+    (own2) => (target, dirfd, path) => check(dirfd, path) || own2(target, dirfd, path),
     true
   );
 }
@@ -10935,9 +10944,9 @@ function kernelUname(imports, hostname, memory, glue) {
     imports,
     "uname",
     glue,
-    (own) => (buf) => {
+    (own2) => (buf) => {
       const heap = memory();
-      if (!buf || !heap) return own(buf);
+      if (!buf || !heap) return own2(buf);
       const bytes = new Uint8Array(heap.buffer, buf, UTS_FIELD * fields.length);
       bytes.fill(0);
       encoded.forEach((field2, i) => {
@@ -11286,8 +11295,8 @@ function withPidFiles(names, extra) {
 }
 function exeNodes(fresh, info, error, self) {
   return {
-    exeLink: (parent, target, own = false) => {
-      const of = info(target, own);
+    exeLink: (parent, target, own2 = false) => {
+      const of = info(target, own2);
       const exe = of?.exe;
       if (!of || exe === void 0) throw error();
       const link = fresh(parent, "exe", LINK_MODE2);
@@ -11297,7 +11306,7 @@ function exeNodes(fresh, info, error, self) {
       };
       return link;
     },
-    hasExe: (target, own = false) => info(target, own)?.exe === void 0 ? [] : ["exe"]
+    hasExe: (target, own2 = false) => info(target, own2)?.exe === void 0 ? [] : ["exe"]
   };
 }
 function useProcfs(Fs, sys, pid, memory = memorySource()) {
@@ -11348,11 +11357,11 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     };
     return node;
   };
-  const find = (processes2, target, own) => (own ? processes2.find((p) => p.tid === target) : void 0) ?? processes2.find((p) => p.pid === target || p.tid === target);
-  const infoOf = (target) => find(procList().processes, target, false);
-  const pidContent = (target, name2, own = false) => () => {
+  const find2 = (processes2, target, own2) => (own2 ? processes2.find((p) => p.tid === target) : void 0) ?? processes2.find((p) => p.pid === target || p.tid === target);
+  const infoOf = (target) => find2(procList().processes, target, false);
+  const pidContent = (target, name2, own2 = false) => () => {
     const listing2 = procList();
-    const info = find(listing2.processes, target, own);
+    const info = find2(listing2.processes, target, own2);
     if (!info) throw error();
     return pidFile(name2, info, listing2.boot);
   };
@@ -11366,7 +11375,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     dir.node_ops.readdir = () => [".", "..", ...Object.keys(tree)];
     return dir;
   };
-  const exe = exeNodes(fresh, (at, own) => find(procList().processes, at, own), error, pid);
+  const exe = exeNodes(fresh, (at, own2) => find2(procList().processes, at, own2), error, pid);
   const pidNames = (names) => withPidFiles(names, exe.hasExe(pid, true));
   const pidDir = (name2, target) => {
     const dir = fresh(proc, name2, DIR_MODE2);
@@ -11449,7 +11458,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
   };
   hashRemoveNode.call(Fs, self);
   const link = fresh(proc, "self", LINK_MODE2);
-  const shownPid = () => String(find(procList().processes, pid, true)?.pid ?? pid);
+  const shownPid = () => String(find2(procList().processes, pid, true)?.pid ?? pid);
   link.node_ops.readlink = shownPid;
   const procLookup = proc.node_ops.lookup;
   proc.node_ops.lookup = (parent, name2) => name2 === "self" ? link : name2 === shownPid() ? self : procLookup(parent, name2);
@@ -11677,7 +11686,7 @@ function shownLink(fs, tree, q) {
   }
 }
 function routing(fs, tree, toProc, shadowing) {
-  return (p, inner, own, follow3 = true, outside) => {
+  return (p, inner, own2, follow3 = true, outside) => {
     const proc = (q) => {
       const target = outside ? current(fs, tree, q) : void 0;
       return target === void 0 ? inner(q) : outside(target);
@@ -11688,7 +11697,7 @@ function routing(fs, tree, toProc, shadowing) {
       if (real !== void 0) return proc(real);
     }
     try {
-      return own();
+      return own2();
     } catch (err) {
       if (directMiss(err, p)) throw err;
       const real = toProc(p, follow3);
@@ -11704,14 +11713,14 @@ function procfsBridge(fs, tree) {
   const readOnly2 = guard(toProc, shadowing);
   const snapshots = /* @__PURE__ */ new Map();
   let lastSnapshot = 0;
-  const snapshot = (q) => {
+  const snapshot2 = (q) => {
     lastSnapshot--;
     snapshots.set(lastSnapshot, tree.read(q));
     return lastSnapshot;
   };
   const late = (p) => {
     const q = toProc(p, true);
-    return q === void 0 ? void 0 : snapshot(q);
+    return q === void 0 ? void 0 : snapshot2(q);
   };
   const over = {
     readFile: (p) => via(
@@ -11744,14 +11753,14 @@ function procfsBridge(fs, tree) {
     ),
     exists: (p) => {
       if (inProc(p)) return tree.exists(p);
-      const probe = () => {
+      const probe2 = () => {
         try {
           return toProc(p, true);
         } catch {
           return null;
         }
       };
-      const real = shadowing() ? probe() : void 0;
+      const real = shadowing() ? probe2() : void 0;
       if (real === null) return false;
       if (real !== void 0) return tree.exists(real);
       try {
@@ -11760,7 +11769,7 @@ function procfsBridge(fs, tree) {
       } catch (err) {
         if (directMiss(err, p)) return false;
       }
-      const late2 = probe();
+      const late2 = probe2();
       return typeof late2 === "string" && tree.exists(late2);
     },
     readlink: (p) => via(
@@ -11802,7 +11811,7 @@ function procfsBridge(fs, tree) {
     hold: (p, held2, open, handle, want, seen) => {
       if (handle !== void 0 && snapshots.delete(handle)) return void 0;
       if (!held2) return fs.hold?.(p, held2, open, handle);
-      return via(p, snapshot, () => fs.hold?.(p, held2, open, void 0, want, seen) ?? late(p));
+      return via(p, snapshot2, () => fs.hold?.(p, held2, open, void 0, want, seen) ?? late(p));
     },
     kept: (handle) => snapshots.has(handle) || fs.kept?.(handle) === true,
     escape: (p) => inProc(p) ? current(fs, tree, p) : void 0,
@@ -12173,6 +12182,69 @@ var init_js_proc = __esm({
   }
 });
 
+// src/process/js/js-rights.ts
+function sendmsgRequest(fd, data, options = {}) {
+  return {
+    op: "sock-sendmsg",
+    fd,
+    body: typeof data === "string" ? encoder2.encode(data) : data,
+    fds: options.fds ?? [],
+    nonblock: options.nonblock === true
+  };
+}
+function recvmsgRequest(fd, max = RECV_DEFAULT, options = {}) {
+  return {
+    op: "sock-recvmsg",
+    fd,
+    max,
+    cloexec: options.cloexec === true,
+    nonblock: options.nonblock === true
+  };
+}
+function decodeReceived2(frame) {
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const count = view.getUint32(0, true);
+  const fds = [];
+  for (let i = 0; i < count; i++) fds.push(view.getUint32(8 + i * 4, true));
+  return {
+    bytes: frame.slice(8 + count * 4),
+    fds,
+    ctrunc: (view.getUint32(4, true) & 1) === 1
+  };
+}
+async function blocked(kernel, watch, req) {
+  if (req.nonblock) return kernel.call(req);
+  const { signal, done } = watch(req.fd);
+  try {
+    return await kernel.blocking(req, signal);
+  } finally {
+    done();
+  }
+}
+function rightsAsync(kernel, forget, watch) {
+  return {
+    socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    sendmsg: async (fd, data, options) => jsonOf(await blocked(kernel, watch, sendmsgRequest(fd, data, options))),
+    async recvmsg(fd, max, options) {
+      const got = decodeReceived2(
+        bytesOf2(await blocked(kernel, watch, recvmsgRequest(fd, max, options)))
+      );
+      for (const n of got.fds) forget(n);
+      return got;
+    }
+  };
+}
+var jsonOf, bytesOf2, encoder2, RECV_DEFAULT;
+var init_js_rights = __esm({
+  "src/process/js/js-rights.ts"() {
+    "use strict";
+    jsonOf = (r) => r.ok && r.kind === "json" ? r.json : void 0;
+    bytesOf2 = (r) => r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(8);
+    encoder2 = new TextEncoder();
+    RECV_DEFAULT = 64 * 1024;
+  }
+});
+
 // src/process/js/js-run.ts
 function stdioOf(how) {
   if (how === void 0) return "pipe";
@@ -12210,7 +12282,7 @@ function runSync(kernel, d, o) {
   const named = argv0Of(o.argv0, "run");
   const stdout = stdioOf(o.stdout);
   const stderr = stderrOf(o.stderr);
-  const input = typeof o.input === "string" ? encoder2.encode(o.input) : o.input;
+  const input = typeof o.input === "string" ? encoder3.encode(o.input) : o.input;
   const maxBuffer = limit(o.maxBuffer);
   const timeout = limit(o.timeout);
   const bytes = kernel.bytes({
@@ -12233,13 +12305,13 @@ function runSync(kernel, d, o) {
   });
   return decodeRun(bytes, stdout, stderr);
 }
-var encoder2, STDIO4;
+var encoder3, STDIO4;
 var init_js_run = __esm({
   "src/process/js/js-run.ts"() {
     "use strict";
     init_js_children();
     init_js_kernel();
-    encoder2 = new TextEncoder();
+    encoder3 = new TextEncoder();
     STDIO4 = /* @__PURE__ */ new Set(["pipe", "ignore", "inherit"]);
   }
 });
@@ -12297,7 +12369,7 @@ function syncOps(kernel, shared) {
     return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
   };
   const write2 = (fd, data, options) => {
-    const bytes = typeof data === "string" ? encoder3.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
     const i = info(fd);
     if (writeDevice(i)) return bytes.length;
     const nonblock = options?.nonblock === true;
@@ -12388,6 +12460,12 @@ function syncOps(kernel, shared) {
       kernel.call({ op: "fd-close", fd });
     },
     socketpair: () => kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    sendmsg: (fd, data, options) => kernel.json(sendmsgRequest(fd, data, options)),
+    recvmsg(fd, max, options) {
+      const got = decodeReceived2(kernel.bytes(recvmsgRequest(fd, max, options)));
+      for (const n of got.fds) infos.delete(n);
+      return got;
+    },
     pipe: () => kernel.json({ op: "fd-pipe" }),
     open: procOpenSync(open, kernel, { resolve: resolve2, pid: shared.pid }),
     fs: procFsSync(syncPathOps(kernel, resolve2, statOf, open, tryDevSync), kernel, {
@@ -12534,14 +12612,14 @@ function syncPathOps(kernel, resolve2, statOf, open, tryDev) {
         ...mode !== void 0 ? { mode } : {}
       });
       try {
-        file.write(0, typeof data === "string" ? encoder3.encode(data) : data);
+        file.write(0, typeof data === "string" ? encoder4.encode(data) : data);
       } finally {
         file.close();
       }
     }
   };
 }
-var encoder3, noLane, READ_ONLY, JsSyncKernel;
+var encoder4, noLane, READ_ONLY, JsSyncKernel;
 var init_js_sync = __esm({
   "src/process/js/js-sync.ts"() {
     "use strict";
@@ -12553,7 +12631,8 @@ var init_js_sync = __esm({
     init_js_io();
     init_js_kernel();
     init_js_proc();
-    encoder3 = new TextEncoder();
+    init_js_rights();
+    encoder4 = new TextEncoder();
     noLane = () => ({ ok: false, errno: "ENOSYS", message: "no sync lane" });
     READ_ONLY = /* @__PURE__ */ new Set([...SYNC_FS_READ_ONLY, "fd-path-flush"]);
     JsSyncKernel = class {
@@ -12788,17 +12867,17 @@ var init_emscripten_vfs_hook = __esm({
 });
 
 // src/process/fd-metadata.ts
-function idOf3(value2) {
+function idOf4(value2) {
   return value2 === -1 || value2 === 4294967295 ? void 0 : value2 >>> 0;
 }
 function timeOf(value2) {
   return typeof value2 === "number" && Number.isFinite(value2) ? value2 : null;
 }
-function useKernelFdMetadata(Fs, sys, call2) {
+function useKernelFdMetadata(Fs, sys, call3) {
   const { fdChown, fdChmod, fdUtimes } = sys;
   const meta = Fs;
   const kernelFd = (stream) => stream?.sliccKernelFile ? stream.sliccKernelFd : void 0;
-  const find = (match) => {
+  const find2 = (match) => {
     for (const s of Fs.streams) {
       const kfd = s && match(s) ? kernelFd(s) : void 0;
       if (kfd !== void 0) return kfd;
@@ -12806,13 +12885,13 @@ function useKernelFdMetadata(Fs, sys, call2) {
     return void 0;
   };
   const ofPath = (path, follow3) => {
-    if (typeof path !== "string") return find((s) => s.node === path);
+    if (typeof path !== "string") return find2((s) => s.node === path);
     const fd = follow3 ? fdOfPath(path, Fs.cwd()) : void 0;
     if (fd !== void 0) return kernelFd(Fs.getStream(fd));
-    return find((s) => s.path === path);
+    return find2((s) => s.path === path);
   };
   const ofFd = (fd) => kernelFd(Fs.getStream(fd));
-  const chownBy = (kfd, uid, gid) => call2(() => fdChown?.call(sys, kfd, idOf3(uid), idOf3(gid)));
+  const chownBy = (kfd, uid, gid) => call3(() => fdChown?.call(sys, kfd, idOf4(uid), idOf4(gid)));
   if (fdChown && meta.chown) {
     const chown = meta.chown.bind(Fs);
     meta.chown = (path, uid, gid, dontFollow) => {
@@ -12834,7 +12913,7 @@ function useKernelFdMetadata(Fs, sys, call2) {
     meta.chmod = (path, mode, dontFollow) => {
       const kfd = ofPath(path, !dontFollow);
       if (kfd === void 0) return chmod(path, mode, dontFollow);
-      call2(() => fdChmod.call(sys, kfd, mode & 4095));
+      call3(() => fdChmod.call(sys, kfd, mode & 4095));
     };
   }
   if (fdChmod && meta.fchmod) {
@@ -12842,7 +12921,7 @@ function useKernelFdMetadata(Fs, sys, call2) {
     meta.fchmod = (fd, mode) => {
       const kfd = ofFd(fd);
       if (kfd === void 0) return fchmod(fd, mode);
-      call2(() => fdChmod.call(sys, kfd, mode & 4095));
+      call3(() => fdChmod.call(sys, kfd, mode & 4095));
     };
   }
   if (fdUtimes && meta.utime) {
@@ -12851,7 +12930,7 @@ function useKernelFdMetadata(Fs, sys, call2) {
       const kfd = ofPath(path, true);
       if (kfd === void 0) return utime(path, atime, mtime);
       const now = meta.sliccTouch === true;
-      call2(() => fdUtimes.call(sys, kfd, timeOf(atime), timeOf(mtime), now));
+      call3(() => fdUtimes.call(sys, kfd, timeOf(atime), timeOf(mtime), now));
     };
   }
 }
@@ -13874,13 +13953,13 @@ function ownReady(Fs, read2, write2) {
 }
 function anySelect(Fs, transport, read2, write2, timeoutMs2) {
   const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
-  const own = (fd) => kernel(fd) === void 0;
-  if (![...read2, ...write2].some(own)) return kernelSelect(Fs, transport, read2, write2, timeoutMs2);
+  const own2 = (fd) => kernel(fd) === void 0;
+  if (![...read2, ...write2].some(own2)) return kernelSelect(Fs, transport, read2, write2, timeoutMs2);
   const deadline = timeoutMs2 < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs2;
-  const kernelRead = read2.filter((fd) => !own(fd));
-  const kernelWrite = write2.filter((fd) => !own(fd));
+  const kernelRead = read2.filter((fd) => !own2(fd));
+  const kernelWrite = write2.filter((fd) => !own2(fd));
   for (; ; ) {
-    const local3 = ownReady(Fs, read2.filter(own), write2.filter(own));
+    const local3 = ownReady(Fs, read2.filter(own2), write2.filter(own2));
     const pending = local3.read.length > 0 || local3.write.length > 0;
     const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
     const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
@@ -13895,7 +13974,7 @@ function createProcessKernel(deps) {
   const { transport, Fs } = deps;
   if (deps.stdioPromoter) lockPromoters.set(Fs, deps.stdioPromoter);
   const reaped = /* @__PURE__ */ new Map();
-  const call2 = (req, label) => transport.call(req, Infinity, label);
+  const call3 = (req, label) => transport.call(req, Infinity, label);
   const at = (path) => path === "" || path.startsWith("/") ? path : `${Fs.cwd()}/${path}`;
   const slot2 = (fd, n, promote) => {
     const stream = fd >= 0 ? Fs.getStream(fd) : null;
@@ -13999,29 +14078,29 @@ function createProcessKernel(deps) {
       execCaptures.delete(pid);
       return status2;
     },
-    pause: () => status(call2({ op: "sig-pause" }, "pause")),
-    sigInherited: () => inheritedOf(call2({ op: "sig-inherited" }, "sig-inherited")),
+    pause: () => status(call3({ op: "sig-pause" }, "pause")),
+    sigInherited: () => inheritedOf(call3({ op: "sig-inherited" }, "sig-inherited")),
     mount(source, target, type, flags, data) {
       const req = { op: "mount", source, target: at(target), type, flags, data };
-      return status(call2(req, `mount ${target}`));
+      return status(call3(req, `mount ${target}`));
     },
     umount2(target, flags) {
-      return status(call2({ op: "umount", target: at(target), flags }, `umount ${target}`));
+      return status(call3({ op: "umount", target: at(target), flags }, `umount ${target}`));
     },
     kill(pid, sig) {
       if (pid === deps.pid && !throughKernel(sig)) {
         if (sig !== 0) deps.raise?.(sig);
         return 0;
       }
-      return status(call2({ op: "proc-kill", pid, sig }, `kill ${pid}`));
+      return status(call3({ op: "proc-kill", pid, sig }, `kill ${pid}`));
     },
-    setpgid: (pid, pgid) => status(call2({ op: "proc-setpgid", pid, pgid }, "setpgid")),
-    setsid: () => number(call2({ op: "proc-setsid" }, "setsid")),
-    getpgid: (pid) => number(call2({ op: "proc-getpgid", pid }, "getpgid")),
-    getsid: (pid) => number(call2({ op: "proc-getsid", pid }, "getsid")),
-    cred: () => credOf(call2({ op: "proc-cred" }, "cred")),
+    setpgid: (pid, pgid) => status(call3({ op: "proc-setpgid", pid, pgid }, "setpgid")),
+    setsid: () => number(call3({ op: "proc-setsid" }, "setsid")),
+    getpgid: (pid) => number(call3({ op: "proc-getpgid", pid }, "getpgid")),
+    getsid: (pid) => number(call3({ op: "proc-getsid", pid }, "getsid")),
+    cred: () => credOf(call3({ op: "proc-cred" }, "cred")),
     setcred(change) {
-      const cred = credOf(call2({ op: "proc-setcred", change }, "setcred"));
+      const cred = credOf(call3({ op: "proc-setcred", change }, "setcred"));
       if (typeof cred === "object" && deps.owner) {
         deps.owner.uid = cred.euid;
         deps.owner.gid = cred.egid;
@@ -14031,12 +14110,12 @@ function createProcessKernel(deps) {
     tcgetpgrp(fd) {
       const kfd = Fs.getStream(fd)?.sliccKernelFd;
       if (kfd === void 0) return -wasiErrno("ENOTTY");
-      return number(call2({ op: "tty-pgrp-get", fd: kfd }, "tcgetpgrp"));
+      return number(call3({ op: "tty-pgrp-get", fd: kfd }, "tcgetpgrp"));
     },
     tcsetpgrp(fd, pgrp) {
       const kfd = Fs.getStream(fd)?.sliccKernelFd;
       if (kfd === void 0) return -wasiErrno("ENOTTY");
-      return status(call2({ op: "tty-pgrp-set", fd: kfd, pgrp }, "tcsetpgrp"));
+      return status(call3({ op: "tty-pgrp-set", fd: kfd, pgrp }, "tcsetpgrp"));
     },
     wait(pid, nohang, options) {
       const key = pid > 0 ? reaped.has(pid) ? pid : void 0 : reaped.keys().next().value;
@@ -14074,14 +14153,14 @@ var init_process_children = __esm({
 
 // src/process/process-http.ts
 function createHttpKernel(transport) {
-  const call2 = (req) => {
+  const call3 = (req) => {
     const r = transport.call(req, Number.POSITIVE_INFINITY, req.op);
     if (!r.ok) throw new HttpError(r.errno, r.message);
     return r;
   };
   return {
     request(req) {
-      const r = call2({
+      const r = call3({
         op: "net-request",
         url: req.url,
         method: (req.method ?? "GET").toUpperCase(),
@@ -14091,10 +14170,10 @@ function createHttpKernel(transport) {
       return r.json;
     },
     read(handle, max) {
-      return call2({ op: "net-read", handle, max }).bytes;
+      return call3({ op: "net-read", handle, max }).bytes;
     },
     close(handle) {
-      call2({ op: "net-close", handle });
+      call3({ op: "net-close", handle });
     }
   };
 }
@@ -14220,8 +14299,8 @@ var init_process_signals = __esm({
           this.hooks.killed(killed);
         }
         const timers = Atomics.exchange(this.header, SAB_I_TIMERS, 0);
-        const blocked = Atomics.load(this.header, SAB_I_BLOCKED);
-        const pending = blocked === 0 ? Atomics.exchange(this.header, SAB_I_SIGNALS, 0) : Atomics.and(this.header, SAB_I_SIGNALS, blocked) & ~blocked;
+        const blocked2 = Atomics.load(this.header, SAB_I_BLOCKED);
+        const pending = blocked2 === 0 ? Atomics.exchange(this.header, SAB_I_SIGNALS, 0) : Atomics.and(this.header, SAB_I_SIGNALS, blocked2) & ~blocked2;
         if (this.depth <= 1) this.lastDelivered = pending | (timers & 1 ? sigbit(SIG.ALRM) : 0);
         if (pending !== 0 || timers !== 0) this.delivered++;
         this.raised |= pending | (timers & 1 ? sigbit(SIG.ALRM) : 0) | (timers & ~1 ? -1 : 0);
@@ -14248,17 +14327,17 @@ function resolved(Fs, addr) {
 }
 function createSocketKernel(deps) {
   const { transport, Fs, sys, streams: streams2 } = deps;
-  const call2 = (req) => {
+  const call3 = (req) => {
     const r = transport.call(req, Number.POSITIVE_INFINITY, req.op);
     if (!r.ok) throw new SyscallError(r.errno);
     return r;
   };
   const json2 = (req) => {
-    const r = call2(req);
+    const r = call3(req);
     return r.ok && r.kind === "json" ? r.json : void 0;
   };
   const done = (req) => {
-    call2(req);
+    call3(req);
     return 0;
   };
   const guard2 = (op) => {
@@ -14403,7 +14482,7 @@ function ownedBuffer(body, given) {
   return body === given ? void 0 : [body.buffer];
 }
 function kernelSys(transport) {
-  const call2 = (req, label, transfer) => {
+  const call3 = (req, label, transfer) => {
     const r = transport.call(req, Number.POSITIVE_INFINITY, label, transfer);
     if (!r.ok) throw new SyscallError(r.errno);
     return r;
@@ -14415,7 +14494,7 @@ function kernelSys(transport) {
         ...opts?.nonblock ? { nonblock: true } : {},
         ...opts?.peek ? { peek: true } : {}
       };
-      const r = call2({ op: "fd-read", fd, max, ...flags }, `fd-read ${fd}`);
+      const r = call3({ op: "fd-read", fd, max, ...flags }, `fd-read ${fd}`);
       return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
     },
     write(fd, bytes, opts) {
@@ -14426,21 +14505,21 @@ function kernelSys(transport) {
         body,
         ...opts?.nonblock ? { nonblock: true } : {}
       };
-      const n = json2(call2(req, `fd-write ${fd}`, ownedBuffer(body, bytes)));
+      const n = json2(call3(req, `fd-write ${fd}`, ownedBuffer(body, bytes)));
       return typeof n === "number" ? n : bytes.length;
     },
     close(fd) {
-      call2({ op: "fd-close", fd }, `fd-close ${fd}`);
+      call3({ op: "fd-close", fd }, `fd-close ${fd}`);
     },
     pipe() {
-      return json2(call2({ op: "fd-pipe" }, "fd-pipe"));
+      return json2(call3({ op: "fd-pipe" }, "fd-pipe"));
     },
     poll(fd) {
-      return json2(call2({ op: "fd-poll", fd }, `fd-poll ${fd}`));
+      return json2(call3({ op: "fd-poll", fd }, `fd-poll ${fd}`));
     },
     openVfs(path, flags, position, opts) {
       return json2(
-        call2(
+        call3(
           {
             op: "fd-open-vfs",
             path,
@@ -14462,126 +14541,126 @@ function kernelSys(transport) {
       );
     },
     seek(fd, offset, whence) {
-      return json2(call2({ op: "fd-seek", fd, offset, whence }, `fd-seek ${fd}`));
+      return json2(call3({ op: "fd-seek", fd, offset, whence }, `fd-seek ${fd}`));
     },
     flush(fd) {
-      call2({ op: "fd-flush", fd }, `fd-flush ${fd}`);
+      call3({ op: "fd-flush", fd }, `fd-flush ${fd}`);
     },
     pread(fd, max, at) {
-      const r = call2({ op: "fd-pread", fd, max, offset: at }, `fd-pread ${fd}`);
+      const r = call3({ op: "fd-pread", fd, max, offset: at }, `fd-pread ${fd}`);
       return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
     },
     pwrite(fd, bytes, at) {
       const body = ownBytes(bytes);
       return json2(
-        call2({ op: "fd-pwrite", fd, offset: at, body }, `fd-pwrite ${fd}`, ownedBuffer(body, bytes))
+        call3({ op: "fd-pwrite", fd, offset: at, body }, `fd-pwrite ${fd}`, ownedBuffer(body, bytes))
       );
     },
     isatty(fd) {
-      return json2(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.tty === true;
+      return json2(call3({ op: "fd-info", fd }, `fd-info ${fd}`))?.tty === true;
     },
     ttyName(fd) {
-      return json2(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.name;
+      return json2(call3({ op: "fd-info", fd }, `fd-info ${fd}`))?.name;
     },
     kind(fd) {
-      return json2(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.kind;
+      return json2(call3({ op: "fd-info", fd }, `fd-info ${fd}`))?.kind;
     },
     heldMeta(fd) {
-      return json2(call2({ op: "fd-info", fd }, `fd-info ${fd}`)).meta;
+      return json2(call3({ op: "fd-info", fd }, `fd-info ${fd}`)).meta;
     },
     access(fd) {
-      return json2(call2({ op: "fd-info", fd }, `fd-info ${fd}`)).access;
+      return json2(call3({ op: "fd-info", fd }, `fd-info ${fd}`)).access;
     },
     size(fd) {
-      return json2(call2({ op: "fd-vfs-stat", fd }, `fd-vfs-stat ${fd}`)).size;
+      return json2(call3({ op: "fd-vfs-stat", fd }, `fd-vfs-stat ${fd}`)).size;
     },
     fdStat(fd) {
-      const r = json2(call2({ op: "fd-vfs-stat", fd, full: true }, `fd-vfs-stat ${fd}`));
+      const r = json2(call3({ op: "fd-vfs-stat", fd, full: true }, `fd-vfs-stat ${fd}`));
       return r?.stat;
     },
     fdChmod(fd, mode) {
-      call2({ op: "fd-chmod", fd, mode }, `fd-chmod ${fd}`);
+      call3({ op: "fd-chmod", fd, mode }, `fd-chmod ${fd}`);
     },
     fdChown(fd, uid, gid) {
       const ids = { ...uid !== void 0 ? { uid } : {}, ...gid !== void 0 ? { gid } : {} };
-      call2({ op: "fd-chown", fd, ...ids }, `fd-chown ${fd}`);
+      call3({ op: "fd-chown", fd, ...ids }, `fd-chown ${fd}`);
     },
     fdUtimes(fd, atimeMs, mtimeMs, now) {
-      call2({ op: "fd-utimes", fd, atimeMs, mtimeMs, now }, `fd-utimes ${fd}`);
+      call3({ op: "fd-utimes", fd, atimeMs, mtimeMs, now }, `fd-utimes ${fd}`);
     },
     ttyNames() {
-      return json2(call2({ op: "fd-tty-names" }, "fd-tty-names"));
+      return json2(call3({ op: "fd-tty-names" }, "fd-tty-names"));
     },
     ttyOwner(name2) {
-      return json2(call2({ op: "fd-tty-owner", name: name2 }, `fd-tty-owner ${name2}`));
+      return json2(call3({ op: "fd-tty-owner", name: name2 }, `fd-tty-owner ${name2}`));
     },
     openTty(name2) {
       const req = name2 === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name: name2 };
-      return json2(call2(req, `fd-open-tty ${name2 ?? ""}`));
+      return json2(call3(req, `fd-open-tty ${name2 ?? ""}`));
     },
     tcgets(fd) {
-      return json2(call2({ op: "tty-get", fd }, `tty-get ${fd}`));
+      return json2(call3({ op: "tty-get", fd }, `tty-get ${fd}`));
     },
     tcsets(fd, termios, flush) {
-      call2({ op: "tty-set", fd, termios, ...flush ? { flush } : {} }, `tty-set ${fd}`);
+      call3({ op: "tty-set", fd, termios, ...flush ? { flush } : {} }, `tty-set ${fd}`);
     },
     winsize(fd) {
-      return json2(call2({ op: "tty-winsz", fd }, `tty-winsz ${fd}`));
+      return json2(call3({ op: "tty-winsz", fd }, `tty-winsz ${fd}`));
     },
     openPty() {
-      return json2(call2({ op: "pty-open" }, "pty-open"));
+      return json2(call3({ op: "pty-open" }, "pty-open"));
     },
     openPts(n, noctty) {
-      return json2(call2({ op: "pty-slave-open", n, noctty }, `pty-slave-open ${n}`));
+      return json2(call3({ op: "pty-slave-open", n, noctty }, `pty-slave-open ${n}`));
     },
     openSealed(flags) {
-      return json2(call2({ op: "fd-open-sealed", flags }, "fd-open-sealed"));
+      return json2(call3({ op: "fd-open-sealed", flags }, "fd-open-sealed"));
     },
     openClipboard(flags) {
-      return json2(call2({ op: "fd-open-clipboard", flags }, "fd-open-clipboard"));
+      return json2(call3({ op: "fd-open-clipboard", flags }, "fd-open-clipboard"));
     },
     clipboardAbort(fd) {
-      call2({ op: "fd-clipboard-abort", fd }, "fd-clipboard-abort");
+      call3({ op: "fd-clipboard-abort", fd }, "fd-clipboard-abort");
     },
     openEmbedder(flags) {
-      return json2(call2({ op: "fd-open-embedder", flags }, "fd-open-embedder"));
+      return json2(call3({ op: "fd-open-embedder", flags }, "fd-open-embedder"));
     },
     ptyNumbers() {
-      return json2(call2({ op: "pty-list" }, "pty-list"));
+      return json2(call3({ op: "pty-list" }, "pty-list"));
     },
     procList() {
-      return json2(call2({ op: "proc-list" }, "proc-list"));
+      return json2(call3({ op: "proc-list" }, "proc-list"));
     },
     mountList() {
-      return json2(call2({ op: "mount-list" }, "mount-list"));
+      return json2(call3({ op: "mount-list" }, "mount-list"));
     },
     setLock(target, kind, start2, len, wait2) {
       const req = { op: "lk-set", ...target, kind, start: start2, len, ...wait2 ? { wait: wait2 } : {} };
-      call2(req, "lk-set");
+      call3(req, "lk-set");
     },
     getLock(target, kind, start2, len) {
-      return json2(call2({ op: "lk-get", ...target, kind, start: start2, len }, "lk-get"));
+      return json2(call3({ op: "lk-get", ...target, kind, start: start2, len }, "lk-get"));
     },
     closeLocks(target) {
-      call2({ op: "lk-close", ...target }, "lk-close");
+      call3({ op: "lk-close", ...target }, "lk-close");
     },
     flock(fd, kind, wait2) {
-      call2({ op: "flock", fd, kind, ...wait2 ? { wait: wait2 } : {} }, `flock ${fd}`);
+      call3({ op: "flock", fd, kind, ...wait2 ? { wait: wait2 } : {} }, `flock ${fd}`);
     },
     ptyNumber(fd) {
-      return json2(call2({ op: "pty-number", fd }, `pty-number ${fd}`));
+      return json2(call3({ op: "pty-number", fd }, `pty-number ${fd}`));
     },
     ptyLock(fd, lock) {
-      call2({ op: "pty-lock", fd, lock }, `pty-lock ${fd}`);
+      call3({ op: "pty-lock", fd, lock }, `pty-lock ${fd}`);
     },
     setControllingTerminal(fd) {
-      call2({ op: "pty-ctty", fd }, `pty-ctty ${fd}`);
+      call3({ op: "pty-ctty", fd }, `pty-ctty ${fd}`);
     },
     setPacketMode(fd, on) {
-      call2({ op: "pty-packet", fd, on }, `pty-packet ${fd}`);
+      call3({ op: "pty-packet", fd, on }, `pty-packet ${fd}`);
     },
     setWinsize(fd, rows, cols) {
-      call2({ op: "pty-winsz-set", fd, rows, cols }, `pty-winsz-set ${fd}`);
+      call3({ op: "pty-winsz-set", fd, rows, cols }, `pty-winsz-set ${fd}`);
     }
   };
 }
@@ -14634,8 +14713,8 @@ function glueBody(glue) {
   return glue.startsWith("#!") ? glue.slice(glue.indexOf("\n") + 1) : glue;
 }
 function ownValue(module, name2) {
-  const own = Object.getOwnPropertyDescriptor(module, name2);
-  return own && "value" in own ? own.value : void 0;
+  const own2 = Object.getOwnPropertyDescriptor(module, name2);
+  return own2 && "value" in own2 ? own2.value : void 0;
 }
 function identify(transport, init) {
   const r = transport.call({ op: "proc-identity" }, Number.POSITIVE_INFINITY, "proc-identity");
@@ -14779,8 +14858,8 @@ async function runWasmProcess(init, port3, deps = {}) {
   };
   const transport = credSyncTransport(gated, () => early(), init.cred);
   const sys = kernelSys(transport);
-  const encoder5 = new TextEncoder();
-  const say = (fd) => (text) => sys.write(fd, encoder5.encode(`${text}
+  const encoder6 = new TextEncoder();
+  const say = (fd) => (text) => sys.write(fd, encoder6.encode(`${text}
 `));
   let ready;
   let failed5;
@@ -15193,7 +15272,7 @@ function preopensOf(given, resolve2) {
 function createJsWasi(deps, o = {}) {
   const transport = laneTransport(deps.lane);
   const sys = kernelSys(transport);
-  const call2 = (req) => {
+  const call3 = (req) => {
     const r = deps.lane(req);
     if (!r.ok) throw new JsCallError(r.errno, req.op);
     return r.kind === "json" ? r.json : r.kind === "bytes" ? r.bytes : void 0;
@@ -15203,13 +15282,13 @@ function createJsWasi(deps, o = {}) {
     env: { ...o.env ?? {} },
     cwd: deps.cwd,
     pid: deps.pid,
-    kernel: { sys, call: call2 },
+    kernel: { sys, call: call3 },
     fs: createSyncFsSabBridge(transport, { ...deps.fs, direct: true }),
     bare: true
   });
   const owned = deps.owned;
   const guest = /* @__PURE__ */ new Map();
-  const own = (g, k) => {
+  const own2 = (g, k) => {
     guest.set(g, k);
     owned.add(k);
   };
@@ -15226,13 +15305,13 @@ function createJsWasi(deps, o = {}) {
     (o.stdio ?? [0, 1, 2]).forEach((fd, i) => {
       const k = host.fds.adoptCopy(fd);
       opened2.push(k);
-      own(i, k);
+      own2(i, k);
     });
     for (const [name2, path] of preopensOf(o.preopens, deps.resolve)) {
       const k = host.fds.preopenAt(path, name2);
       opened2.push(k);
       const g = 3 + roots.size;
-      own(g, k);
+      own2(g, k);
       roots.set(g, path);
     }
   } catch (err) {
@@ -15259,7 +15338,7 @@ function createJsWasi(deps, o = {}) {
   const opens = (out, root) => {
     const k = view().getUint32(out, true);
     const g = free();
-    own(g, k);
+    own2(g, k);
     if (root !== void 0) roots.set(g, root);
     view().setUint32(out, g, true);
   };
@@ -15642,9 +15721,9 @@ async function selectOp(kernel, sets, signal) {
   return { read: got.read ?? [], write: got.write ?? [] };
 }
 function listen(listeners, listener) {
-  const own = (error, promise) => listener(error, promise);
-  listeners.add(own);
-  return () => void listeners.delete(own);
+  const own2 = (error, promise) => listener(error, promise);
+  listeners.add(own2);
+  return () => void listeners.delete(own2);
 }
 function identityOf(answer2, fallback) {
   const id = answer2;
@@ -15875,11 +15954,11 @@ function watchingSyncOps(kernel, syncKernel, shared) {
   };
   return { ...ops, fs: { ...ops.fs, watch } };
 }
-function pendingReads(kernel, info, random) {
+function pendingReads(kernel, info, random2) {
   const reading = /* @__PURE__ */ new Map();
   const read2 = async (fd, max = CHUNK, signal) => {
     index2(max, "read");
-    const emulated = readDevice(await info(fd), max, random);
+    const emulated = readDevice(await info(fd), max, random2);
     if (emulated) return emulated;
     const stop = new AbortController();
     const waits = reading.get(fd) ?? /* @__PURE__ */ new Set();
@@ -15898,13 +15977,23 @@ function pendingReads(kernel, info, random) {
     for (const stop of reading.get(fd) ?? []) stop.abort(new JsCallError("EBADF", "read"));
     reading.delete(fd);
   };
-  return { read: read2, closing };
+  const watch = (fd) => {
+    const stop = new AbortController();
+    const waits = reading.get(fd) ?? /* @__PURE__ */ new Set();
+    reading.set(fd, waits.add(stop));
+    const done = () => {
+      waits.delete(stop);
+      if (waits.size === 0 && reading.get(fd) === waits) reading.delete(fd);
+    };
+    return { signal: stop.signal, done };
+  };
+  return { read: read2, closing, watch };
 }
 function tracked2(pending, writeAll, writeSome, failed5) {
   return (fd, data, options) => {
     const status2 = failed5?.();
     if (status2 !== void 0) return Promise.reject(new JsExit(status2));
-    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder5.encode(data) : data;
     let settle;
     const settled2 = new Promise((resolve2) => settle = resolve2);
     pending.add(settled2);
@@ -15934,6 +16023,12 @@ function measured(measure) {
   }
   return out;
 }
+function realmOps(o) {
+  return {
+    runScript: scriptRunner(o.runScript),
+    promiseState: (promise) => o.promiseState?.(promise)
+  };
+}
 function scriptRunner(run) {
   return (source, options = {}) => {
     if (typeof source !== "string") throw new TypeError("runScript needs a source string");
@@ -15953,7 +16048,7 @@ function createContext(o) {
   const infos = /* @__PURE__ */ new Map();
   const handles = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Set();
-  const random = o.random ?? cryptoRandom;
+  const random2 = o.random ?? cryptoRandom;
   let held2;
   const resolve2 = (path) => resolvePath(cwdFor(o.cwd, held2, path), path);
   const tryDev = (abs) => resolveDevAsync(kernel, abs);
@@ -15974,7 +16069,7 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const { read: read2, closing } = pendingReads(kernel, info, random);
+  const { read: read2, closing, watch } = pendingReads(kernel, info, random2);
   const { writes, writeAll, writeSome } = writer(kernel, info, o.pid);
   const write2 = tracked2(pending, writeAll, writeSome, o.failed);
   const writable2 = (fd) => new WritableStream({
@@ -16009,7 +16104,7 @@ function createContext(o) {
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
   held2 = heldOn(o.held, lane, syncKernel);
   const terminal = ttyOps(kernel, syncKernel);
-  const shared = { pid: o.pid, resolve: resolve2, random, infos, handles, closing };
+  const shared = { pid: o.pid, resolve: resolve2, random: random2, infos, handles, closing };
   const wasi = wasiFor({ lane, pid: o.pid, cwd: o.cwd, resolve: resolve2, fs: o.fs, owned: o.owned });
   const sync = {
     kernel: KERNEL_INFO,
@@ -16028,7 +16123,7 @@ function createContext(o) {
     cred: () => syncKernel.json({ op: "proc-cred" }),
     umask: (mask) => syncKernel.json(umaskRequest(mask)),
     setcred: setcredOn(syncKernel),
-    runScript: scriptRunner(o.runScript)
+    ...realmOps(o)
   };
   const io = { read: read2, send: writeAll, close: (fd) => ctx.close(fd) };
   const defaults = { env: o.env, cwd: o.cwd, signal: signalNumber };
@@ -16054,7 +16149,7 @@ function createContext(o) {
       closing(fd);
       await kernel.call({ op: "fd-close", fd });
     },
-    socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    ...rightsAsync(kernel, (fd) => infos.delete(fd), watch),
     pipe: async () => await kernel.json({ op: "fd-pipe" }),
     select: (sets, options) => selectOp(kernel, sets, options?.signal),
     async fdStatus(fd) {
@@ -16079,7 +16174,7 @@ function createContext(o) {
       cwd: o.cwd,
       ...o.env.TERM !== void 0 ? { term: o.env.TERM } : {}
     }),
-    crontab: async (call2) => await kernel.json({ ...call2, op: "proc-crontab" }),
+    crontab: async (call3) => await kernel.json({ ...call3, op: "proc-crontab" }),
     ...children,
     net,
     websocket: websocketOp(kernel),
@@ -16284,14 +16379,14 @@ function pathOps(kernel, resolve2, statOf, open, tryDev) {
         true
       );
       try {
-        await file.write(0, typeof data === "string" ? encoder4.encode(data) : data);
+        await file.write(0, typeof data === "string" ? encoder5.encode(data) : data);
       } finally {
         await file.close();
       }
     }
   };
 }
-var KERNEL_INFO, JsExit, encoder4, cryptoRandom, MEMORY_FIELDS;
+var KERNEL_INFO, JsExit, encoder5, cryptoRandom, MEMORY_FIELDS;
 var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
@@ -16309,6 +16404,7 @@ var init_js_context = __esm({
     init_js_kernel();
     init_js_net();
     init_js_proc();
+    init_js_rights();
     init_js_run();
     init_js_sync();
     init_js_tty();
@@ -16324,7 +16420,7 @@ var init_js_context = __esm({
         this.status = status2;
       }
     };
-    encoder4 = new TextEncoder();
+    encoder5 = new TextEncoder();
     cryptoRandom = (bytes) => void crypto.getRandomValues(bytes);
     MEMORY_FIELDS = [
       "heapUsed",
@@ -16378,7 +16474,7 @@ function started(port3, control) {
     };
   });
 }
-function threadContext(post2, start2) {
+function threadContext(post3, start2) {
   const spawn = (options) => {
     let asked;
     try {
@@ -16397,7 +16493,7 @@ function threadContext(post2, start2) {
       transfer
     };
     try {
-      post2.postMessage(msg, [channel.port2, control.port2, ...transfer]);
+      post3.postMessage(msg, [channel.port2, control.port2, ...transfer]);
     } catch (err) {
       channel.port1.close();
       control.port1.close();
@@ -16510,6 +16606,7 @@ async function runJs(init, port3, deps, thread) {
     memory: deps.memory,
     asyncContext: deps.asyncContext,
     runScript: deps.runScript,
+    promiseState: deps.promiseState,
     ...thread?.owned ? { owned: thread.owned } : {},
     held: init.held,
     failed: () => failedWith
@@ -16651,9 +16748,9 @@ var init_wasi_module = __esm({
 });
 
 // src/process/wasi/wasi-ptsfs.ts
-function ptsBridge(fs, call2) {
-  const open = () => call2({ op: "pty-list" });
-  const kernel = { json: (req) => call2(req) };
+function ptsBridge(fs, call3) {
+  const open = () => call3({ op: "pty-list" });
+  const kernel = { json: (req) => call3(req) };
   const entry = (p, known = open()) => {
     const n = PTS_ENTRY.exec(p)?.[1];
     if (n === void 0 || !known.includes(Number(n))) throw syncError("ENOENT", p);
@@ -17071,8 +17168,8 @@ var init_wasix_fork = __esm({
         return out;
       }
       dataPointer() {
-        const own = this.exports[STACK_POINTER] instanceof WebAssembly.Global;
-        if (this.linked && (this.threadStack || !own)) return this.linked.low + 15 & ~15;
+        const own2 = this.exports[STACK_POINTER] instanceof WebAssembly.Global;
+        if (this.linked && (this.threadStack || !own2)) return this.linked.low + 15 & ~15;
         const g = this.exports.__data_end;
         const dataEnd = g instanceof WebAssembly.Global ? g.value : 0;
         return dataEnd < this.stackUpper ? dataEnd + 15 & ~15 : 16;
@@ -17119,9 +17216,9 @@ function write(view, at, type, value2) {
   else if (type === "f32") view.setFloat32(at, Number(value2), true);
   else view.setFloat64(at, Number(value2), true);
 }
-function scalars(types) {
-  if (types.includes("other")) throw new WasiError("EINVAL");
-  return types;
+function scalars(types2) {
+  if (types2.includes("other")) throw new WasiError("EINVAL");
+  return types2;
 }
 function callDynamic(ctx, ...operands) {
   const [id, values, valuesLen, results, resultsLen, strict] = operands.map((n) => n >>> 0);
@@ -17132,7 +17229,7 @@ function callDynamic(ctx, ...operands) {
   if (!fn || !sig) throw new WasiError("EINVAL");
   const params = scalars(sig.params);
   const outs = scalars(sig.results);
-  const size = (types) => types.reduce((n, type) => n + SIZE2[type], 0);
+  const size = (types2) => types2.reduce((n, type) => n + SIZE2[type], 0);
   if (strict && (size(params) !== valuesLen || size(outs) !== resultsLen)) {
     throw new WasiError("EINVAL");
   }
@@ -17569,7 +17666,7 @@ function growTo(memory, bytes) {
 function growTable(table, length) {
   if (table.length < length) table.grow(length - table.length);
 }
-function call(instance, name2) {
+function call2(instance, name2) {
   const fn = instance.exports[name2];
   if (typeof fn === "function") fn();
 }
@@ -17668,7 +17765,7 @@ var init_wasix_linker = __esm({
       }
       bindMain(instance, relocate) {
         this.main = instance;
-        if (relocate) call(instance, "__wasm_apply_data_relocs");
+        if (relocate) call2(instance, "__wasm_apply_data_relocs");
       }
       mainPath;
       isMain(path) {
@@ -17904,10 +18001,10 @@ var init_wasix_linker = __esm({
         if (!first || at.handle < first.handle) this.byPath.set(path, linked);
         for (const resolve2 of pending) resolve2();
         if (init) {
-          call(linked.instance, "__wasm_apply_data_relocs");
-          call(linked.instance, "__wasm_call_ctors");
+          call2(linked.instance, "__wasm_apply_data_relocs");
+          call2(linked.instance, "__wasm_call_ctors");
         } else if (!this.carryTls(linked)) {
-          call(linked.instance, "__wasix_init_tls");
+          call2(linked.instance, "__wasix_init_tls");
         }
         return linked;
       }
@@ -18716,20 +18813,20 @@ function kernelOf(init, port3, hooks = { masks: () => null, raise: () => {
   );
   const transport = gate.transport();
   const sys = kernelSys(transport);
-  const call2 = (req) => {
+  const call3 = (req) => {
     const r = transport.call(req, Number.POSITIVE_INFINITY, req.op);
     if (!r.ok) throw new SyscallError(r.errno);
     return r.kind === "json" ? r.json : r.kind === "bytes" ? r.bytes : void 0;
   };
   const say = (text) => sys.write(2, new TextEncoder().encode(`${init.argv0}: ${text}
 `));
-  return { transport, sys, call: call2, say, gate };
+  return { transport, sys, call: call3, say, gate };
 }
 function traced(stats, tag, table) {
   return stats ? stats.wrap(tag, table) : table;
 }
-function timedCalls(stats, call2) {
-  return (req) => stats.time(`kernel.${req.op}`, () => call2(req));
+function timedCalls(stats, call3) {
+  return (req) => stats.time(`kernel.${req.op}`, () => call3(req));
 }
 function report(stats, sys) {
   stats.phase("run");
@@ -18752,8 +18849,8 @@ function threadStackLow(memory, start2) {
   return stack - size;
 }
 function ownStack(driver, instance, linked, low) {
-  const own = instance.exports.__stack_pointer;
-  const pointer = own instanceof WebAssembly.Global ? own : linked;
+  const own2 = instance.exports.__stack_pointer;
+  const pointer = own2 instanceof WebAssembly.Global ? own2 : linked;
   if (!pointer) return false;
   driver.useThreadStack(pointer, low);
   return true;
@@ -18863,11 +18960,11 @@ function bindLinker(host, sync, instance, at) {
   if (at.thread || at.forked) sync.catchUp();
   sync.linker.bindMainGot();
 }
-function procTree(call2, pid) {
+function procTree(call3, pid) {
   return new ProcTree(
     {
-      procList: () => call2({ op: "proc-list" }),
-      mountList: () => call2({ op: "mount-list" })
+      procList: () => call3({ op: "proc-list" }),
+      mountList: () => call3({ op: "mount-list" })
     },
     pid
   );
@@ -18909,16 +19006,16 @@ function ownersOf(init) {
     ...init.changes ? { changes: init.changes } : {}
   };
 }
-function heldOf2(init, call2) {
+function heldOf2(init, call3) {
   const { held: held2 } = init;
   if (!held2) return {};
-  const ask = () => call2({ op: "cwd-check" });
+  const ask = () => call3({ op: "cwd-check" });
   return { held: new HeldCwd(held2.sab, held2.slot, ask, { ...held2, path: init.cwd }) };
 }
 async function runWasiProcess(init, port3) {
   captureBacktraces(init.env);
   const signals = new WasiSignals(
-    takeDefault((req) => call2(req), init.pid),
+    takeDefault((req) => call3(req), init.pid),
     (code2) => {
       throw new WasiExit(code2);
     }
@@ -18933,7 +19030,7 @@ async function runWasiProcess(init, port3) {
   } = kernelOf(init, port3, signals, sizeOf2(main));
   const id = identify(transport, init);
   const stats = init.env.SLICC_WASI_STATS === "1" ? new WasiStats() : void 0;
-  const call2 = stats ? timedCalls(stats, kernelCall) : kernelCall;
+  const call3 = stats ? timedCalls(stats, kernelCall) : kernelCall;
   const { module } = init.program;
   const refused3 = unsupportedImport(
     module,
@@ -18955,7 +19052,7 @@ async function runWasiProcess(init, port3) {
     pid: id.pid,
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
-    kernel: { sys: traced(stats, "kernel", sys), call: call2 },
+    kernel: { sys: traced(stats, "kernel", sys), call: call3 },
     fs: ptsBridge(
       procfsBridge(
         cachingBridge(
@@ -18967,12 +19064,12 @@ async function runWasiProcess(init, port3) {
           void 0,
           threads?.ids
         ),
-        procTree(call2, id.pid)
+        procTree(call3, id.pid)
       ),
-      call2
+      call3
     ),
     ...descriptors(init, fork, threads),
-    ...heldOf2(init, call2),
+    ...heldOf2(init, call3),
     ...threads ? { credGen: threads.ids } : {}
   });
   host.sigmask = sigmaskOf(module, init.sab, gate, threads);
@@ -19066,11 +19163,11 @@ function captureBacktraces(env) {
 async function runWasiThread(init, port3) {
   captureBacktraces(init.env);
   const { thread } = init;
-  const { transport, sys, call: call2, say, gate } = kernelOf(init, port3, {
+  const { transport, sys, call: call3, say, gate } = kernelOf(init, port3, {
     masks: () => null,
     raise: (sig) => signals.raise(sig)
   });
-  const signals = new WasiSignals(takeThreadDefault(call2, init.pid));
+  const signals = new WasiSignals(takeThreadDefault(call3, init.pid));
   const threads = new WasiThreads(port3, thread.memory, threadCap(init.env), thread.tid, thread.ids);
   threads.received = thread.modules;
   const id = identify(transport, init);
@@ -19081,7 +19178,7 @@ async function runWasiThread(init, port3) {
     pid: id.pid,
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
-    kernel: { sys, call: call2 },
+    kernel: { sys, call: call3 },
     fs: ptsBridge(
       procfsBridge(
         cachingBridge(
@@ -19089,12 +19186,12 @@ async function runWasiThread(init, port3) {
           void 0,
           threads.ids
         ),
-        procTree(call2, id.pid)
+        procTree(call3, id.pid)
       ),
-      call2
+      call3
     ),
     shared: threads.ids,
-    ...heldOf2(init, call2)
+    ...heldOf2(init, call3)
   });
   host.tid = thread.tid;
   host.sigmask = sigmaskOf(init.program.module, init.sab, gate, threads, init.signals);
@@ -19173,17 +19270,17 @@ var init_wasi_runtime = __esm({
     WASIX = "wasix_32v1";
     SLICC = "slicc";
     SIGNAL_CALLBACK = "__wasm_signal";
-    takeDefault = (call2, pid) => (sig) => {
-      call2({ op: "proc-kill", pid, sig });
+    takeDefault = (call3, pid) => (sig) => {
+      call3({ op: "proc-kill", pid, sig });
       if (defaultAction(sig) === "terminate") throw new WasiExit(128 + sig);
     };
-    takeThreadDefault = (call2, pid) => (sig) => {
+    takeThreadDefault = (call3, pid) => (sig) => {
       if (defaultAction(sig) !== "terminate") {
-        call2({ op: "proc-kill", pid, sig });
+        call3({ op: "proc-kill", pid, sig });
         return;
       }
       try {
-        call2({ op: "proc-kill-self", sig });
+        call3({ op: "proc-kill-self", sig });
       } catch {
       }
       throw new WasiExit(128 + sig);
@@ -19213,9 +19310,9 @@ var init_wasi_runtime = __esm({
       call;
       ids;
       owner;
-      constructor(linker, call2, threads) {
+      constructor(linker, call3, threads) {
         this.linker = linker;
-        this.call = call2;
+        this.call = call3;
         this.ids = threads?.ids;
         this.owner = threads?.tid ?? 0;
         linker.publisher = (record) => this.publish(record);
@@ -19300,6 +19397,7 @@ init_lockdown();
 import { AsyncLocalStorage } from "node:async_hooks";
 import { isBuiltin, registerHooks } from "node:module";
 import { resolve, sep } from "node:path";
+import { types } from "node:util";
 import { getHeapStatistics } from "node:v8";
 import { runInThisContext } from "node:vm";
 var NODE_GLOBALS = ["localStorage", "sessionStorage"];
@@ -19410,6 +19508,189 @@ function nodeRunScript(source, filename) {
   options.filename = filename;
   return freeze({ value: runHere(source, options), completion: true });
 }
+var isPromise = types.isPromise;
+var here = globalThis;
+var define = Reflect.defineProperty;
+var remove = Reflect.deleteProperty;
+var call = Reflect.apply;
+var hasOwn = Object.hasOwn;
+var stringify = JSON.stringify;
+var endsWith = String.prototype.endsWith;
+var sliceOf = String.prototype.slice;
+var toHex = Number.prototype.toString;
+var random = Math.random;
+var makeBigInt = BigInt;
+var builtin = process.getBuiltinModule.bind(process);
+var find = Array.prototype.find;
+var keysOf = Object.keys;
+var nothing = Object.create;
+var isList = Array.isArray;
+var seal = Object.freeze;
+var ownKeys = Reflect.ownKeys;
+var ownDescriptor = Reflect.getOwnPropertyDescriptor;
+var BASE = Object.prototype;
+function snapshot(of) {
+  const keys = ownKeys(of);
+  const out = [];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    out[i] = [key, ownDescriptor(of, key)];
+  }
+  return out;
+}
+function sameDescriptor(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  for (let i = 0; i < FIELDS.length; i++) {
+    const field2 = FIELDS[i];
+    if (own(a, field2) !== own(b, field2)) return false;
+  }
+  return true;
+}
+var FIELDS = ["value", "get", "set", "writable", "enumerable", "configurable"];
+var BASE_SNAPSHOT = snapshot(BASE);
+function baseUnchanged() {
+  const keys = ownKeys(BASE);
+  if (keys.length !== BASE_SNAPSHOT.length) return false;
+  for (let i = 0; i < keys.length; i++) {
+    const was = BASE_SNAPSHOT[i];
+    if (keys[i] !== was[0]) return false;
+    if (!sameDescriptor(ownDescriptor(BASE, keys[i]), was[1])) return false;
+  }
+  return true;
+}
+var SERIALIZED = [Array.prototype, String.prototype, Number.prototype, Boolean.prototype];
+function untouched() {
+  if (!baseUnchanged()) return false;
+  for (let i = 0; i < SERIALIZED.length; i++) {
+    if (ownDescriptor(SERIALIZED[i], "toJSON") !== void 0) return false;
+  }
+  return true;
+}
+var Failure = Error;
+var WrongType = TypeError;
+function own(from, key) {
+  return typeof from === "object" && from !== null && hasOwn(from, key) ? from[key] : void 0;
+}
+function bare(fields) {
+  const out = nothing(null);
+  const keys = keysOf(fields);
+  for (let i = 0; i < keys.length; i++) out[keys[i]] = fields[keys[i]];
+  return out;
+}
+var session;
+var inspectorGone = false;
+var probing = false;
+function post(method, params) {
+  let out;
+  let failed5;
+  let done = false;
+  call(session.post, session, [
+    method,
+    bare(params),
+    (err, result) => {
+      failed5 = err;
+      out = result;
+      done = true;
+    }
+  ]);
+  if (!done) throw new Failure("slicc-kernel: the inspector did not answer synchronously");
+  if (failed5) throw failed5;
+  return out;
+}
+function inspectorSession(load) {
+  try {
+    const made = new (load()).Session();
+    made.connect();
+    return made;
+  } catch {
+    return void 0;
+  }
+}
+function connected() {
+  if (session) return true;
+  if (inspectorGone) return false;
+  session = inspectorSession(() => builtin("node:inspector"));
+  inspectorGone = session === void 0;
+  return !inspectorGone;
+}
+function idOf(key, value2, group) {
+  if (!define(here, key, { __proto__: null, value: value2, configurable: true })) {
+    return void 0;
+  }
+  const result = own(
+    post("Runtime.evaluate", {
+      expression: `this[${stringify(key)}]`,
+      objectGroup: group,
+      includeCommandLineAPI: false,
+      silent: true,
+      returnByValue: false,
+      generatePreview: false
+    }),
+    "result"
+  );
+  return own(result, "objectId");
+}
+function primitive(remote) {
+  const raw = own(remote, "unserializableValue");
+  if (typeof raw !== "string") return own(remote, "value");
+  if (call(endsWith, raw, ["n"])) return makeBigInt(call(sliceOf, raw, [0, -1]));
+  if (raw === "NaN") return 0 / 0;
+  if (raw === "-0") return -0;
+  return raw === "Infinity" ? 1 / 0 : -1 / 0;
+}
+function internal(list, name2) {
+  if (!isList(list)) return void 0;
+  return own(call(find, list, [(item) => own(item, "name") === name2]), "value");
+}
+function probe(promise, group, key) {
+  const promiseId = idOf(key, promise, group);
+  if (promiseId === void 0) return void 0;
+  const found = own(
+    post("Runtime.getProperties", {
+      objectId: promiseId,
+      ownProperties: true,
+      generatePreview: false
+    }),
+    "internalProperties"
+  );
+  const state = own(internal(found, "[[PromiseState]]"), "value");
+  if (state === "pending") return seal({ state, value: void 0 });
+  const result = internal(found, "[[PromiseResult]]");
+  const resultId = own(result, "objectId");
+  if (typeof resultId !== "string") return seal({ state, value: primitive(result) });
+  const holder = nothing(null);
+  const holderId = idOf(key, holder, group);
+  if (holderId === void 0) return void 0;
+  post("Runtime.callFunctionOn", {
+    objectId: resultId,
+    functionDeclaration: 'function (h) { "use strict"; h.v = this; }',
+    arguments: [bare({ objectId: holderId })],
+    objectGroup: group,
+    silent: true,
+    returnByValue: false,
+    generatePreview: false
+  });
+  return seal({ state, value: holder.v });
+}
+function nodePromiseState(promise) {
+  if (!isPromise(promise)) throw new WrongType("promiseState needs a native promise");
+  if (probing) throw new Failure("slicc-kernel: promiseState is already running");
+  if (!untouched() || !connected()) return void 0;
+  probing = true;
+  const tag = call(toHex, random() * 2 ** 52, [16]);
+  const group = `slicc-promise-${tag}`;
+  const key = `__slicc_promise_${tag}`;
+  try {
+    return probe(promise, group, key);
+  } finally {
+    remove(here, key);
+    try {
+      post("Runtime.releaseObjectGroup", { objectGroup: group });
+    } finally {
+      probing = false;
+    }
+  }
+}
 var Storage = AsyncLocalStorage;
 var apply = Reflect.apply;
 var freeze = Object.freeze;
@@ -19448,7 +19729,7 @@ function started2(init, port3, run, wasi, js) {
   if (wasmInit.program?.abi === "wasi") return wasi().then((m) => m.runWasiProcess(wasmInit, port3));
   return run(wasmInit, port3);
 }
-function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs, seal = () => {
+function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs, seal2 = () => {
 }) {
   const failed5 = (err, code2) => port3.postMessage({
     type: WASM_PROCESS_ERROR,
@@ -19459,7 +19740,7 @@ function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs,
   const sealOnce = () => {
     if (refused3 === void 0) {
       try {
-        seal();
+        seal2();
         refused3 = null;
       } catch (error) {
         refused3 = { error };
@@ -19508,12 +19789,12 @@ var cacheDir = workerData?.compileCache;
 var cached = typeof cacheDir === "string" && ownCache(cacheDir, enableCompileCache(cacheDir));
 var imported = cached ? () => flushCompileCache() : void 0;
 var port2 = parentPort;
-var post = {
+var post2 = {
   postMessage: (message2, transfer) => port2.postMessage(message2, transfer)
 };
 var strayScope = nodeProcess ? { process: nodeProcess } : {};
 var onMessage = processEntry(
-  post,
+  post2,
   (init, at) => {
     workerShaped(globalThis, glueUrl(init.program?.path));
     return runWasmProcess(init, at);
@@ -19526,6 +19807,7 @@ var onMessage = processEntry(
       memory: nodeMemory,
       asyncContext: nodeAsyncContext,
       runScript: nodeRunScript,
+      promiseState: nodePromiseState,
       imported
     }),
     runJsThread: (init, at) => runJsThread(init, at, {
@@ -19534,6 +19816,7 @@ var onMessage = processEntry(
       memory: nodeMemory,
       asyncContext: nodeAsyncContext,
       runScript: nodeRunScript,
+      promiseState: nodePromiseState,
       imported
     })
   }),