@ai-ecoverse/slicc-kernel 1.74.0 → 1.75.1

package/dist/process-worker.js

@@ -1998,7 +1998,7 @@ function ptyStat(path) {
     ctime: now
   };
 }
-function sealedStat() {
+function sealedStat(minor = 250) {
   const now = /* @__PURE__ */ new Date();
   return {
     dev: 22,
@@ -2007,7 +2007,7 @@ function sealedStat() {
     nlink: 1,
     uid: 0,
     gid: 0,
-    rdev: 10 << 8 | 250,
+    rdev: 10 << 8 | minor,
     size: 0,
     blksize: 4096,
     blocks: 0,
@@ -2019,7 +2019,7 @@ function sealedStat() {
 function nonblocking(stream) {
   return (stream.flags & O_NONBLOCK) !== 0 ? { nonblock: true } : void 0;
 }
-var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, TCSETSF, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, TTY_NAME, SEALED_PATH, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC2, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
+var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, TCSETSF, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, TTY_NAME, SEALED_PATH, STRERROR, CLIPBOARD_PATH, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC2, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
 var init_kernel_streams = __esm({
   "src/process/kernel-streams.ts"() {
     "use strict";
@@ -2037,6 +2037,16 @@ var init_kernel_streams = __esm({
     TTY_PATH = /^\/dev\/tty\d+$/;
     TTY_NAME = /^tty\d+$/;
     SEALED_PATH = "/dev/sealed";
+    STRERROR = {
+      EACCES: "Permission denied",
+      EIO: "I/O error",
+      ENOTSUP: "Not supported",
+      EOPNOTSUPP: "Not supported",
+      EFBIG: "File too large",
+      EILSEQ: "Illegal byte sequence",
+      EINTR: "Interrupted system call"
+    };
+    CLIPBOARD_PATH = "/dev/clipboard";
     O_CREAT = 64;
     O_EXCL = 128;
     O_NOCTTY = 256;
@@ -2112,10 +2122,64 @@ var init_kernel_streams = __esm({
       }
       listSealed() {
         const { analyzePath, mkdev, makedev } = this.Fs;
-        if (!this.sys.openSealed || !analyzePath || !mkdev || !makedev) return;
-        if (analyzePath.call(this.Fs, SEALED_PATH).exists) return;
+        if (!analyzePath || !mkdev || !makedev) return;
+        const nodes = [
+          [SEALED_PATH, 250, this.sys.openSealed],
+          [CLIPBOARD_PATH, 251, this.sys.openClipboard]
+        ];
+        for (const [path, minor, present] of nodes) {
+          if (!present || analyzePath.call(this.Fs, path).exists) continue;
+          try {
+            mkdev.call(this.Fs, path, makedev.call(this.Fs, 10, minor));
+          } catch {
+          }
+        }
+      }
+      reporting = /* @__PURE__ */ new Set();
+      reportClose(kfd) {
+        this.reporting.add(kfd);
+      }
+      quitting = false;
+      atExit = false;
+      failedAtExit = false;
+      committed = /* @__PURE__ */ new Set();
+      exiting() {
+        this.atExit = true;
+        return () => {
+          this.atExit = false;
+        };
+      }
+      commitStdout() {
+        const kfd = this.Fs.getStream(1)?.sliccKernelFd;
+        if (kfd === void 0 || !this.reporting.delete(kfd)) return;
+        this.committed.add(kfd);
+        try {
+          this.sys.close(kfd);
+        } catch (e) {
+          if (e instanceof SyscallError) this.stdoutFailed(e.code);
+        }
+      }
+      exitStatus(status2) {
+        return this.failedAtExit && status2 === 0 ? 1 : status2;
+      }
+      reportedClose(stream, kfd) {
         try {
-          mkdev.call(this.Fs, SEALED_PATH, makedev.call(this.Fs, 10, 250));
+          this.sys.close(kfd);
+        } catch (e) {
+          if (this.quitting && stream.fd === 1 && e instanceof SyscallError) this.stdoutFailed(e.code);
+          this.call(() => {
+            throw e;
+          });
+        }
+      }
+      stdoutFailed(code2) {
+        this.failedAtExit = true;
+        const stderr = this.Fs.getStream(2)?.sliccKernelFd;
+        if (stderr === void 0) return;
+        const line = `${this.options.program ?? "program"}: write error: ${STRERROR[code2] ?? code2}
+`;
+        try {
+          this.sys.write(stderr, new TextEncoder().encode(line));
         } catch {
         }
       }
@@ -2218,7 +2282,7 @@ var init_kernel_streams = __esm({
           if (device2 !== void 0 && TTY_PATH.test(device2) && !this.terminalExists(device2)) {
             throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
           }
-          const pty = this.openPty(open, path, flags, mode) ?? this.openSealed(open, path, flags, mode);
+          const pty = this.openPty(open, path, flags, mode) ?? this.openSealed(open, path, flags, mode) ?? this.openClipboard(open, path, flags, mode);
           if (pty) return pty;
           this.refuseExclusiveLink(path, flags);
           const stream = this.openRacing(open, path, flags, mode);
@@ -2284,6 +2348,14 @@ var init_kernel_streams = __esm({
         const kfd = this.call(() => openSealed.call(this.sys));
         return this.vessel(open, kfd, { path, flags, mode }, false);
       }
+      openClipboard(open, path, flags, mode) {
+        const { openClipboard } = this.sys;
+        if (path !== CLIPBOARD_PATH || !openClipboard) return void 0;
+        const kfd = this.call(() => openClipboard.call(this.sys, flags & 3));
+        const stream = this.vessel(open, kfd, { path, flags, mode }, false);
+        this.reportClose(kfd);
+        return stream;
+      }
       vessel(open, kfd, at, terminal) {
         let stream;
         try {
@@ -2308,6 +2380,7 @@ var init_kernel_streams = __esm({
           if (typeof original !== "function") continue;
           fs[name2] = (path, ...rest2) => {
             if (path === SEALED_PATH && this.sys.openSealed) return sealedStat();
+            if (path === CLIPBOARD_PATH && this.sys.openClipboard) return sealedStat(251);
             const owned = this.ownedTty(path);
             if (owned && isPtyPath(path)) return this.owned(path, ptyStat(path));
             if (!isPtyPath(path)) {
@@ -2448,6 +2521,7 @@ var init_kernel_streams = __esm({
             this.refs.set(kfd, (this.refs.get(kfd) ?? 0) + 1);
           },
           close: (stream) => {
+            if (this.atExit && stream.fd === 2 && this.reporting.size > 0) this.commitStdout();
             try {
               base.close?.(stream);
             } catch {
@@ -2458,6 +2532,11 @@ var init_kernel_streams = __esm({
               return;
             }
             this.refs.delete(kfd);
+            if (this.committed.size > 0 && this.committed.delete(kfd)) return;
+            if (this.reporting.size > 0 && this.reporting.delete(kfd)) {
+              this.reportedClose(stream, kfd);
+              return;
+            }
             try {
               this.sys.close(kfd);
             } catch {
@@ -3308,7 +3387,7 @@ function place(Fs, stream, fd) {
 function placeholder(Fs, streams, entry) {
   if (entry.kind === "socket") return streams.socketStream(entry.flags ?? O_RDWR);
   if (entry.kind === "tty") return Fs.open("/dev/tty", O_RDWR);
-  if (entry.kind === "stream") return Fs.open("/dev/null", O_RDWR);
+  if (entry.kind === "stream" || entry.kind === "clipboard") return Fs.open("/dev/null", O_RDWR);
   Fs.mkdirTree(PLACEHOLDER_DIR);
   return Fs.open(`${PLACEHOLDER_DIR}/${entry.fd}`, O_RDWR | O_CREAT3);
 }
@@ -3332,6 +3411,7 @@ function placeKernelStream(Fs, streams, entry) {
     streams.sizeFromKernel(stream, entry.kernel);
   } else if (entry.kind === "socket") streams.attachSocket(stream, entry.kernel);
   else streams.attach(stream, entry.kernel, entry.kind === "tty");
+  if (entry.kind === "clipboard") streams.reportClose(entry.kernel);
   if (entry.kind === "tty") streams.nameTerminal(stream);
   if (entry.kind === "stream") {
     asFifo(stream, streams, entry.desc !== void 0 ? `d${entry.desc}` : `k${entry.kernel}`);
@@ -4491,6 +4571,9 @@ function kernelSys(transport) {
     openSealed() {
       return json2(call2({ op: "fd-open-sealed" }, "fd-open-sealed"));
     },
+    openClipboard(flags) {
+      return json2(call2({ op: "fd-open-clipboard", flags }, "fd-open-clipboard"));
+    },
     ptyNumbers() {
       return json2(call2({ op: "pty-list" }, "pty-list"));
     },
@@ -4647,6 +4730,8 @@ async function runWasmProcess(init, port2, deps = {}) {
   let failed5;
   let memory;
   let exports;
+  let atExit = () => () => {
+  };
   const initialized = new Promise((resolve, reject) => {
     ready = resolve;
     failed5 = reject;
@@ -4688,7 +4773,10 @@ async function runWasmProcess(init, port2, deps = {}) {
         memory = wasmMemory(instance, imports);
         exports = instance.exports;
         publishMemory(init.sab, memory?.buffer.byteLength ?? 0);
-        done(instance, init.program.module);
+        done(
+          withExitHook(instance, () => atExit()),
+          init.program.module
+        );
       }, failed5);
       return {};
     },
@@ -4721,9 +4809,17 @@ async function runWasmProcess(init, port2, deps = {}) {
   const sigpipe = () => running.sliccSigpipe?.() === 1;
   const restartable = () => signals.restartable();
   const owners = init.owners ? { owners: true } : {};
-  const streams = new KernelStreams(running.FS, sys, { sigpipe, restartable, ...owners });
+  const streams = new KernelStreams(running.FS, sys, {
+    sigpipe,
+    restartable,
+    ...owners,
+    program: init.argv0
+  });
   trackCloseOnExec(running.FS);
-  quietQuit(running.FS);
+  quietQuit(running.FS, (on) => {
+    streams.quitting = on;
+  });
+  atExit = () => streams.exiting();
   useMounts(running.FS, init.env, true);
   useZeroDevices(running.FS);
   useProcfs(running.FS, sys, init.pid);
@@ -4769,7 +4865,7 @@ async function runWasmProcess(init, port2, deps = {}) {
     restartable
   });
   try {
-    return runMain(running, init);
+    return streams.exitStatus(runMain(running, init));
   } finally {
     try {
       vfs.flush();
@@ -4777,10 +4873,27 @@ async function runWasmProcess(init, port2, deps = {}) {
     }
   }
 }
-function quietQuit(Fs) {
+function withExitHook(instance, begin) {
+  const funcs = instance.exports.__funcs_on_exit;
+  if (typeof funcs !== "function") return instance;
+  const run = funcs;
+  const exported = Object.assign(/* @__PURE__ */ Object.create(null), instance.exports, {
+    __funcs_on_exit: () => {
+      const end = begin();
+      try {
+        run();
+      } finally {
+        end();
+      }
+    }
+  });
+  return { exports: exported };
+}
+function quietQuit(Fs, quitting) {
   const { quit, close } = Fs;
   if (!quit) return;
   Fs.quit = () => {
+    quitting?.(true);
     Fs.close = (stream) => {
       try {
         close.call(Fs, stream);
@@ -4790,6 +4903,7 @@ function quietQuit(Fs) {
     try {
       quit.call(Fs);
     } finally {
+      quitting?.(false);
       Fs.close = close;
     }
   };
@@ -4842,7 +4956,7 @@ var init_process_runtime = __esm({
     O_ACCMODE4 = 3;
     O_DIRECTORY = 65536;
     accessMode = (access) => access === "read" ? O_RDONLY : access === "write" ? O_WRONLY3 : O_RDWR3;
-    PLACED = /* @__PURE__ */ new Set(["stream", "file", "socket"]);
+    PLACED = /* @__PURE__ */ new Set(["stream", "file", "socket", "clipboard"]);
     GLUE_TRAILER = [
       "if (typeof ENV !== 'undefined') Object.assign(ENV, Module.sliccEnv);",
       "const __sliccTake = (name, value) => {",
@@ -5610,7 +5724,7 @@ function promoteRequest(fd, f, handed) {
     ...f.buffer.handle !== void 0 ? { handle: f.buffer.handle } : {}
   };
 }
-var SYNTHETIC_DIRS2, O_NONBLOCK2, O_WRONLY4, O_RDWR4, O_APPEND, SEALED_PATH2, WasiFds, GEN;
+var SYNTHETIC_DIRS2, O_NONBLOCK2, O_WRONLY4, O_RDWR4, O_APPEND, SEALED_PATH2, CLIPBOARD_PATH2, WasiFds, GEN;
 var init_wasi_fds = __esm({
   "src/process/wasi/wasi-fds.ts"() {
     "use strict";
@@ -5624,6 +5738,7 @@ var init_wasi_fds = __esm({
     O_RDWR4 = 2;
     O_APPEND = 1024;
     SEALED_PATH2 = "/dev/sealed";
+    CLIPBOARD_PATH2 = "/dev/clipboard";
     WasiFds = class {
       table = /* @__PURE__ */ new Map();
       buffers = /* @__PURE__ */ new Map();
@@ -5924,9 +6039,12 @@ var init_wasi_fds = __esm({
         const e = this.get(fd);
         this.table.delete(fd);
         this.cloexec.delete(fd);
-        this.kernel.sys.close(fd);
-        this.release(e);
-        this.bump();
+        try {
+          this.kernel.sys.close(fd);
+        } finally {
+          this.release(e);
+          this.bump();
+        }
       }
       renumber(from, to, keep = false) {
         const e = this.get(from);
@@ -6089,8 +6207,8 @@ var init_wasi_fds = __esm({
         const joined2 = path.startsWith("/") ? path : `${this.dir(dirfd).path}/${path}`;
         return joined2.split("/").includes("..") ? physical(this.fs, joined2) : normalize(joined2);
       }
-      openKernelDevice(path, oflags, fdflags) {
-        const { openSealed, openTty } = this.kernel.sys;
+      openKernelDevice(path, oflags, fdflags, rights) {
+        const { openSealed, openClipboard, openTty } = this.kernel.sys;
         const nonblock = (fdflags & FDFLAGS.NONBLOCK) !== 0;
         let fd;
         let kind;
@@ -6099,6 +6217,9 @@ var init_wasi_fds = __esm({
           if (oflags & OFLAGS.CREAT && oflags & OFLAGS.EXCL) throw new WasiError("EEXIST");
           fd = openSealed.call(this.kernel.sys);
           kind = "sealed";
+        } else if (path === CLIPBOARD_PATH2 && openClipboard) {
+          fd = this.openClipboard(openClipboard, oflags, rights);
+          kind = "clipboard";
         } else if (path === "/dev/tty" || /^\/dev\/tty\d+$/.test(path)) {
           fd = openTty?.call(this.kernel.sys, path === "/dev/tty" ? void 0 : path);
           if (fd === void 0) throw new WasiError("ENXIO");
@@ -6108,10 +6229,17 @@ var init_wasi_fds = __esm({
         this.bump();
         return fd;
       }
+      openClipboard(openClipboard, oflags, rights) {
+        if (oflags & OFLAGS.DIRECTORY) throw new WasiError("ENOTDIR");
+        if (oflags & OFLAGS.CREAT && oflags & OFLAGS.EXCL) throw new WasiError("EEXIST");
+        const want = wantOf2(oflags, rights);
+        const flags = want === 6 ? O_RDWR4 : want === 2 ? O_WRONLY4 : 0;
+        return openClipboard.call(this.kernel.sys, flags);
+      }
       open(path, oflags, rights, fdflags) {
         const device2 = deviceOf(path);
         if (device2) return this.install({ type: "device", device: device2 });
-        const kernelDevice = this.openKernelDevice(path, oflags, fdflags);
+        const kernelDevice = this.openKernelDevice(path, oflags, fdflags, rights);
         if (kernelDevice !== void 0) return kernelDevice;
         const alias = stdioAlias(path);
         if (alias !== void 0) return this.reopen(alias);
@@ -6554,6 +6682,7 @@ function kernelFiletype(kind) {
   switch (kind) {
     case "tty":
     case "sealed":
+    case "clipboard":
       return { filetype: FILETYPE.CHARACTER_DEVICE, seeks: false };
     case "device":
       return { filetype: FILETYPE.CHARACTER_DEVICE, seeks: true };
@@ -6711,7 +6840,7 @@ var init_wasi_host = __esm({
           const e = fds.get(fd);
           if (e.type === "device") return ROOT_IDS;
           const kind = e.type === "kernel" ? fds.kind(fd, e) : "file";
-          if (kind === "sealed") return ROOT_IDS;
+          if (kind === "sealed" || kind === "clipboard") return ROOT_IDS;
           if (kind !== "file") return void 0;
           try {
             return this.o.fs.stat(pathOf(fd));
@@ -6768,12 +6897,12 @@ var init_wasi_host = __esm({
           fd_mode: (fd, out) => {
             const e = fds.get(fd);
             const kind = e.type === "kernel" ? fds.kind(fd, e) : void 0;
-            const mode = kind === "stream" ? S_IFIFO | 384 : kind === "sealed" ? SEALED_MODE : modeOf(this.o.fs.stat(pathOf(fd)));
+            const mode = kind === "stream" ? S_IFIFO | 384 : kind === "sealed" || kind === "clipboard" ? SEALED_MODE : modeOf(this.o.fs.stat(pathOf(fd)));
             mem.view().setUint32(out, mode, true);
           },
           path_mode: (dirfd, p, l, flags, out) => {
             const path = at(dirfd, p, l);
-            if (path === SEALED_PATH2 && this.o.kernel.sys.openSealed)
+            if (this.synthetic(path) && deviceOf(path) === void 0)
               return void mem.view().setUint32(out, SEALED_MODE, true);
             const st = flags & AT_SYMLINK_NOFOLLOW2 ? this.o.fs.lstat(path) : this.o.fs.stat(path);
             mem.view().setUint32(out, modeOf(st), true);
@@ -7276,7 +7405,7 @@ var init_wasi_host = __esm({
         return gone ? { ...out, nlink: 0n } : out;
       }
       synthetic(path) {
-        return deviceOf(path) !== void 0 || path === SEALED_PATH2 && !!this.o.kernel.sys.openSealed;
+        return deviceOf(path) !== void 0 || path === SEALED_PATH2 && !!this.o.kernel.sys.openSealed || path === CLIPBOARD_PATH2 && !!this.o.kernel.sys.openClipboard;
       }
       pathFilestat(path, lookup2) {
         if (this.synthetic(path)) {
@@ -10873,6 +11002,11 @@ var init_async_sab = __esm({
 });
 
 // src/process/js/js-kernel.ts
+function callError(result, op) {
+  const { errno: errno2, message: message2 } = result;
+  const detailed = typeof message2 === "string" && message2 !== errno2 && DETAILED.has(op);
+  return new JsCallError(errno2, detailed ? `${op}: ${message2}` : op);
+}
 function untilAborted(work, signal) {
   if (!signal) return work;
   return new Promise((resolve) => {
@@ -10889,7 +11023,7 @@ function caughtOf(handlers) {
   for (const sig of handlers.keys()) caught |= sigbit(sig);
   return caught;
 }
-var JsCallError, JsKernel;
+var JsCallError, DETAILED, JsKernel;
 var init_js_kernel = __esm({
   "src/process/js/js-kernel.ts"() {
     "use strict";
@@ -10904,6 +11038,12 @@ var init_js_kernel = __esm({
         this.code = code2;
       }
     };
+    DETAILED = /* @__PURE__ */ new Set([
+      "fd-read",
+      "fd-write",
+      "fd-close",
+      "fd-open-clipboard"
+    ]);
     JsKernel = class {
       header;
       transport;
@@ -10930,7 +11070,7 @@ var init_js_kernel = __esm({
       }
       async call(req) {
         const result = await this.raw(req);
-        if (!result.ok) throw new JsCallError(result.errno, req.op);
+        if (!result.ok) throw callError(result, req.op);
         return result;
       }
       async json(req) {
@@ -10946,7 +11086,7 @@ var init_js_kernel = __esm({
           const id = await this.submit(req, track);
           const result = await this.settled(id, signal);
           if (result.ok) return result;
-          if (result.errno !== "EINTR") throw new JsCallError(result.errno, req.op);
+          if (result.errno !== "EINTR") throw callError(result, req.op);
         }
       }
       acks = [];
@@ -11326,6 +11466,7 @@ function* lookup(abs) {
   const name2 = abs.slice("/dev/".length);
   if (DEVICES2.includes(name2)) return { kind: "device" };
   if (name2 === "tty") return { kind: "tty" };
+  if (name2 === "clipboard") return { kind: "clipboard" };
   const std = STDIO3.indexOf(name2);
   if (std >= 0) return { kind: "link", target: `${SELF_FD}/${std}`, fd: std };
   if (name2 === "fd") return { kind: "link", target: SELF_FD };
@@ -11369,7 +11510,8 @@ function* fdStat(fd, path) {
     return yield* pathStat(file.path);
   }
   if (info.terminal) return yield* terminalStat(info.terminal);
-  if (info.kind === "device" || info.kind === "tty") return nodeStat(CHAR | 438);
+  if (info.kind === "device" || info.kind === "tty" || info.kind === "clipboard")
+    return nodeStat(CHAR | 438);
   if (info.kind === "socket") return nodeStat(49663);
   return nodeStat(4480);
 }
@@ -11379,6 +11521,7 @@ function* fdTarget(fd, path) {
   if (info.kind === "file") return (yield { op: "fd-vfs-stat", fd }).path;
   if (info.terminal) return info.terminal;
   if (info.meta && "device" in info.meta) return `/dev/${info.meta.device}`;
+  if (info.kind === "clipboard") return "/dev/clipboard";
   return `${info.kind === "socket" ? "socket" : "pipe"}:[${fd}]`;
 }
 function linkStat(target) {
@@ -11391,6 +11534,7 @@ function* devStat(abs, follow2) {
       return nodeStat(node.mode);
     case "device":
     case "tty":
+    case "clipboard":
       return nodeStat(CHAR | 438);
     case "terminal":
       return yield* terminalStat(node.name);
@@ -11425,7 +11569,7 @@ function* devReaddir(abs) {
   if (node.kind !== "dir") throw new JsCallError("ENOTDIR", abs);
   const names = yield { op: "fd-tty-names" };
   const ttys = names.filter((n) => /^\/dev\/tty\d+$/.test(n)).map((n) => n.slice(5));
-  return [...DEVICES2, "tty", "fd", ...STDIO3, ...ttys].sort();
+  return [...DEVICES2, "clipboard", "tty", "fd", ...STDIO3, ...ttys].sort();
 }
 function* aliasOf(fd, abs, o) {
   const info = yield* fdInfo(fd, abs);
@@ -11454,6 +11598,11 @@ function* opened(abs, o) {
       return { fd: yield openRequest(abs, { ...o, create: false }), file: false };
     case "tty":
       return { fd: yield { op: "fd-open-tty" }, file: false };
+    case "clipboard": {
+      const write2 = o.write === true || o.append === true || o.truncate === true;
+      const flags = write2 ? o.read === true ? 2 : 1 : 0;
+      return { fd: yield { op: "fd-open-clipboard", flags }, file: false };
+    }
     case "terminal": {
       const req = node.pts === void 0 ? { op: "fd-open-tty", name: node.name } : { op: "pty-slave-open", n: node.pts, noctty: true };
       return { fd: yield req, file: false };
@@ -12496,7 +12645,7 @@ var init_js_sync = __esm({
       }
       call(req) {
         const result = this.raw(req);
-        if (!result.ok) throw new JsCallError(result.errno, req.op);
+        if (!result.ok) throw callError(result, req.op);
         return result;
       }
       json(req) {
@@ -12511,7 +12660,7 @@ var init_js_sync = __esm({
         for (; ; ) {
           const result = this.raw(req);
           if (result.ok) return result;
-          if (result.errno !== "EINTR") throw new JsCallError(result.errno, req.op);
+          if (result.errno !== "EINTR") throw callError(result, req.op);
         }
       }
     };
@@ -13103,7 +13252,7 @@ async function receiveSome(kernel, fd, max, signal) {
     signal.throwIfAborted();
     const r = await kernel.raw({ op: "fd-read", fd, max, nonblock: true });
     if (r.ok) return r.kind === "bytes" ? r.bytes : new Uint8Array(0);
-    if (r.errno !== "EAGAIN") throw new JsCallError(r.errno, "fd-read");
+    if (r.errno !== "EAGAIN") throw callError(r, "fd-read");
     await kernel.blocking({ op: "fd-select", read: [fd], write: [], timeoutMs: -1 }, signal);
   }
 }
@@ -13112,7 +13261,7 @@ async function sendSome(kernel, fd, body, signal) {
     signal.throwIfAborted();
     const r = await kernel.raw({ op: "fd-write", fd, body, nonblock: true });
     if (r.ok) return written(r, body.length);
-    if (r.errno !== "EAGAIN") throw new JsCallError(r.errno, "fd-write");
+    if (r.errno !== "EAGAIN") throw callError(r, "fd-write");
     await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
   }
 }