@ai-ecoverse/slicc-kernel 1.181.0 → 1.183.0

package/dist/process-worker.js

@@ -2994,8 +2994,8 @@ function linkLive(Fs, from, to, follow3) {
   try {
     bridge.link(path, base === "/" ? `/${name2}` : `${base}/${name2}`);
   } catch (err) {
-    const refused2 = toErrno(Fs, err);
-    if (refused2.errno !== wasiErrno("EPERM") || linkable(bridge, path)) throw refused2;
+    const refused3 = toErrno(Fs, err);
+    if (refused3.errno !== wasiErrno("EPERM") || linkable(bridge, path)) throw refused3;
     throw new Fs.ErrnoError(wasiErrno("EMLINK"));
   }
   source.live.stat = void 0;
@@ -3180,7 +3180,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.181.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.183.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -3226,8 +3226,8 @@ function writeHolder(view, at, found) {
   view.setInt32(at + 24, found.pid, true);
 }
 function refused(kind, flags) {
-  const access = flags & O_ACCMODE2;
-  return kind === "write" && access === O_RDONLY || kind === "read" && access === O_WRONLY;
+  const access2 = flags & O_ACCMODE2;
+  return kind === "write" && access2 === O_RDONLY || kind === "read" && access2 === O_WRONLY;
 }
 function baseOf(Fs, stream) {
   return (whence) => whence === SEEK_CUR2 ? stream.position : whence === SEEK_END2 ? sizeOf(Fs, stream) : 0;
@@ -3323,15 +3323,221 @@ var init_process_locks = __esm({
   }
 });
 
+// src/kernel/serial-ioctl.ts
+function codeOf(speed) {
+  const low = SPEEDS.indexOf(speed);
+  if (low >= 0) return low;
+  const high = FAST.indexOf(speed);
+  return high > 0 ? BOTHER | high : BOTHER;
+}
+function settingsOf(cflag, baudRate) {
+  return {
+    baudRate,
+    dataBits: 5 + ((cflag & CSIZE) >> 4),
+    parity: cflag & PARENB ? cflag & PARODD ? "odd" : "even" : "none",
+    stopBits: cflag & CSTOPB ? 2 : 1,
+    flowControl: cflag & CRTSCTS ? "hardware" : "none"
+  };
+}
+function readFlags(view, at, ncc) {
+  const cCc = new capturedArray(NCCS).fill(0);
+  for (let i = 0; i < ncc; i++) cCc[i] = view.getUint8(at + C_CC + i);
+  return {
+    c_iflag: view.getUint32(at, true),
+    c_oflag: view.getUint32(at + 4, true),
+    c_cflag: view.getUint32(at + 8, true),
+    c_lflag: view.getUint32(at + 12, true),
+    c_cc: cCc
+  };
+}
+function writeFlags(view, at, t, ncc) {
+  view.setUint32(at, t.c_iflag >>> 0, true);
+  view.setUint32(at + 4, t.c_oflag >>> 0, true);
+  view.setUint32(at + 8, t.c_cflag >>> 0, true);
+  view.setUint32(at + 12, t.c_lflag >>> 0, true);
+  view.setUint8(at + C_LINE, 0);
+  for (let i = 0; i < ncc; i++) view.setUint8(at + C_CC + i, t.c_cc[i] ?? 0);
+}
+function ioctlArg(view, request, arg) {
+  if (TERMIOS_SETS.has(request)) {
+    if (request > 65535) {
+      const t = readFlags(view, arg, NCCS2);
+      return {
+        ...t,
+        c_ispeed: view.getUint32(arg + 36, true),
+        c_ospeed: view.getUint32(arg + 40, true)
+      };
+    }
+    return readFlags(view, arg, NCCS);
+  }
+  if (INT_IN.has(request)) return view.getInt32(arg, true);
+  if (INT_ARG.has(request)) return arg | 0;
+  if (request === IOCTL.TIOCSWINSZ)
+    return { rows: view.getUint16(arg, true), cols: view.getUint16(arg + 2, true) };
+  return void 0;
+}
+function ioctlResult(view, request, arg, result) {
+  if (TERMIOS_GETS.has(request)) {
+    const t = result;
+    if (request === IOCTL.TCGETS2) {
+      writeFlags(view, arg, t, NCCS2);
+      view.setUint32(arg + 36, (t.c_ispeed ?? 0) >>> 0, true);
+      view.setUint32(arg + 40, (t.c_ospeed ?? 0) >>> 0, true);
+    } else {
+      writeFlags(view, arg, t, NCCS);
+      view.setUint32(arg + 52, t.c_cflag & CBAUD, true);
+      view.setUint32(arg + 56, t.c_cflag & CBAUD, true);
+    }
+  } else if (INT_OUT.has(request)) view.setInt32(arg, capturedNumber(result) | 0, true);
+  else if (request === IOCTL.TIOCGWINSZ) {
+    const size = result;
+    view.setUint16(arg, size.rows, true);
+    view.setUint16(arg + 2, size.cols, true);
+    view.setUint32(arg + 4, 0, true);
+  }
+}
+var IOCTL, FILE_IOCTLS, TERMIOS_GETS, TERMIOS_SETS, INT_OUT, INT_IN, INT_ARG, TIOCM, CBAUD, BOTHER, CSIZE, CSTOPB, PARENB, PARODD, CRTSCTS, SPEEDS, FAST, SERIAL_CFLAG, SERIAL_LFLAG, NCCS, NCCS2, C_LINE, C_CC;
+var init_serial_ioctl = __esm({
+  "src/kernel/serial-ioctl.ts"() {
+    "use strict";
+    init_captured_globals();
+    IOCTL = {
+      TCGETS: 21505,
+      TCSETS: 21506,
+      TCSETSW: 21507,
+      TCSETSF: 21508,
+      TCSBRK: 21513,
+      TCFLSH: 21515,
+      TIOCEXCL: 21516,
+      TIOCNXCL: 21517,
+      TIOCSCTTY: 21518,
+      TIOCGPGRP: 21519,
+      TIOCSPGRP: 21520,
+      TIOCOUTQ: 21521,
+      TIOCGWINSZ: 21523,
+      TIOCSWINSZ: 21524,
+      TIOCMGET: 21525,
+      TIOCMBIS: 21526,
+      TIOCMBIC: 21527,
+      TIOCMSET: 21528,
+      FIONREAD: 21531,
+      TIOCNOTTY: 21538,
+      TCSBRKP: 21541,
+      TIOCSBRK: 21543,
+      TIOCCBRK: 21544,
+      TCGETS2: 2150388778,
+      TCSETS2: 1076646955,
+      TCSETSW2: 1076646956,
+      TCSETSF2: 1076646957
+    };
+    FILE_IOCTLS = new capturedSet([21537, 21584, 21585, 21586]);
+    TERMIOS_GETS = new capturedSet([IOCTL.TCGETS, IOCTL.TCGETS2]);
+    TERMIOS_SETS = new capturedSet([
+      IOCTL.TCSETS,
+      IOCTL.TCSETSW,
+      IOCTL.TCSETSF,
+      IOCTL.TCSETS2,
+      IOCTL.TCSETSW2,
+      IOCTL.TCSETSF2
+    ]);
+    INT_OUT = new capturedSet([
+      IOCTL.TIOCMGET,
+      IOCTL.FIONREAD,
+      IOCTL.TIOCOUTQ
+    ]);
+    INT_IN = new capturedSet([
+      IOCTL.TIOCMBIS,
+      IOCTL.TIOCMBIC,
+      IOCTL.TIOCMSET
+    ]);
+    INT_ARG = new capturedSet([IOCTL.TCSBRK, IOCTL.TCSBRKP, IOCTL.TCFLSH]);
+    TIOCM = {
+      DTR: 2,
+      RTS: 4,
+      CTS: 32,
+      CD: 64,
+      RI: 128,
+      DSR: 256
+    };
+    CBAUD = 4111;
+    BOTHER = 4096;
+    CSIZE = 48;
+    CSTOPB = 64;
+    PARENB = 256;
+    PARODD = 512;
+    CRTSCTS = 2147483648;
+    SPEEDS = [
+      0,
+      50,
+      75,
+      110,
+      134,
+      150,
+      200,
+      300,
+      600,
+      1200,
+      1800,
+      2400,
+      4800,
+      9600,
+      19200,
+      38400
+    ];
+    FAST = [
+      0,
+      57600,
+      115200,
+      230400,
+      460800,
+      5e5,
+      576e3,
+      921600,
+      1e6,
+      1152e3,
+      15e5,
+      2e6,
+      25e5,
+      3e6,
+      35e5,
+      4e6
+    ];
+    SERIAL_CFLAG = 13 | 48 | 128 | 1024 | 2048;
+    SERIAL_LFLAG = 16 | 32 | 512 | 2048;
+    NCCS = 32;
+    NCCS2 = 19;
+    C_LINE = 16;
+    C_CC = 17;
+  }
+});
+
 // src/process/process-pty.ts
 function failed(e) {
   const code2 = e?.code;
   if (typeof code2 === "string") return -wasiErrno(code2);
   throw e;
 }
+function deviceIoctl(stream, request, varargs, deps) {
+  const heap = deps.heap();
+  if (!heap) return -wasiErrno("EFAULT");
+  const view = new capturedDataView(heap.buffer);
+  const argp = (heap[varargs >> 2] ?? 0) >>> 0;
+  try {
+    const arg = ioctlArg(view, request, argp);
+    const kernel = deps.kernel;
+    const result = kernel.devIoctl(stream.sliccKernelFd, request, arg);
+    ioctlResult(new capturedDataView(heap.buffer), request, argp, result);
+    return 0;
+  } catch (e) {
+    return failed(e);
+  }
+}
 function ptyIoctl(ioctl, deps) {
   return (fd, op, varargs) => {
     const request = op >>> 0;
+    const device2 = deps.fs()?.getStream(fd);
+    if (device2?.sliccDevice && deps.kernel.devIoctl && !FILE_IOCTLS.has(request))
+      return deviceIoctl(device2, request, varargs ?? 0, deps);
     if (request !== TIOCGPTN && request !== TIOCSPTLCK && request !== TIOCSCTTY && request !== TIOCSWINSZ && request !== TIOCPKT) {
       return ioctl(fd, op, varargs);
     }
@@ -3374,6 +3580,7 @@ var init_process_pty = __esm({
   "src/process/process-pty.ts"() {
     "use strict";
     init_captured_globals();
+    init_serial_ioctl();
     init_wasi_errno();
     TIOCGPTN = 2147767344;
     TIOCSPTLCK = 1074025521;
@@ -3869,8 +4076,8 @@ function useDevRemoval(Fs) {
     const remove = fs[name2];
     if (typeof remove !== "function") continue;
     fs[name2] = (path) => {
-      const refused2 = devRemoval(absoluteOf(path, Fs.cwd()), fs.sliccCred);
-      if (refused2) throw new Fs.ErrnoError(wasiErrno(refused2));
+      const refused3 = devRemoval(absoluteOf(path, Fs.cwd()), fs.sliccCred);
+      if (refused3) throw new Fs.ErrnoError(wasiErrno(refused3));
       remove.call(Fs, path);
     };
   }
@@ -3925,16 +4132,16 @@ function pinRootKind() {
 }
 function mountTable(mounts = []) {
   const root = pinnedRoot ?? rootKind();
-  const lines = [`${root} / ${root} rw 0 0`, "devfs /dev devfs rw 0 0", "proc /proc proc rw 0 0"];
+  const lines2 = [`${root} / ${root} rw 0 0`, "devfs /dev devfs rw 0 0", "proc /proc proc rw 0 0"];
   for (const m of mounts) {
     const options = capturedObject.entries(m.options).map(([k, v]) => v === "" ? k : `${k}=${v}`);
     if (m.state !== "ok") options.push(m.state);
-    const access = options.includes("ro") ? [] : ["rw"];
-    lines.push(
-      `${field(m.source)} ${field(m.target)} ${m.type} ${[...access, ...options].join(",")} 0 0`
+    const access2 = options.includes("ro") ? [] : ["rw"];
+    lines2.push(
+      `${field(m.source)} ${field(m.target)} ${m.type} ${[...access2, ...options].join(",")} 0 0`
     );
   }
-  return `${lines.join("\n")}
+  return `${lines2.join("\n")}
 `;
 }
 function accounts(env = {}) {
@@ -4054,8 +4261,8 @@ function kernelAccess(imports, fs, memory, glue) {
     const Fs = fs();
     const heap = memory();
     const call2 = { dirfd, path, amode: amode & 7, flags };
-    const refused2 = Fs?.lookupPath && heap ? readonlyRefusal(Fs, heap, call2) : 0;
-    if (refused2 !== 0) return refused2;
+    const refused3 = Fs?.lookupPath && heap ? readonlyRefusal(Fs, heap, call2) : 0;
+    if (refused3 !== 0) return refused3;
     const rc = own(dirfd, path, amode, flags);
     if (rc !== 0 || !Fs?.lookupPath || !heap) return rc;
     try {
@@ -4094,13 +4301,13 @@ function kernelLink(imports, fs, memory, glue) {
 function refusedCreation(Fs, heap, dirfd, ptr) {
   const name2 = cString(heap, ptr);
   const path = absoluteOf(name2, name2.startsWith("/") ? "/" : baseOf2(Fs, dirfd));
-  const refused2 = devCreation(path, Fs.sliccCred);
-  if (!refused2 || !Fs.lookupPath) return 0;
+  const refused3 = devCreation(path, Fs.sliccCred);
+  if (!refused3 || !Fs.lookupPath) return 0;
   try {
     Fs.lookupPath(path, { follow: false });
     return 0;
   } catch {
-    return -wasiErrno(refused2);
+    return -wasiErrno(refused3);
   }
 }
 function devCreations(imports, fs, memory, glue) {
@@ -4366,6 +4573,29 @@ var init_fd_metadata = __esm({
 });
 
 // src/process/kernel-streams.ts
+function deviceStat(node) {
+  return {
+    dev: 22,
+    ino: 4096 + (node.major << 8) + node.minor,
+    mode: 8192 | node.mode,
+    nlink: 1,
+    uid: node.uid,
+    gid: node.gid,
+    rdev: node.major << 8 | node.minor,
+    size: 0,
+    blksize: 4096,
+    blocks: 0,
+    atime: new capturedDate(node.atimeMs),
+    mtime: new capturedDate(node.mtimeMs),
+    ctime: new capturedDate(node.ctimeMs)
+  };
+}
+function byIdNames(nodes) {
+  const names = new capturedMap();
+  for (const node of nodes)
+    for (const link of node.links) names.set(link.slice(BY_ID_DIR.length + 1), node.path);
+  return names;
+}
 function isPtyPath(path) {
   return PTY_PATH.test(path);
 }
@@ -4416,7 +4646,7 @@ function datesOf(real) {
       dates[key] = new capturedDate(value2);
   return dates;
 }
-var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, TCSETSF, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, PTS_MAJOR, TTY_NAME, SEALED_PATH, STRERROR, CLIPBOARD_PATH, EMBEDDER_PATH, DEVICE_INO, O_CREAT3, O_EXCL2, O_NOCTTY, O_TRUNC3, O_DIRECTORY, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
+var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, TCSETSF, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, PTS_MAJOR, TTY_NAME, DEVICE_PATH, DEVICE_LEAF, SERIAL_DIR, BY_ID_DIR, SEALED_PATH, STRERROR, CLIPBOARD_PATH, EMBEDDER_PATH, DEVICE_INO, O_CREAT3, O_EXCL2, O_NOCTTY, O_TRUNC3, O_DIRECTORY, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
 var init_kernel_streams = __esm({
   "src/process/kernel-streams.ts"() {
     "use strict";
@@ -4436,6 +4666,10 @@ var init_kernel_streams = __esm({
     TTY_PATH = /^\/dev\/tty\d+$/;
     PTS_MAJOR = 136;
     TTY_NAME = /^tty\d+$/;
+    DEVICE_PATH = /^\/dev\/tty(?:USB|ACM)\d+$/;
+    DEVICE_LEAF = /^tty(?:USB|ACM)\d+$/;
+    SERIAL_DIR = "/dev/serial";
+    BY_ID_DIR = "/dev/serial/by-id";
     SEALED_PATH = "/dev/sealed";
     STRERROR = {
       EACCES: "Permission denied",
@@ -4522,6 +4756,7 @@ var init_kernel_streams = __esm({
         const kfd = stream.sliccKernelFd;
         if (!stream.tty || kfd === void 0) return;
         const name2 = this.sys.ttyName?.(kfd);
+        if (name2 && DEVICE_PATH.test(name2)) stream.sliccDevice = true;
         if (name2) this.nameStream(stream, name2);
       }
       nameStream(stream, name2) {
@@ -4690,6 +4925,121 @@ var init_kernel_streams = __esm({
           return [...names, ...extra.filter((name2) => !names.includes(name2))];
         };
       }
+      useDeviceNodes() {
+        const fs = this.Fs;
+        const { lookupNode, readdir, getPath, mkdir, mkdev, makedev, registerDevice } = fs;
+        const nodes = this.sys.devNodes?.bind(this.sys);
+        if (!lookupNode || !readdir || !getPath || !mkdir || !mkdev || !makedev || !nodes) return;
+        const serial = (dir, name2) => dir === "/dev" && (DEVICE_LEAF.test(name2) || name2 === "serial") || dir === SERIAL_DIR && name2 === "by-id" || dir === BY_ID_DIR;
+        const make = (dir, name2) => {
+          if (!serial(dir, name2)) return false;
+          const known = nodes();
+          const links = byIdNames(known);
+          if (dir === "/dev" && DEVICE_LEAF.test(name2)) {
+            const node = known.find((n) => n.path === `/dev/${name2}`);
+            if (!node) return false;
+            const dev = makedev.call(fs, node.major, node.minor);
+            registerDevice?.call(fs, dev, {
+              open: (stream) => this.openDeviceNode(stream, node.path)
+            });
+            const made = mkdev.call(fs, node.path, dev);
+            made.node_ops = { ...made.node_ops, getattr: () => this.liveDeviceStat(node.path) };
+          } else if (dir === "/dev" && name2 === "serial" && links.size > 0)
+            mkdir.call(fs, SERIAL_DIR, 493);
+          else if (dir === SERIAL_DIR && name2 === "by-id" && links.size > 0)
+            mkdir.call(fs, BY_ID_DIR, 493);
+          else if (dir === BY_ID_DIR && links.has(name2))
+            fs.symlink?.call(
+              fs,
+              `../..${links.get(name2).slice(4)}`,
+              `${BY_ID_DIR}/${name2}`
+            );
+          else return false;
+          return true;
+        };
+        let making = false;
+        fs.lookupNode = (parent, name2) => {
+          try {
+            return lookupNode.call(fs, parent, name2);
+          } catch (e) {
+            if (making) throw e;
+            making = true;
+            let made;
+            try {
+              made = make(getPath.call(fs, parent), name2);
+            } finally {
+              making = false;
+            }
+            if (!made) throw e;
+            return lookupNode.call(fs, parent, name2);
+          }
+        };
+        this.useDeviceMeta();
+        fs.readdir = (path) => {
+          const at = path.replace(/\/+$/, "");
+          const names = readdir.call(fs, path);
+          if (at !== "/dev" && at !== SERIAL_DIR && at !== BY_ID_DIR) return names;
+          const known = nodes();
+          const links = byIdNames(known);
+          const wanted = at === "/dev" ? [...known.map((n) => n.path.slice(5)), ...links.size > 0 ? ["serial"] : []] : at === SERIAL_DIR ? links.size > 0 ? ["by-id"] : [] : [...links.keys()];
+          const stale2 = (name2) => at === "/dev" ? (DEVICE_LEAF.test(name2) || name2 === "serial") && !wanted.includes(name2) : name2 !== "." && name2 !== ".." && !wanted.includes(name2);
+          const kept = names.filter((name2) => !stale2(name2));
+          return [...kept, ...wanted.filter((name2) => !kept.includes(name2))];
+        };
+      }
+      useDeviceMeta() {
+        const fs = this.Fs;
+        const { lookupPath, getPath } = fs;
+        const devMeta = this.sys.devMeta?.bind(this.sys);
+        if (!lookupPath || !getPath || !devMeta) return;
+        const deviceOf2 = (path, follow3) => {
+          try {
+            const at = typeof path === "string" ? lookupPath.call(fs, path, { follow: follow3 }).path : getPath.call(fs, path);
+            return DEVICE_PATH.test(at) ? at : void 0;
+          } catch {
+            return void 0;
+          }
+        };
+        const set = (path, change) => this.call(() => devMeta(path, change));
+        const { chmod, chown, utime } = fs;
+        if (chmod)
+          fs.chmod = (path, mode, dontFollow) => {
+            const device2 = deviceOf2(path, !dontFollow);
+            if (device2 === void 0) return chmod.call(fs, path, mode, dontFollow);
+            set(device2, { mode: mode & 4095 });
+          };
+        if (chown)
+          fs.chown = (path, uid, gid, dontFollow) => {
+            const device2 = deviceOf2(path, !dontFollow);
+            if (device2 === void 0) return chown.call(fs, path, uid, gid, dontFollow);
+            set(device2, { uid, gid });
+          };
+        if (utime)
+          fs.utime = (path, atime, mtime) => {
+            const device2 = deviceOf2(path, true);
+            if (device2 === void 0) return utime.call(fs, path, atime, mtime);
+            set(device2, {
+              atimeMs: capturedNumber(atime),
+              mtimeMs: capturedNumber(mtime),
+              now: fs.sliccTouch === true
+            });
+          };
+      }
+      liveDeviceStat(path) {
+        const node = this.call(() => this.sys.devNodes?.() ?? []).find((n) => n.path === path);
+        if (!node) throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
+        return deviceStat(node);
+      }
+      openDeviceNode(stream, path) {
+        const { openDev: openDev2 } = this.sys;
+        stream.sliccDevice = true;
+        this.openNode(
+          stream,
+          path,
+          (flags) => openDev2.call(this.sys, path, flags | stream.flags & O_NONBLOCK),
+          true
+        );
+      }
       ptyNode(path, dev) {
         const fs = this.Fs;
         fs.registerDevice?.call(fs, dev, {
@@ -4784,6 +5134,7 @@ var init_kernel_streams = __esm({
         this.usePtyPaths();
         this.useTerminalNodes();
         this.usePtsNodes();
+        this.useDeviceNodes();
         this.listSealed();
         const open = this.Fs.open.bind(this.Fs);
         this.Fs.open = (path, flags, mode) => {
@@ -4795,7 +5146,7 @@ var init_kernel_streams = __esm({
           if (pty) return pty;
           this.refuseExclusiveLink(path, flags);
           const stream = this.openRacing(open, path, flags, mode);
-          if (!stream.tty) return stream;
+          if (!stream.tty || stream.sliccDevice) return stream;
           if (stream.path === "/dev/tty" && this.sys.openTty) {
             let kfd;
             try {
@@ -5039,6 +5390,7 @@ var init_kernel_streams = __esm({
             if (state.readable) mask |= POLLIN | POLLRDNORM;
             if (state.writable) mask |= POLLOUT | POLLWRNORM;
             if (state.hangup) mask |= state.readable ? POLLHUP : POLLERR;
+            if (state.error) mask |= POLLERR;
             return mask;
           },
           dup: (stream) => {
@@ -5140,9 +5492,9 @@ function kernelEntry(stream, kernel) {
   }
   const device2 = stream.path === void 0 ? void 0 : NAMED_DEVICES[stream.path];
   const kind = stream.sliccKernelFile ? "file" : stream.tty ? "tty" : device2 ?? "stream";
-  const access = kind === "tty" ? O_RDWR : (stream.flags ?? O_RDWR) & O_ACCMODE4;
+  const access2 = kind === "tty" ? O_RDWR : (stream.flags ?? O_RDWR) & O_ACCMODE4;
   const fifo = stream.sliccKernelFifo ? { fifo: stream.sliccKernelFifo } : {};
-  return { fd: stream.fd, kernel, kind, flags: access, ...cloexec, ...fifo };
+  return { fd: stream.fd, kernel, kind, flags: access2, ...cloexec, ...fifo };
 }
 function describeInherited(Fs, sys, streams2, livePath, actions = []) {
   const table = new capturedMap();
@@ -5171,8 +5523,8 @@ function describeInherited(Fs, sys, streams2, livePath, actions = []) {
 function deviceOfStream(stream) {
   const device2 = stream.path === void 0 ? void 0 : DEVICES[stream.path];
   if (!device2 || stream.sliccKernelFd !== void 0) return void 0;
-  const access = ACCESS[stream.flags & O_ACCMODE4];
-  return { device: device2, ...access ? { access } : {} };
+  const access2 = ACCESS[stream.flags & O_ACCMODE4];
+  return { device: device2, ...access2 ? { access: access2 } : {} };
 }
 function inheritedSlot(fd, stream) {
   if (stream.sliccKernelFd === void 0) {
@@ -5189,12 +5541,12 @@ function place(Fs, stream, fd) {
   return moved;
 }
 function placeholder(Fs, streams2, entry) {
-  const access = entry.flags ?? O_RDWR;
-  if (entry.kind === "socket") return streams2.socketStream(access);
+  const access2 = entry.flags ?? O_RDWR;
+  if (entry.kind === "socket") return streams2.socketStream(access2);
   if (entry.kind === "tty") return Fs.open("/dev/tty", O_RDWR);
-  if (entry.kind === "stream" || DEVICE_KINDS.has(entry.kind)) return Fs.open("/dev/null", access);
+  if (entry.kind === "stream" || DEVICE_KINDS.has(entry.kind)) return Fs.open("/dev/null", access2);
   Fs.mkdirTree(PLACEHOLDER_DIR);
-  return Fs.open(`${PLACEHOLDER_DIR}/${entry.fd}`, access | O_CREAT4);
+  return Fs.open(`${PLACEHOLDER_DIR}/${entry.fd}`, access2 | O_CREAT4);
 }
 function asFifo(stream, streams2, identity) {
   const inos = streamInos.get(streams2) ?? new capturedMap();
@@ -6418,6 +6770,29 @@ function ownBytes(bytes) {
 function ownedBuffer(body, given) {
   return body === given ? void 0 : [body.buffer];
 }
+function deviceSys(call2) {
+  const json2 = (r) => r.ok && r.kind === "json" ? r.json : void 0;
+  return {
+    devNodes() {
+      return json2(call2({ op: "fd-dev-nodes" }, "fd-dev-nodes"));
+    },
+    openDev(path, flags) {
+      return json2(call2({ op: "fd-open-dev", path, flags }, `fd-open-dev ${path}`));
+    },
+    devIoctl(fd, request, arg) {
+      const req = {
+        op: "fd-dev-ioctl",
+        fd,
+        request,
+        ...arg !== void 0 ? { arg } : {}
+      };
+      return json2(call2(req, `fd-dev-ioctl ${fd}`));
+    },
+    devMeta(path, change) {
+      call2({ op: "fd-dev-meta", path, ...change }, `fd-dev-meta ${path}`);
+    }
+  };
+}
 function kernelSys(transport) {
   const call2 = (req, label, transfer) => {
     const r = transport.call(req, capturedNumber.POSITIVE_INFINITY, label, transfer);
@@ -6426,6 +6801,7 @@ function kernelSys(transport) {
   };
   const json2 = (r) => r.ok && r.kind === "json" ? r.json : void 0;
   return {
+    ...deviceSys(call2),
     read(fd, max, opts) {
       const flags = {
         ...opts?.nonblock ? { nonblock: true } : {},
@@ -6538,8 +6914,9 @@ function kernelSys(transport) {
     tcgets(fd) {
       return json2(call2({ op: "tty-get", fd }, `tty-get ${fd}`));
     },
-    tcsets(fd, termios, flush) {
-      call2({ op: "tty-set", fd, termios, ...flush ? { flush } : {} }, `tty-set ${fd}`);
+    tcsets(fd, termios, flush, drain2) {
+      const how = { ...flush ? { flush } : {}, ...drain2 ? { drain: drain2 } : {} };
+      call2({ op: "tty-set", fd, termios, ...how }, `tty-set ${fd}`);
     },
     winsize(fd) {
       return json2(call2({ op: "tty-winsz", fd }, `tty-winsz ${fd}`));
@@ -6795,8 +7172,8 @@ async function runWasmProcess(init, port2, deps = {}) {
   };
   const transport = credSyncTransport(gated, () => early(), init.cred);
   const sys = kernelSys(transport);
-  const encoder6 = new capturedTextEncoder();
-  const say = (fd) => (text) => sys.write(fd, encoder6.encode(`${text}
+  const encoder7 = new capturedTextEncoder();
+  const say = (fd) => (text) => sys.write(fd, encoder7.encode(`${text}
 `));
   let ready;
   let failed5;
@@ -7057,7 +7434,7 @@ var init_process_runtime = __esm({
     O_RDWR3 = 2;
     O_ACCMODE5 = 3;
     O_DIRECTORY2 = 65536;
-    accessMode = (access) => access === "read" ? O_RDONLY2 : access === "write" ? O_WRONLY3 : O_RDWR3;
+    accessMode = (access2) => access2 === "read" ? O_RDONLY2 : access2 === "write" ? O_WRONLY3 : O_RDWR3;
     PLACED = new capturedSet([
       "stream",
       "file",
@@ -8130,6 +8507,92 @@ var init_wasi_files = __esm({
   }
 });
 
+// src/fs/dac.ts
+var init_dac = __esm({
+  "src/fs/dac.ts"() {
+    "use strict";
+    init_captured_globals();
+    init_access();
+    init_owners();
+    init_types();
+    init_walk();
+  }
+});
+
+// src/kernel/pipe.ts
+var PIPE_CAPACITY;
+var init_pipe = __esm({
+  "src/kernel/pipe.ts"() {
+    "use strict";
+    init_captured_globals();
+    PIPE_CAPACITY = 64 * 1024;
+  }
+});
+
+// src/kernel/fd-table.ts
+function deviceAt(path) {
+  return DEVICE_PATHS.get(path);
+}
+var DEVICE_PATHS;
+var init_fd_table = __esm({
+  "src/kernel/fd-table.ts"() {
+    "use strict";
+    init_captured_globals();
+    init_pipe();
+    DEVICE_PATHS = new capturedMap([
+      ["/dev/null", "null"],
+      ["/dev/zero", "zero"],
+      ["/dev/full", "full"],
+      ["/dev/urandom", "urandom"],
+      ["/dev/random", "urandom"]
+    ]);
+  }
+});
+
+// src/kernel/embedder.ts
+var EMBEDDER_HEADER_MAX, EMBEDDER_WINDOW, EMBEDDER_BUDGET;
+var init_embedder = __esm({
+  "src/kernel/embedder.ts"() {
+    "use strict";
+    init_captured_globals();
+    init_fd_table();
+    EMBEDDER_HEADER_MAX = 64 * 1024;
+    EMBEDDER_WINDOW = 1024 * 1024;
+    EMBEDDER_BUDGET = 256 * 1024 * 1024;
+  }
+});
+
+// src/kernel/tty.ts
+var encoder2;
+var init_tty = __esm({
+  "src/kernel/tty.ts"() {
+    "use strict";
+    init_captured_globals();
+    init_fd_table();
+    init_signals();
+    encoder2 = new capturedTextEncoder();
+  }
+});
+
+// src/kernel/devices.ts
+var DEVICE_NAME, BY_ID, HIGH_WATER, DEFAULT_SETTINGS;
+var init_devices = __esm({
+  "src/kernel/devices.ts"() {
+    "use strict";
+    init_captured_globals();
+    init_access();
+    init_dac();
+    init_embedder();
+    init_fd_table();
+    init_serial_ioctl();
+    init_tty();
+    DEVICE_NAME = /^tty(USB|ACM)(\d{1,3})$/;
+    BY_ID = "/dev/serial/by-id";
+    HIGH_WATER = 64 * 1024;
+    DEFAULT_SETTINGS = settingsOf(SERIAL_CFLAG, 9600);
+  }
+});
+
 // src/process/js/async-sab.ts
 async function changed(header, index3, seen, waitAsync = defaultWaitAsync) {
   const waited = waitAsync(header, index3, seen);
@@ -8272,6 +8735,8 @@ var init_js_kernel = __esm({
       "fd-close",
       "fd-open-clipboard",
       "fd-open-embedder",
+      "fd-open-dev",
+      "fd-dev-ioctl",
       "net-ws-ready",
       "sock-tls",
       "sock-tls-upgrade",
@@ -8545,8 +9010,8 @@ function checkOpen(abs, o, existing) {
 }
 function flagsOf(o) {
   const write2 = o.write || o.append || o.truncate;
-  const access = write2 ? o.read ? O_RDWR4 : O_WRONLY4 : 0;
-  return access | (o.append ? O_APPEND2 : 0) | (o.nonblock ? O_NONBLOCK_OPEN : 0);
+  const access2 = write2 ? o.read ? O_RDWR4 : O_WRONLY4 : 0;
+  return access2 | (o.append ? O_APPEND2 : 0) | (o.nonblock ? O_NONBLOCK_OPEN : 0);
 }
 function openRequest(abs, o) {
   return {
@@ -8602,9 +9067,28 @@ function nodeStat(mode, size = 0, owner) {
     gid: owner?.gid ?? 0
   };
 }
+function serialNamed(name2) {
+  return DEVICE_NAME.test(name2) || name2 === "serial" || name2.startsWith("serial/");
+}
+function serialNode(abs, nodes) {
+  const node = nodes.find((n) => n.path === abs);
+  if (node) return { kind: "serial", node };
+  const links = nodes.some((n) => n.links.length > 0);
+  if (links && (abs === SERIAL || abs === BY_ID)) return { kind: "dir", mode: DIR | 493 };
+  const owner = nodes.find((n) => n.links.includes(abs));
+  if (owner) return { kind: "devlink", target: `../..${owner.path.slice(4)}`, node: owner };
+  return void 0;
+}
+function* deviceNodes() {
+  return yield { op: "fd-dev-nodes" };
+}
 function* lookup(abs) {
   if (abs === "/dev") return { kind: "dir", mode: DIR | 493 };
   const name2 = abs.slice("/dev/".length);
+  if (serialNamed(name2)) {
+    const found = serialNode(abs, yield* deviceNodes());
+    if (found) return found;
+  }
   if (DEVICES2.includes(name2)) return { kind: "device" };
   if (name2 === "tty") return { kind: "tty" };
   if (name2 === "clipboard") return { kind: "clipboard" };
@@ -8672,6 +9156,14 @@ function* fdTarget(fd, path) {
 function devFdStat(fd) {
   return fdStat(fd, `/dev/fd/${fd}`);
 }
+function serialStat(node) {
+  return {
+    ...nodeStat(CHAR | node.mode, 0, node),
+    atimeMs: node.atimeMs,
+    mtimeMs: node.mtimeMs,
+    ctimeMs: node.ctimeMs
+  };
+}
 function linkStat(target) {
   return nodeStat(LINK | 511, target.length);
 }
@@ -8688,6 +9180,10 @@ function* devStat(abs, follow3) {
       return nodeStat(CHAR | 438);
     case "terminal":
       return yield* terminalStat(node.name);
+    case "serial":
+      return serialStat(node.node);
+    case "devlink":
+      return follow3 ? serialStat(node.node) : linkStat(node.target);
     case "link":
       if (!follow3) return linkStat(node.target);
       return node.fd === void 0 ? nodeStat(DIR | 365) : yield* fdStat(node.fd, abs);
@@ -8706,7 +9202,7 @@ function* devExists(abs) {
 }
 function* devReadlink(abs) {
   const node = yield* lookup(abs);
-  if (node.kind === "link") return node.target;
+  if (node.kind === "link" || node.kind === "devlink") return node.target;
   if (node.kind === "fd") return yield* fdTarget(node.fd, abs);
   throw new JsCallError("EINVAL", abs);
 }
@@ -8727,9 +9223,18 @@ function* devReaddir(abs) {
   }
   const node = yield* lookup(abs);
   if (node.kind !== "dir") throw new JsCallError("ENOTDIR", abs);
+  if (abs === SERIAL || abs === BY_ID) {
+    const nodes2 = yield* deviceNodes();
+    if (abs === SERIAL) return ["by-id"];
+    return nodes2.flatMap((n) => n.links.map((l) => l.slice(BY_ID.length + 1))).sort();
+  }
   const names = yield { op: "fd-tty-names" };
   const ttys = names.filter((n) => /^\/dev\/tty\d+$/.test(n)).map((n) => n.slice(5));
+  const nodes = yield* deviceNodes();
+  const serial = nodes.map((n) => n.path.slice(5));
+  if (nodes.some((n) => n.links.length > 0)) serial.push("serial");
   return [
+    ...serial,
     ...DEVICES2,
     "clipboard",
     "embedder",
@@ -8788,6 +9293,13 @@ function* opened(abs, o) {
       };
     case "sealed":
       return { fd: yield { op: "fd-open-sealed", flags: accessFlags(o) }, file: false };
+    case "serial":
+    case "devlink":
+      return {
+        fd: yield { op: "fd-open-dev", path: node.node.path, flags: accessFlags(o) },
+        file: false,
+        device: true
+      };
     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 };
@@ -8834,6 +9346,85 @@ function devSync(kernel, step) {
 function tooLarge(got) {
   if (got > DEV_READ_MAX) throw new JsCallError("EFBIG", "readFile");
 }
+function ioctlRequest(fd, request, arg) {
+  return { op: "fd-dev-ioctl", fd, request, ...arg !== void 0 ? { arg } : {} };
+}
+function jsTermios(t) {
+  const { c_iflag, c_oflag, c_cflag, c_lflag, c_cc } = t;
+  return {
+    c_iflag,
+    c_oflag,
+    c_cflag,
+    c_lflag,
+    c_cc,
+    ispeed: t.c_ispeed,
+    ospeed: t.c_ospeed
+  };
+}
+function kernelTermios(t) {
+  const ospeed = speedArg(t?.ospeed);
+  const ispeed = t.ispeed === void 0 ? ospeed : speedArg(t.ispeed);
+  const out = codeOf(ospeed);
+  const cflag = capturedNumber(t.c_cflag) >>> 0 & ~(CBAUD | CBAUD << 16) | out;
+  return {
+    c_iflag: capturedNumber(t.c_iflag) >>> 0,
+    c_oflag: capturedNumber(t.c_oflag) >>> 0,
+    c_cflag: (ispeed === ospeed ? cflag : cflag | codeOf(ispeed) << 16) >>> 0,
+    c_lflag: capturedNumber(t.c_lflag) >>> 0,
+    c_cc: capturedArray.from({ length: 32 }, (_, i) => capturedNumber(t.c_cc?.[i] ?? 0) & 255),
+    c_ispeed: ispeed,
+    c_ospeed: ospeed
+  };
+}
+function speedArg(speed) {
+  if (!capturedNumber.isInteger(speed) || speed < 0 || speed > 4294967295)
+    throw new JsCallError("EINVAL", "setTermios");
+  return speed;
+}
+function modemOf(bits) {
+  const b = capturedNumber(bits);
+  return {
+    dtr: (b & TIOCM.DTR) !== 0,
+    rts: (b & TIOCM.RTS) !== 0,
+    cts: (b & TIOCM.CTS) !== 0,
+    dsr: (b & TIOCM.DSR) !== 0,
+    cd: (b & TIOCM.CD) !== 0,
+    ri: (b & TIOCM.RI) !== 0
+  };
+}
+function lines(m, on) {
+  return (m?.dtr === on ? TIOCM.DTR : 0) | (m?.rts === on ? TIOCM.RTS : 0);
+}
+function serialControls(fd, live, ioctl, then) {
+  const ask = (request, arg) => {
+    live();
+    return ioctl(fd, request, arg);
+  };
+  const none = () => void 0;
+  return {
+    termios: () => then(ask(IOCTL.TCGETS2), (t) => jsTermios(t)),
+    setTermios: (termios, when = "now") => {
+      const request = WHEN[when];
+      if (request === void 0) throw new JsCallError("EINVAL", "setTermios");
+      return then(ask(request, kernelTermios(termios)), none);
+    },
+    modem: () => then(ask(IOCTL.TIOCMGET), modemOf),
+    setModem: (modem) => {
+      const on = lines(modem, true);
+      const off = lines(modem, false);
+      const clear = () => off ? then(ask(IOCTL.TIOCMBIC, off), none) : void 0;
+      return on ? then(ask(IOCTL.TIOCMBIS, on), clear) : then(clear(), none);
+    },
+    setBreak: (on) => then(ask(on ? IOCTL.TIOCSBRK : IOCTL.TIOCCBRK), none),
+    sendBreak: () => then(ask(IOCTL.TCSBRK, 0), none),
+    drain: () => then(ask(IOCTL.TCSBRK, 1), none),
+    flush: (queue = "both") => {
+      const n = QUEUE[queue];
+      if (n === void 0) throw new JsCallError("EINVAL", "flush");
+      return then(ask(IOCTL.TCFLSH, n), none);
+    }
+  };
+}
 function liveness(path) {
   let open = true;
   return {
@@ -8848,13 +9439,13 @@ function liveness(path) {
 function allowed(may, what) {
   if (!may) throw new JsCallError("EBADF", what);
 }
-function streamFile(fd, path, io, access) {
+function streamFile(fd, path, io, access2) {
   const { live, end } = liveness(path);
   const readAsync = async (position, length) => {
     index2(position, "read");
     index2(length, "read");
     live();
-    allowed(access.read, "read");
+    allowed(access2.read, "read");
     return length === 0 ? new capturedUint8Array(0) : io.read(fd, capturedMath.min(length, MAX_IO));
   };
   const file = {
@@ -8869,7 +9460,7 @@ function streamFile(fd, path, io, access) {
     async write(position, data) {
       index2(position, "write");
       live();
-      allowed(access.write, "write");
+      allowed(access2.write, "write");
       await io.write(fd, data);
       return data.length;
     },
@@ -8885,15 +9476,22 @@ function streamFile(fd, path, io, access) {
       await io.close(fd);
     }
   };
+  if (access2.device && io.ioctl) {
+    const ioctl = io.ioctl;
+    capturedObject.assign(
+      file,
+      serialControls(fd, live, ioctl, (v, next2) => capturedPromise.resolve(v).then(next2))
+    );
+  }
   return { file, invalidate: end };
 }
-function streamSyncFile(fd, path, io, access) {
+function streamSyncFile(fd, path, io, access2) {
   const { live, end } = liveness(path);
   const readSync = (position, length) => {
     index2(position, "read");
     index2(length, "read");
     live();
-    allowed(access.read, "read");
+    allowed(access2.read, "read");
     return length === 0 ? new capturedUint8Array(0) : io.read(fd, capturedMath.min(length, MAX_IO));
   };
   const file = {
@@ -8908,7 +9506,7 @@ function streamSyncFile(fd, path, io, access) {
     write(position, data) {
       index2(position, "write");
       live();
-      allowed(access.write, "write");
+      allowed(access2.write, "write");
       io.write(fd, data);
       return data.length;
     },
@@ -8924,6 +9522,11 @@ function streamSyncFile(fd, path, io, access) {
       io.close(fd);
     }
   };
+  if (access2.device && io.ioctl)
+    capturedObject.assign(
+      file,
+      serialControls(fd, live, io.ioctl, (v, next2) => next2(v))
+    );
   return { file, invalidate: end };
 }
 async function readWhole(file) {
@@ -8956,12 +9559,14 @@ function readWholeSync(file) {
     file.close();
   }
 }
-var DEV_READ_MAX, DEVICES2, STDIO, SELF_FD, S_IFMT3, DIR, LINK, CHAR, BORN, CHAR_KINDS;
+var DEV_READ_MAX, DEVICES2, STDIO, SELF_FD, S_IFMT3, DIR, LINK, CHAR, BORN, CHAR_KINDS, SERIAL, WHEN, QUEUE;
 var init_js_dev = __esm({
   "src/process/js/js-dev.ts"() {
     "use strict";
     init_captured_globals();
     init_dev_removal();
+    init_devices();
+    init_serial_ioctl();
     init_sync_fs_wire();
     init_js_io();
     init_js_kernel();
@@ -8981,6 +9586,13 @@ var init_js_dev = __esm({
       "embedder",
       "sealed"
     ]);
+    SERIAL = "/dev/serial";
+    WHEN = {
+      now: IOCTL.TCSETS2,
+      drain: IOCTL.TCSETSW2,
+      flush: IOCTL.TCSETSF2
+    };
+    QUEUE = { input: 0, output: 1, both: 2 };
   }
 });
 
@@ -9218,36 +9830,6 @@ var init_wasi_cred = __esm({
   }
 });
 
-// src/kernel/pipe.ts
-var PIPE_CAPACITY;
-var init_pipe = __esm({
-  "src/kernel/pipe.ts"() {
-    "use strict";
-    init_captured_globals();
-    PIPE_CAPACITY = 64 * 1024;
-  }
-});
-
-// src/kernel/fd-table.ts
-function deviceAt(path) {
-  return DEVICE_PATHS.get(path);
-}
-var DEVICE_PATHS;
-var init_fd_table = __esm({
-  "src/kernel/fd-table.ts"() {
-    "use strict";
-    init_captured_globals();
-    init_pipe();
-    DEVICE_PATHS = new capturedMap([
-      ["/dev/null", "null"],
-      ["/dev/zero", "zero"],
-      ["/dev/full", "full"],
-      ["/dev/urandom", "urandom"],
-      ["/dev/random", "urandom"]
-    ]);
-  }
-});
-
 // src/process/wasi/wasi-fds.ts
 function stdioAlias(path) {
   const m = /^\/dev\/(?:(stdin)|(stdout)|(stderr)|fd\/(\d+))$/.exec(path);
@@ -9332,13 +9914,14 @@ function promoteRequest(fd, f, handed) {
     ...f.buffer.handle !== void 0 && f.ino !== void 0 ? { ino: f.ino } : {}
   };
 }
-var SYNTHETIC_DIRS2, O_NONBLOCK2, O_WRONLY5, O_RDWR5, O_APPEND3, SEALED_PATH2, CLIPBOARD_PATH2, EMBEDDER_PATH2, NAMED_PATHS, WasiFds, GEN2;
+var SYNTHETIC_DIRS2, O_NONBLOCK2, O_WRONLY5, O_RDWR5, O_APPEND3, DEVICE_PATH2, SEALED_PATH2, CLIPBOARD_PATH2, EMBEDDER_PATH2, NAMED_PATHS, WasiFds, GEN2;
 var init_wasi_fds = __esm({
   "src/process/wasi/wasi-fds.ts"() {
     "use strict";
     init_captured_globals();
     init_changes();
     init_ranged();
+    init_devices();
     init_fd_table();
     init_sync_fs_wire();
     init_wasi_abi();
@@ -9348,6 +9931,7 @@ var init_wasi_fds = __esm({
     O_WRONLY5 = 1;
     O_RDWR5 = 2;
     O_APPEND3 = 1024;
+    DEVICE_PATH2 = /^\/dev\/tty(?:USB|ACM)\d+$/;
     SEALED_PATH2 = "/dev/sealed";
     CLIPBOARD_PATH2 = "/dev/clipboard";
     EMBEDDER_PATH2 = "/dev/embedder";
@@ -10013,6 +10597,19 @@ var init_wasi_fds = __esm({
         this.adopt(fd, kind, nonblock);
         return fd;
       }
+      openSerial(path, oflags, fdflags, rights) {
+        const { openDev: openDev2 } = this.kernel.sys;
+        const linked = path.startsWith(`${BY_ID}/`);
+        if (!openDev2 || !(linked || DEVICE_PATH2.test(path))) return void 0;
+        if (this.nofollow && linked) throw new WasiError("ELOOP");
+        const fd = this.openCharDevice(
+          (flags) => openDev2.call(this.kernel.sys, path, flags),
+          oflags,
+          rights
+        );
+        this.adopt(fd, "tty", (fdflags & FDFLAGS.NONBLOCK) !== 0);
+        return fd;
+      }
       openCharDevice(openDevice2, oflags, rights) {
         if (oflags & OFLAGS.DIRECTORY) throw new WasiError("ENOTDIR");
         if (oflags & OFLAGS.CREAT && oflags & OFLAGS.EXCL) throw new WasiError("EEXIST");
@@ -10062,6 +10659,8 @@ var init_wasi_fds = __esm({
         if (exclusive && namedDevice(path)) throw new WasiError("EEXIST");
         const device2 = deviceOf(path);
         if (device2) return this.install({ type: "device", device: device2 });
+        const serial = this.openSerial(path, oflags, fdflags, rights);
+        if (serial !== void 0) return serial;
         const kernelDevice = this.openKernelDevice(path, oflags, fdflags, rights);
         if (kernelDevice !== void 0) return kernelDevice;
         const alias = stdioAlias(path);
@@ -10190,9 +10789,9 @@ var init_wasi_fds = __esm({
       kernelFifo(path, existing, oflags, rights, fdflags) {
         const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
         const nonblock = (fdflags & FDFLAGS.NONBLOCK) !== 0;
-        const access = writable2 ? readable3 ? O_RDWR5 : O_WRONLY5 : 0;
+        const access2 = writable2 ? readable3 ? O_RDWR5 : O_WRONLY5 : 0;
         const fd = this.restarting(
-          () => this.kernel.sys.openVfs(path, access | (nonblock ? O_NONBLOCK2 : 0), 0, { fifo: true })
+          () => this.kernel.sys.openVfs(path, access2 | (nonblock ? O_NONBLOCK2 : 0), 0, { fifo: true })
         );
         this.table.set(fd, { type: "kernel", kind: "stream", nonblock, append: false });
         if (nonblock) this.publishFlags(fd, { nonblock, append: false });
@@ -10346,11 +10945,11 @@ var init_wasi_memory = __esm({
         return at;
       }
       putStrings(list, ptrs, buf) {
-        const encoder6 = new capturedTextEncoder();
+        const encoder7 = new capturedTextEncoder();
         const v = this.view();
         let at = buf;
         list.forEach((s, i) => {
-          const b = encoder6.encode(s);
+          const b = encoder7.encode(s);
           v.setUint32(ptrs + i * 4, at, true);
           this.bytes(at, b.length).set(b);
           v.setUint8(at + b.length, 0);
@@ -10358,12 +10957,12 @@ var init_wasi_memory = __esm({
         });
       }
       putSizes(list, countPtr, sizePtr) {
-        const encoder6 = new capturedTextEncoder();
+        const encoder7 = new capturedTextEncoder();
         const v = this.view();
         v.setUint32(countPtr, list.length, true);
         v.setUint32(
           sizePtr,
-          list.reduce((n, s) => n + encoder6.encode(s).length + 1, 0),
+          list.reduce((n, s) => n + encoder7.encode(s).length + 1, 0),
           true
         );
       }
@@ -10638,10 +11237,10 @@ function writeTermios(mem, ptr, termios) {
   v.setUint32(ptr + 4, termios.c_oflag, true);
   v.setUint32(ptr + 8, termios.c_cflag, true);
   v.setUint32(ptr + 12, termios.c_lflag, true);
-  for (let i = 0; i < NCCS; i++) v.setUint8(ptr + C_CC + i, termios.c_cc[i] ?? 0);
-  v.setUint8(ptr + C_LINE, 0);
-  v.setUint32(ptr + ISPEED, B38400, true);
-  v.setUint32(ptr + OSPEED, B38400, true);
+  for (let i = 0; i < NCCS3; i++) v.setUint8(ptr + C_CC2 + i, termios.c_cc[i] ?? 0);
+  v.setUint8(ptr + C_LINE2, 0);
+  v.setUint32(ptr + ISPEED, termios.c_cflag & CBAUD2, true);
+  v.setUint32(ptr + OSPEED, termios.c_cflag & CBAUD2, true);
 }
 function readTermios(mem, ptr) {
   const v = mem.view();
@@ -10650,7 +11249,7 @@ function readTermios(mem, ptr) {
     c_oflag: v.getUint32(ptr + 4, true),
     c_cflag: v.getUint32(ptr + 8, true),
     c_lflag: v.getUint32(ptr + 12, true),
-    c_cc: capturedArray.from({ length: NCCS }, (_, i) => v.getUint8(ptr + C_CC + i))
+    c_cc: capturedArray.from({ length: NCCS3 }, (_, i) => v.getUint8(ptr + C_CC2 + i))
   };
 }
 function sliccTty(mem, fds, kernel, interrupted = () => void 0) {
@@ -10674,7 +11273,17 @@ function sliccTty(mem, fds, kernel, interrupted = () => void 0) {
     if (actions < 0 || actions > TCSAFLUSH) throw new WasiError("EINVAL");
     const at = terminal(fd);
     needs(sys.tcsets);
-    sys.tcsets?.(at, readTermios(mem, ptr), actions === TCSAFLUSH);
+    sys.tcsets?.(at, readTermios(mem, ptr), actions === TCSAFLUSH, actions !== 0);
+  };
+  const control = (fd, request, arg) => {
+    interrupted();
+    const e = fds.find(fd);
+    if (!e) throw new WasiError("EBADF");
+    if (e.type !== "kernel") throw new WasiError("ENOTTY");
+    const asked = request >>> 0;
+    const value2 = ioctlArg(mem.view(), asked, arg >>> 0);
+    const result = needs(sys.devIoctl).call(sys, fd, asked, value2);
+    ioctlResult(mem.view(), asked, arg >>> 0, result);
   };
   const size = (fd, ptr) => {
     interrupted();
@@ -10687,21 +11296,23 @@ function sliccTty(mem, fds, kernel, interrupted = () => void 0) {
   return {
     tcgetattr: (fd, ptr) => void getAttr(fd, ptr),
     tcsetattr: (fd, actions, ptr) => void setAttr(fd, actions, ptr),
-    winsize: (fd, ptr) => void size(fd, ptr)
+    winsize: (fd, ptr) => void size(fd, ptr),
+    ioctl: (fd, request, arg) => void control(fd, request, arg)
   };
 }
-var NCCS, C_LINE, C_CC, ISPEED, OSPEED, B38400, TCSAFLUSH;
+var NCCS3, C_LINE2, C_CC2, ISPEED, OSPEED, CBAUD2, TCSAFLUSH;
 var init_wasi_termios = __esm({
   "src/process/wasi/wasi-termios.ts"() {
     "use strict";
     init_captured_globals();
+    init_serial_ioctl();
     init_wasi_files();
-    NCCS = 32;
-    C_LINE = 16;
-    C_CC = 17;
+    NCCS3 = 32;
+    C_LINE2 = 16;
+    C_CC2 = 17;
     ISPEED = 52;
     OSPEED = 56;
-    B38400 = 15;
+    CBAUD2 = 4111;
     TCSAFLUSH = 2;
   }
 });
@@ -12044,21 +12655,21 @@ var init_wasi_host = __esm({
         }
         return out;
       }
-      file(fd, access) {
+      file(fd, access2) {
         const e = this.fds.get(fd);
         if (e.type !== "file") {
           throw new WasiError(e.type === "dir" ? "EISDIR" : e.type === "kernel" ? "ESPIPE" : "EINVAL");
         }
-        if (access === "read" && !e.file.readable || access === "write" && !e.file.writable) {
+        if (access2 === "read" && !e.file.readable || access2 === "write" && !e.file.writable) {
           throw new WasiError("EBADF");
         }
         return e.file;
       }
-      positional(fd, access) {
+      positional(fd, access2) {
         const e = this.fds.get(fd);
         const kind = e.type === "kernel" ? this.fds.kind(fd, e) : e.type;
         if (kind === "device") this.interrupted?.();
-        if (kind !== "file" || e.type !== "kernel") return this.file(fd, access);
+        if (kind !== "file" || e.type !== "kernel") return this.file(fd, access2);
         const kernel = this.o.kernel;
         return {
           pread: (max, at) => {
@@ -12208,9 +12819,9 @@ var init_wasi_host = __esm({
         v.setUint16(out + 2, flags, true);
         let rights = seeks ? RIGHTS.ALL : RIGHTS.ALL & ~(RIGHTS.FD_SEEK | RIGHTS.FD_TELL);
         if (e.type === "kernel") {
-          const access = this.o.kernel.sys.access?.(fd);
-          if (access === "read") rights &= ~RIGHTS.FD_WRITE;
-          else if (access === "write") rights &= ~RIGHTS.FD_READ;
+          const access2 = this.o.kernel.sys.access?.(fd);
+          if (access2 === "read") rights &= ~RIGHTS.FD_WRITE;
+          else if (access2 === "write") rights &= ~RIGHTS.FD_READ;
         }
         v.setBigUint64(out + 8, rights, true);
         v.setBigUint64(out + 16, RIGHTS.ALL, true);
@@ -13596,32 +14207,61 @@ function ptsBridge(fs, call2) {
     }
   };
   const dir = () => devSync(kernel, devStat(PTS, true));
-  const statOf = (p, real) => {
+  const statOf = (p, real, follow3 = true) => {
     if (p === PTS) return dir();
+    if (SERIAL_AREA.test(p)) return devSync(kernel, devStat(p, follow3));
     return PTS_ENTRY.test(p) ? entry(p) : real();
   };
+  const serialNames = () => devSync(kernel, devReaddir("/dev")).filter((n) => SERIAL_AREA.test(`/dev/${n}`));
+  const withSerial = (listed2) => [
+    ...listed2,
+    ...serialNames().filter((n) => !listed2.includes(n))
+  ];
   const names = (known = open()) => known.map(capturedString).sort();
+  const serialEntry = (p, name2) => {
+    try {
+      return [name2, devSync(kernel, devStat(p, false))];
+    } catch {
+      return [name2, null];
+    }
+  };
   const over = {
     stat: (p) => statOf(p, () => fs.stat(p)),
-    lstat: (p) => statOf(p, () => fs.lstat(p)),
+    lstat: (p) => statOf(p, () => fs.lstat(p), false),
+    readlink: (p) => SERIAL_AREA.test(p) ? devSync(kernel, devReadlink(p)) : fs.readlink(p),
     exists: (p) => {
       if (p === PTS) return true;
+      if (SERIAL_AREA.test(p)) {
+        try {
+          devSync(kernel, devStat(p, true));
+          return true;
+        } catch {
+          return false;
+        }
+      }
       if (!PTS_ENTRY.test(p)) return fs.exists(p);
       return open().includes(capturedNumber(PTS_ENTRY.exec(p)?.[1]));
     },
     readdir: (p) => {
       if (p === PTS) return names();
+      if (SERIAL_AREA.test(p)) return devSync(kernel, devReaddir(p));
       const listed2 = fs.readdir(p);
-      return p === "/dev" && !listed2.includes("pts") ? [...listed2, "pts"] : listed2;
+      if (p !== "/dev") return listed2;
+      return withSerial(listed2.includes("pts") ? listed2 : [...listed2, "pts"]);
     },
     readdirStat: (p) => {
       if (p === PTS) {
         const known = open();
         return names(known).map((name2) => listedEntry(name2, known));
       }
+      if (SERIAL_AREA.test(p))
+        return devSync(kernel, devReaddir(p)).map((name2) => serialEntry(`${p}/${name2}`, name2));
       const listed2 = fs.readdirStat(p);
-      if (p !== "/dev" || listed2.some(([name2]) => name2 === "pts")) return listed2;
-      return [...listed2, ["pts", dir()]];
+      if (p !== "/dev") return listed2;
+      const all = listed2.some(([name2]) => name2 === "pts") ? listed2 : [...listed2, ["pts", dir()]];
+      const have = all.map(([name2]) => name2);
+      const extra = serialNames().filter((n) => !have.includes(n));
+      return [...all, ...extra.map((name2) => serialEntry(`/dev/${name2}`, name2))];
     }
   };
   return new capturedProxy(fs, {
@@ -13632,7 +14272,7 @@ function ptsBridge(fs, call2) {
     }
   });
 }
-var PTS, PTS_ENTRY;
+var PTS, PTS_ENTRY, SERIAL_AREA;
 var init_wasi_ptsfs = __esm({
   "src/process/wasi/wasi-ptsfs.ts"() {
     "use strict";
@@ -13641,6 +14281,7 @@ var init_wasi_ptsfs = __esm({
     init_js_dev();
     PTS = "/dev/pts";
     PTS_ENTRY = /^\/dev\/pts\/(\d+)$/;
+    SERIAL_AREA = /^\/dev\/(?:tty(?:USB|ACM)\d+|serial(?:\/.*)?)$/;
   }
 });
 
@@ -13854,13 +14495,13 @@ var init_wasi_stats = __esm({
       }
       report() {
         const ms = (v) => v.toFixed(1).padStart(9);
-        const lines = this.phases.map(([name2, t]) => `${ms(t)} ms  ${name2}`);
-        lines.push(`${"total ms".padStart(12)} ${"calls".padStart(7)} ${"max ms".padStart(9)}  call`);
+        const lines2 = this.phases.map(([name2, t]) => `${ms(t)} ms  ${name2}`);
+        lines2.push(`${"total ms".padStart(12)} ${"calls".padStart(7)} ${"max ms".padStart(9)}  call`);
         const sorted = [...this.rows].sort((a, b) => b[1].ms - a[1].ms);
         for (const [key, row] of sorted) {
-          lines.push(`${ms(row.ms)}   ${capturedString(row.n).padStart(7)} ${ms(row.max)}  ${key}`);
+          lines2.push(`${ms(row.ms)}   ${capturedString(row.n).padStart(7)} ${ms(row.max)}  ${key}`);
         }
-        return `${lines.join("\n")}
+        return `${lines2.join("\n")}
 `;
       }
     };
@@ -15406,11 +16047,11 @@ function parseFunctionNames(payload) {
   }
   return names;
 }
-function mainModule(lines) {
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const m = WASM_MODULE.exec(lines[i]);
+function mainModule(lines2) {
+  for (let i = lines2.length - 1; i >= 0; i--) {
+    const m = WASM_MODULE.exec(lines2[i]);
     if (!m) continue;
-    return lines.slice(i + 1).some((line) => /^\s+at /.test(line)) ? m[1] : void 0;
+    return lines2.slice(i + 1).some((line) => /^\s+at /.test(line)) ? m[1] : void 0;
   }
   return void 0;
 }
@@ -15574,12 +16215,12 @@ function unsupportedImport(module, memory, extended = false, foreign = {}) {
   const wasix = imports.some((i) => i.module === WASIX);
   const wasi = wasix || imports.some((i) => i.module === PREVIEW1);
   const scope2 = { extended, wasi, wasix, pie: dylinkInfo(module) !== void 0, memory };
-  const refused2 = imports.find((imp) => !accepted(imp, scope2));
-  if (refused2) {
-    if (refused2.kind === "memory" || refused2.module === "wasi") {
-      return `imports ${refused2.module}.${refused2.name}: no WASI program this host runs`;
+  const refused3 = imports.find((imp) => !accepted(imp, scope2));
+  if (refused3) {
+    if (refused3.kind === "memory" || refused3.module === "wasi") {
+      return `imports ${refused3.module}.${refused3.name}: no WASI program this host runs`;
     }
-    return `imports ${refused2.module}.${refused2.name}: no WASI preview1 program (an Emscripten one runs with its glue)`;
+    return `imports ${refused3.module}.${refused3.name}: no WASI preview1 program (an Emscripten one runs with its glue)`;
   }
   const unanswerable = extended ? void 0 : firstOther(foreign);
   if (unanswerable) return noErrno(unanswerable);
@@ -15874,14 +16515,14 @@ async function runWasiProcess(init, port2) {
   const stats = init.env.SLICC_WASI_STATS === "1" ? new WasiStats() : void 0;
   const call2 = stats ? timedCalls(stats, kernelCall) : kernelCall;
   const { module } = init.program;
-  const refused2 = unsupportedImport(
+  const refused3 = unsupportedImport(
     module,
     init.program.memory,
     init.program.imports !== void 0,
     init.program.foreign
   );
-  if (refused2) {
-    say(refused2);
+  if (refused3) {
+    say(refused3);
     return 126;
   }
   const fork = init.fork?.wasi;
@@ -15969,9 +16610,9 @@ async function runWasiProcess(init, port2) {
 function trapMessage(e, env, where = "", name2) {
   const head = `wasm trap${where}: ${e.message}`;
   if (env.SLICC_WASM_BACKTRACE !== "1") return head;
-  const lines = (rawStack(e) ?? "").split("\n");
-  const main = name2 && mainModule(lines);
-  const frames = lines.filter((line) => /^\s+at .*wasm:\/\/wasm\//.test(line)).slice(0, BACKTRACE_FRAMES).map((line) => name2 && main ? nameFrame(line, main, name2) : line);
+  const lines2 = (rawStack(e) ?? "").split("\n");
+  const main = name2 && mainModule(lines2);
+  const frames = lines2.filter((line) => /^\s+at .*wasm:\/\/wasm\//.test(line)).slice(0, BACKTRACE_FRAMES).map((line) => name2 && main ? nameFrame(line, main, name2) : line);
   return frames.length ? `${head}
 ${frames.join("\n")}` : head;
 }
@@ -17091,8 +17732,8 @@ function servedOf(r) {
     ...keylogOf(r.keylog)
   });
 }
-function keylogOf(lines) {
-  return lines ? { keylog: capturedObject.freeze([...lines]) } : {};
+function keylogOf(lines2) {
+  return lines2 ? { keylog: capturedObject.freeze([...lines2]) } : {};
 }
 function clientCert(tls, what = "connect") {
   if (tls.pfx !== void 0) {
@@ -17723,7 +18364,7 @@ function sendmsgRequest(fd, data, options = {}) {
   return {
     op: "sock-sendmsg",
     fd,
-    body: typeof data === "string" ? encoder2.encode(data) : data,
+    body: typeof data === "string" ? encoder3.encode(data) : data,
     fds: options.fds ?? [],
     nonblock: options.nonblock === true
   };
@@ -17770,14 +18411,14 @@ function rightsAsync(kernel, forget, watch) {
     }
   };
 }
-var jsonOf, bytesOf2, encoder2, RECV_DEFAULT;
+var jsonOf, bytesOf2, encoder3, RECV_DEFAULT;
 var init_js_rights = __esm({
   "src/process/js/js-rights.ts"() {
     "use strict";
     init_captured_globals();
     jsonOf = (r) => r.ok && r.kind === "json" ? r.json : void 0;
     bytesOf2 = (r) => r.ok && r.kind === "bytes" ? r.bytes : new capturedUint8Array(8);
-    encoder2 = new capturedTextEncoder();
+    encoder3 = new capturedTextEncoder();
     RECV_DEFAULT = 64 * 1024;
   }
 });
@@ -17819,7 +18460,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" ? encoder3.encode(o.input) : o.input;
+  const input = typeof o.input === "string" ? encoder4.encode(o.input) : o.input;
   const maxBuffer = limit(o.maxBuffer);
   const timeout = limit(o.timeout);
   const bytes = kernel.bytes({
@@ -17842,14 +18483,14 @@ function runSync(kernel, d, o) {
   });
   return decodeRun(bytes, stdout, stderr);
 }
-var encoder3, STDIO4;
+var encoder4, STDIO4;
 var init_js_run = __esm({
   "src/process/js/js-run.ts"() {
     "use strict";
     init_captured_globals();
     init_js_children();
     init_js_kernel();
-    encoder3 = new capturedTextEncoder();
+    encoder4 = new capturedTextEncoder();
     STDIO4 = new capturedSet(["pipe", "ignore", "inherit"]);
   }
 });
@@ -17912,7 +18553,7 @@ function syncOps(kernel, shared) {
     return r.ok && r.kind === "bytes" ? r.bytes : new capturedUint8Array(0);
   };
   const write2 = (fd, data, options) => {
-    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder5.encode(data) : data;
     const i = info(fd);
     if (writeDevice(i)) return bytes.length;
     const nonblock = options?.nonblock === true;
@@ -17946,7 +18587,7 @@ function syncOps(kernel, shared) {
     }
   };
   const openDev2 = (abs, options) => {
-    const { fd, file, ...access } = devSync(kernel, devOpen(abs, options));
+    const { fd, file, ...access2 } = devSync(kernel, devOpen(abs, options));
     const forget = () => {
       infos.delete(fd);
       handles.delete(fd);
@@ -17956,7 +18597,17 @@ function syncOps(kernel, shared) {
       forget();
       kernel.call({ op: "fd-close", fd: n });
     };
-    const handle = file ? syncFile(kernel, fd, abs, options.append === true, forget) : streamSyncFile(fd, abs, { read: (n, max) => read2(n, max), write: write2, close }, access);
+    const handle = file ? syncFile(kernel, fd, abs, options.append === true, forget) : streamSyncFile(
+      fd,
+      abs,
+      {
+        read: (n, max) => read2(n, max),
+        write: write2,
+        close,
+        ioctl: (n, request, arg) => kernel.json(ioctlRequest(n, request, arg))
+      },
+      access2
+    );
     handles.set(fd, handle.invalidate);
     return handle.file;
   };
@@ -18163,14 +18814,14 @@ function syncPathOps(kernel, resolve, statOf, open, clean) {
         ...mode !== void 0 ? { mode } : {}
       });
       try {
-        file.write(0, typeof data === "string" ? encoder4.encode(data) : data);
+        file.write(0, typeof data === "string" ? encoder5.encode(data) : data);
       } finally {
         file.close();
       }
     }
   };
 }
-var encoder4, typed2, getter2, bufferOf2, offsetOf3, setInto, noLane, READ_ONLY, JsSyncKernel;
+var encoder5, typed2, getter2, bufferOf2, offsetOf3, setInto, noLane, READ_ONLY, JsSyncKernel;
 var init_js_sync = __esm({
   "src/process/js/js-sync.ts"() {
     "use strict";
@@ -18184,7 +18835,7 @@ var init_js_sync = __esm({
     init_js_kernel();
     init_js_proc();
     init_js_rights();
-    encoder4 = new capturedTextEncoder();
+    encoder5 = new capturedTextEncoder();
     typed2 = capturedObject.getPrototypeOf(capturedUint8Array.prototype);
     getter2 = (name2) => capturedObject.getOwnPropertyDescriptor(typed2, name2)?.get;
     bufferOf2 = getter2("buffer");
@@ -19133,7 +19784,7 @@ function tracked2(pending, writeAll, writeSome, failed5) {
   return (fd, data, options) => {
     const status2 = failed5?.();
     if (status2 !== void 0) return capturedPromise.reject(new JsExit(status2));
-    const bytes = typeof data === "string" ? encoder5.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder6.encode(data) : data;
     let settle;
     const settled2 = new capturedPromise((resolve) => settle = resolve);
     pending.add(settled2);
@@ -19357,7 +20008,7 @@ function createContext(o) {
   return { ctx, drain: drain2 };
 }
 async function openDev(kernel, abs, options, state) {
-  const { fd, file, ...access } = await devAsync(kernel, devOpen(abs, options));
+  const { fd, file, ...access2 } = await devAsync(kernel, devOpen(abs, options));
   const forget = () => {
     state.infos.delete(fd);
     state.handles.delete(fd);
@@ -19370,8 +20021,13 @@ async function openDev(kernel, abs, options, state) {
   const handle = file ? fileHandle(kernel, fd, abs, options.append === true, forget) : streamFile(
     fd,
     abs,
-    { read: (n, max) => state.read(n, max), write: state.write, close },
-    access
+    {
+      read: (n, max) => state.read(n, max),
+      write: state.write,
+      close,
+      ioctl: (n, request, arg) => kernel.json(ioctlRequest(n, request, arg))
+    },
+    access2
   );
   state.handles.set(fd, handle.invalidate);
   return handle.file;
@@ -19540,14 +20196,14 @@ function pathOps(kernel, resolve, statOf, open, clean) {
         true
       );
       try {
-        await file.write(0, typeof data === "string" ? encoder5.encode(data) : data);
+        await file.write(0, typeof data === "string" ? encoder6.encode(data) : data);
       } finally {
         await file.close();
       }
     }
   };
 }
-var KERNEL_INFO, JsExit, encoder5, cryptoRandom, MEMORY_FIELDS;
+var KERNEL_INFO, JsExit, encoder6, cryptoRandom, MEMORY_FIELDS;
 var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
@@ -19583,7 +20239,7 @@ var init_js_context = __esm({
         this.status = status2;
       }
     };
-    encoder5 = new capturedTextEncoder();
+    encoder6 = new capturedTextEncoder();
     cryptoRandom = (bytes) => void capturedcrypto.getRandomValues(bytes);
     MEMORY_FIELDS = [
       "heapUsed",
@@ -19870,17 +20526,17 @@ function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs,
     message: err instanceof capturedError ? rawStack(err) ?? err.message : capturedString(err),
     ...code2 === void 0 ? {} : { code: code2 }
   });
-  let refused2;
+  let refused3;
   const sealOnce = () => {
-    if (refused2 === void 0) {
+    if (refused3 === void 0) {
       try {
         seal();
-        refused2 = null;
+        refused3 = null;
       } catch (error) {
-        refused2 = { error };
+        refused3 = { error };
       }
     }
-    return refused2;
+    return refused3;
   };
   return (data) => {
     const type = data?.type;