@ai-ecoverse/slicc-kernel 1.68.0 → 1.70.0

package/dist/process-worker.js

@@ -1310,7 +1310,7 @@ function createStreamOps(h) {
       }
     }
   };
-  const opened = (node, on, want = 0) => {
+  const opened2 = (node, on, want = 0) => {
     const s = node.live;
     try {
       const handle = bridgeOf(node).hold?.(liveNodePath(node), on, true, s.handle, want);
@@ -1361,7 +1361,7 @@ function createStreamOps(h) {
         const want = permitted(stream, created);
         live.openCount++;
         counted = true;
-        if (live.openCount === 1) opened(stream.node, true, want);
+        if (live.openCount === 1) opened2(stream.node, true, want);
       } catch (err) {
         if (counted) live.openCount--;
         if (stream.fd !== void 0) Fs.closeStream?.(stream.fd);
@@ -1392,7 +1392,7 @@ function createStreamOps(h) {
         s.len = 0;
         s.loaded = false;
         held(stream, -1);
-        opened(node, false);
+        opened2(node, false);
       }
     },
     read(stream, buffer, offset, length, position) {
@@ -2130,8 +2130,8 @@ var init_kernel_streams = __esm({
         fs.readdir = (path) => {
           const names = readdir.call(fs, path);
           if (path.replace(/\/+$/, "") !== "/dev") return names;
-          const missing = ttyNames().map((tty) => tty.slice("/dev/".length)).filter((name2) => TTY_NAME.test(name2) && !names.includes(name2));
-          return [...names, ...missing];
+          const missing2 = ttyNames().map((tty) => tty.slice("/dev/".length)).filter((name2) => TTY_NAME.test(name2) && !names.includes(name2));
+          return [...names, ...missing2];
         };
       }
       ttyNode(name2) {
@@ -2909,13 +2909,13 @@ function describeFdDir(Fs) {
     return;
   }
   const ops = dir?.node_ops;
-  const lookup = ops?.lookup;
-  if (!dir || !lookup || ops.getattr) return;
+  const lookup2 = ops?.lookup;
+  if (!dir || !lookup2 || ops.getattr) return;
   dir.node_ops = {
     ...ops,
     getattr: () => syntheticAttr(DIR_MODE, 1),
     lookup: (parent, name2) => {
-      const entry = lookup(parent, name2);
+      const entry = lookup2(parent, name2);
       entry.node_ops = {
         ...entry.node_ops,
         getattr: () => syntheticAttr(LINK_MODE, entry.id ?? 0)
@@ -4205,7 +4205,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     return found;
   };
   const procOps = proc.node_ops;
-  const lookup = procOps.lookup?.bind(procOps);
+  const lookup2 = procOps.lookup?.bind(procOps);
   const readdir = procOps.readdir?.bind(procOps);
   const listAll = (node) => {
     const names = new Set(readdir ? readdir(node) : [".", ".."]);
@@ -4228,8 +4228,8 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
           () => systemFile(name2, procList(), Date.now(), memory)
         );
       }
-      if (!lookup) throw error();
-      return lookup(parent, name2);
+      if (!lookup2) throw error();
+      return lookup2(parent, name2);
     },
     readdir: (node) => listAll(node)
   };
@@ -5447,6 +5447,34 @@ var init_wasi_files = __esm({
   }
 });
 
+// src/kernel/pipe.ts
+var PIPE_CAPACITY;
+var init_pipe = __esm({
+  "src/kernel/pipe.ts"() {
+    "use strict";
+    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_pipe();
+    DEVICE_PATHS = /* @__PURE__ */ new Map([
+      ["/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);
@@ -5454,7 +5482,7 @@ function stdioAlias(path) {
   return m[1] ? 0 : m[2] ? 1 : m[3] ? 2 : Number(m[4]);
 }
 function deviceOf(path) {
-  return DEVICES2[path];
+  return deviceAt(path);
 }
 function within(path, root) {
   return path === root || path.startsWith(root === "/" ? "/" : `${root}/`);
@@ -5522,10 +5550,11 @@ 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, DEVICES2, SEALED_PATH2, WasiFds, GEN;
+var SYNTHETIC_DIRS2, O_NONBLOCK2, O_WRONLY4, O_RDWR4, O_APPEND, SEALED_PATH2, WasiFds, GEN;
 var init_wasi_fds = __esm({
   "src/process/wasi/wasi-fds.ts"() {
     "use strict";
+    init_fd_table();
     init_sync_fs_wire();
     init_wasi_abi();
     init_wasi_files();
@@ -5534,13 +5563,6 @@ var init_wasi_fds = __esm({
     O_WRONLY4 = 1;
     O_RDWR4 = 2;
     O_APPEND = 1024;
-    DEVICES2 = {
-      "/dev/null": "null",
-      "/dev/zero": "zero",
-      "/dev/full": "full",
-      "/dev/urandom": "urandom",
-      "/dev/random": "urandom"
-    };
     SEALED_PATH2 = "/dev/sealed";
     WasiFds = class {
       table = /* @__PURE__ */ new Map();
@@ -6653,11 +6675,11 @@ var init_wasi_host = __esm({
             this.writeFilestat(statOut, this.fdFilestat(fd));
             owner(fdOwned(fd), out);
           },
-          path_filestat_owner: (dirfd, lookup, p, l, statOut, out) => {
+          path_filestat_owner: (dirfd, lookup2, p, l, statOut, out) => {
             if (!this.o.fs.owners) throw new WasiError("ENOTSUP");
             const path = at(dirfd, p, l);
-            this.writeFilestat(statOut, this.pathFilestat(path, lookup));
-            owner(pathOwned(path, (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0), out);
+            this.writeFilestat(statOut, this.pathFilestat(path, lookup2));
+            owner(pathOwned(path, (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0), out);
           },
           path_owner: (dirfd, p, l, flags, out) => {
             if (!this.o.fs.owners) throw new WasiError("ENOTSUP");
@@ -6883,11 +6905,11 @@ var init_wasi_host = __esm({
             mem.view().setUint32(out, fds.open(path, oflags, rights, fdflags), true);
             if (fresh) this.created(path, 438);
           },
-          path_filestat_get: (dirfd, lookup, p, l, out) => void this.writeFilestat(out, this.pathFilestat(at(dirfd, p, l), lookup)),
-          path_filestat_set_times: (dirfd, lookup, p, l, atim, mtim, flags) => {
+          path_filestat_get: (dirfd, lookup2, p, l, out) => void this.writeFilestat(out, this.pathFilestat(at(dirfd, p, l), lookup2)),
+          path_filestat_set_times: (dirfd, lookup2, p, l, atim, mtim, flags) => {
             const path = at(dirfd, p, l);
             fds.flushPath(path);
-            this.setTimes(path, atim, mtim, flags, (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0);
+            this.setTimes(path, atim, mtim, flags, (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0);
           },
           path_create_directory: (dirfd, p, l) => {
             const path = at(dirfd, p, l);
@@ -6920,10 +6942,10 @@ var init_wasi_host = __esm({
             mem.bytes(buf, n).set(target.subarray(0, n));
             mem.view().setUint32(used, n, true);
           },
-          path_link: (fd, lookup, p, l, fd2, p2, l2) => {
+          path_link: (fd, lookup2, p, l, fd2, p2, l2) => {
             const from = at(fd, p, l);
             const to = at(fd2, p2, l2);
-            const follow2 = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
+            const follow2 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
             const source = follow2 ? physicalPath(o.fs, from) : from;
             fds.flushPath(from);
             if (source !== from) fds.flushPath(source);
@@ -7191,7 +7213,7 @@ var init_wasi_host = __esm({
       synthetic(path) {
         return deviceOf(path) !== void 0 || path === SEALED_PATH2 && !!this.o.kernel.sys.openSealed;
       }
-      pathFilestat(path, lookup) {
+      pathFilestat(path, lookup2) {
         if (this.synthetic(path)) {
           return this.local({
             filetype: FILETYPE.CHARACTER_DEVICE,
@@ -7201,7 +7223,7 @@ var init_wasi_host = __esm({
           });
         }
         this.fds.flushPath(path);
-        const follow2 = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
+        const follow2 = (lookup2 & LOOKUP_SYMLINK_FOLLOW) !== 0;
         return filestatOf(path, follow2 ? this.o.fs.stat(path) : this.o.fs.lstat(path));
       }
       setTimes(path, atim, mtim, flags, follow2 = true) {
@@ -7399,12 +7421,12 @@ var init_wasix_process = __esm({
         fds.promoteFiles();
         const map = fds.inheritable();
         const nulls = /* @__PURE__ */ new Set();
-        const opened = [];
+        const opened2 = [];
         let cwd = this.host.cwd;
         try {
-          for (const op of ops) cwd = this.applyFdOp(op, { map, nulls, opened }, cwd);
+          for (const op of ops) cwd = this.applyFdOp(op, { map, nulls, opened: opened2 }, cwd);
         } catch (e) {
-          for (const kfd of opened) this.host.o.kernel.sys.close(kfd);
+          for (const kfd of opened2) this.host.o.kernel.sys.close(kfd);
           throw e;
         }
         const stdio = [0, 1, 2].map((fd) => {
@@ -7415,10 +7437,10 @@ var init_wasix_process = __esm({
           ...[...map].filter(([fd]) => fd > 2).map(([fd, kernel]) => ({ fd, kernel })),
           ...[...nulls].filter((fd) => fd > 2).map((fd) => ({ fd, device: "null" }))
         ];
-        return { stdio, inherit, cwd, opened };
+        return { stdio, inherit, cwd, opened: opened2 };
       }
       applyFdOp(op, slots3, cwd) {
-        const { map, nulls, opened } = slots3;
+        const { map, nulls, opened: opened2 } = slots3;
         const { fds } = this.host;
         const point = (fd, kfd) => {
           if (kfd === void 0) {
@@ -7441,7 +7463,7 @@ var init_wasix_process = __esm({
           point(op.fd, void 0);
         } else if (op.cmd === "open") {
           const kfd = this.openFor(op, cwd);
-          opened.push(kfd);
+          opened2.push(kfd);
           point(op.fd, kfd);
         } else if (op.cmd === "chdir") return this.physicalFrom(cwd, op.path);
         else return physicalPath(this.host.o.fs, fds.dir(op.fd).path);
@@ -7463,7 +7485,7 @@ var init_wasix_process = __esm({
         });
       }
       spawn(req, exec = false) {
-        const { stdio, inherit, cwd, opened } = this.childFds(req.ops ?? []);
+        const { stdio, inherit, cwd, opened: opened2 } = this.childFds(req.ops ?? []);
         try {
           const spawn = {
             op: "proc-spawn",
@@ -7478,7 +7500,7 @@ var init_wasix_process = __esm({
           };
           return restarted2(() => this.call(spawn));
         } finally {
-          for (const kfd of opened) this.host.o.kernel.sys.close(kfd);
+          for (const kfd of opened2) this.host.o.kernel.sys.close(kfd);
           this.host.o.fs.invalidate?.();
         }
       }
@@ -9823,8 +9845,8 @@ var init_wasix_host = __esm({
             mem.view().setUint16(out, host.fds.cloexec.has(fd) ? FDFLAGSEXT_CLOEXEC : 0, true);
           },
           fd_fdflags_set: (fd, flags) => void host.fds.setCloexec(fd, (flags & FDFLAGSEXT_CLOEXEC) !== 0),
-          path_open2: (dirfd, lookup, p, l, oflags, rights, inheriting, fdflags, fdflagsext, out) => {
-            const r = preview1.path_open(dirfd, lookup, p, l, oflags, rights, inheriting, fdflags, out);
+          path_open2: (dirfd, lookup2, p, l, oflags, rights, inheriting, fdflags, fdflagsext, out) => {
+            const r = preview1.path_open(dirfd, lookup2, p, l, oflags, rights, inheriting, fdflags, out);
             if (r === E.SUCCESS && fdflagsext & FDFLAGSEXT_CLOEXEC)
               host.fds.setCloexec(mem.view().getUint32(out, true), true);
             return r;
@@ -10797,6 +10819,11 @@ function untilAborted(work, signal) {
     work.then(done, done);
   });
 }
+function caughtOf(handlers) {
+  let caught = 0;
+  for (const sig of handlers.keys()) caught |= sigbit(sig);
+  return caught;
+}
 var JsCallError, JsKernel;
 var init_js_kernel = __esm({
   "src/process/js/js-kernel.ts"() {
@@ -10824,6 +10851,7 @@ var init_js_kernel = __esm({
       reported = { caught: 0, ignored: 0 };
       watching = false;
       faulted = false;
+      syncLane;
       constructor(o) {
         this.header = new Int32Array(o.sab, 0, SAB_HEADER_I32);
         this.transport = o.transport;
@@ -10926,16 +10954,41 @@ var init_js_kernel = __esm({
         if (sig === SIG.KILL || sig === SIG.STOP) {
           return Promise.reject(new JsCallError("EINVAL", "signal"));
         }
+        if (this.syncLane) {
+          try {
+            this.changeNow(this.syncLane, sig, handler);
+            return Promise.resolve();
+          } catch (err) {
+            return Promise.reject(err);
+          }
+        }
         const run = this.changing.then(() => this.change(sig, handler));
         this.changing = run.catch(() => void 0);
         return run;
       }
-      async change(sig, handler) {
+      changeNow(lane, sig, handler) {
+        const { handlers, ignored } = this.disposed(sig, handler);
+        const defaults = handler === "default" ? sigbit(sig) : 0;
+        const caught = caughtOf(handlers);
+        if (caught !== this.reported.caught || ignored !== this.reported.ignored || defaults !== 0) {
+          const r = lane({ op: "sig-mask", caught, ignored, ...defaults ? { defaults } : {} });
+          if (!r.ok) throw new JsCallError(r.errno, "sig-mask");
+          this.reported = { caught, ignored };
+        }
+        this.handlers = handlers;
+        this.ignored = ignored;
+        if (handlers.size > 0) void this.watch();
+      }
+      disposed(sig, handler) {
         const handlers = new Map(this.handlers);
         handlers.delete(sig);
         let ignored = this.ignored & ~sigbit(sig);
         if (handler === "ignore") ignored |= sigbit(sig);
         else if (handler !== "default") handlers.set(sig, handler);
+        return { handlers, ignored };
+      }
+      async change(sig, handler) {
+        const { handlers, ignored } = this.disposed(sig, handler);
         await this.report(handlers, ignored, handler === "default" ? sigbit(sig) : 0);
         this.handlers = handlers;
         this.ignored = ignored;
@@ -10945,8 +10998,7 @@ var init_js_kernel = __esm({
         this.call({ op: "proc-kill", pid: this.pid, sig }).catch(this.onError);
       }
       async report(handlers, ignored, defaults) {
-        let caught = 0;
-        for (const sig of handlers.keys()) caught |= sigbit(sig);
+        const caught = caughtOf(handlers);
         const same = caught === this.reported.caught && ignored === this.reported.ignored;
         if (same && defaults === 0) return;
         this.reported = { caught, ignored };
@@ -11166,6 +11218,344 @@ var init_js_io = __esm({
   }
 });
 
+// src/process/js/js-dev.ts
+function inDev(abs) {
+  return abs.startsWith("/dev") && (abs.length === 4 || abs[4] === "/");
+}
+function missing(path) {
+  throw new JsCallError("ENOENT", path);
+}
+function nodeStat(mode, size = 0, owner) {
+  return {
+    isFile: false,
+    isDirectory: (mode & S_IFMT2) === DIR,
+    isSymbolicLink: (mode & S_IFMT2) === LINK,
+    size,
+    mode,
+    mtimeMs: BORN,
+    atimeMs: BORN,
+    ctimeMs: BORN,
+    nlink: 1,
+    uid: owner?.uid ?? 0,
+    gid: owner?.gid ?? 0
+  };
+}
+function* lookup(abs) {
+  if (abs === "/dev") return { kind: "dir", mode: DIR | 493 };
+  const name2 = abs.slice("/dev/".length);
+  if (DEVICES2.includes(name2)) return { kind: "device" };
+  if (name2 === "tty") return { kind: "tty" };
+  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 };
+  const fd = /^fd\/(\d+)$/.exec(name2)?.[1];
+  if (fd !== void 0) return { kind: "fd", fd: Number(fd) };
+  if (/^tty\d+$/.test(name2)) {
+    const names = yield { op: "fd-tty-names" };
+    if (names.includes(abs)) return { kind: "terminal", name: abs };
+  }
+  const pts = /^pts\/(\d+)$/.exec(name2)?.[1];
+  if (pts !== void 0) {
+    const open = yield { op: "pty-list" };
+    if (open.includes(Number(pts))) return { kind: "terminal", name: abs, pts: Number(pts) };
+  }
+  return missing(abs);
+}
+function* fdInfo(fd, path) {
+  try {
+    return yield { op: "fd-info", fd };
+  } catch (err) {
+    if (err instanceof JsCallError && err.code === "EBADF") return missing(path);
+    throw err;
+  }
+}
+function* pathStat(path) {
+  const s = parseSyncFsStat(yield { op: "stat", path });
+  if (!s) throw new JsCallError("EIO", "stat");
+  return s;
+}
+function* terminalStat(name2) {
+  const owner = yield { op: "fd-tty-owner", name: name2 };
+  if (owner) return nodeStat(CHAR | (owner.mode ?? 400), 0, owner);
+  return nodeStat(CHAR | (name2.startsWith("/dev/pts/") ? 400 : 438));
+}
+function* fdStat(fd, path) {
+  const info = yield* fdInfo(fd, path);
+  if (info.meta && "dir" in info.meta) return yield* pathStat(info.meta.dir);
+  if (info.kind === "file") {
+    const file = yield { op: "fd-vfs-stat", fd };
+    if (file.orphan) return { ...nodeStat(33152, file.size), isFile: true };
+    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 === "socket") return nodeStat(49663);
+  return nodeStat(4480);
+}
+function* fdTarget(fd, path) {
+  const info = yield* fdInfo(fd, path);
+  if (info.meta && "dir" in info.meta) return info.meta.dir;
+  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}`;
+  return `${info.kind === "socket" ? "socket" : "pipe"}:[${fd}]`;
+}
+function linkStat(target) {
+  return nodeStat(LINK | 511, target.length);
+}
+function* devStat(abs, follow2) {
+  const node = yield* lookup(abs);
+  switch (node.kind) {
+    case "dir":
+      return nodeStat(node.mode);
+    case "device":
+    case "tty":
+      return nodeStat(CHAR | 438);
+    case "terminal":
+      return yield* terminalStat(node.name);
+    case "link":
+      if (!follow2) return linkStat(node.target);
+      return node.fd === void 0 ? nodeStat(DIR | 365) : yield* fdStat(node.fd, abs);
+    case "fd":
+      return follow2 ? yield* fdStat(node.fd, abs) : linkStat(yield* fdTarget(node.fd, abs));
+  }
+}
+function* devExists(abs) {
+  try {
+    yield* devStat(abs, true);
+    return true;
+  } catch (err) {
+    if (err instanceof JsCallError) return false;
+    throw err;
+  }
+}
+function* devReadlink(abs) {
+  const node = yield* lookup(abs);
+  if (node.kind === "link") return node.target;
+  if (node.kind === "fd") return yield* fdTarget(node.fd, abs);
+  throw new JsCallError("EINVAL", abs);
+}
+function* devReaddir(abs) {
+  if (abs === "/dev/fd") {
+    const fds = yield { op: "fd-list" };
+    return fds.map(({ fd }) => String(fd));
+  }
+  const node = yield* lookup(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();
+}
+function* aliasOf(fd, abs, o) {
+  const info = yield* fdInfo(fd, abs);
+  const file = info.kind === "file";
+  if (file) {
+    const at = yield { op: "fd-vfs-stat", fd };
+    if (!at.orphan)
+      return { fd: yield openRequest(at.path, { ...o, create: false }), file };
+  }
+  const copy2 = yield { op: "fd-dup", fd, min: 3 };
+  if (file && o.truncate) {
+    try {
+      yield { op: "fd-resize", fd: copy2, size: 0 };
+    } catch (err) {
+      yield { op: "fd-close", fd: copy2 };
+      throw err;
+    }
+  }
+  return { fd: copy2, file };
+}
+function* opened(abs, o) {
+  const node = yield* lookup(abs);
+  if (isExclusive(o)) throw new JsCallError("EEXIST", abs);
+  switch (node.kind) {
+    case "device":
+      return { fd: yield openRequest(abs, { ...o, create: false }), file: false };
+    case "tty":
+      return { fd: yield { op: "fd-open-tty" }, 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 };
+    }
+    case "fd":
+      return yield* aliasOf(node.fd, abs, o);
+    case "link":
+      if (node.fd !== void 0) return yield* aliasOf(node.fd, abs, o);
+      throw new JsCallError("EISDIR", abs);
+    case "dir":
+      throw new JsCallError("EISDIR", abs);
+  }
+}
+function* devOpen(abs, o) {
+  const write2 = o.write === true || o.append === true || o.truncate === true;
+  return { ...yield* opened(abs, o), read: o.read === true || !write2, write: write2 };
+}
+async function devAsync(kernel, step) {
+  let next2 = step.next();
+  while (!next2.done) {
+    let answer2;
+    try {
+      answer2 = { value: await kernel.json(next2.value) };
+    } catch (error) {
+      answer2 = { error };
+    }
+    next2 = "value" in answer2 ? step.next(answer2.value) : step.throw(answer2.error);
+  }
+  return next2.value;
+}
+function devSync(kernel, step) {
+  let next2 = step.next();
+  while (!next2.done) {
+    let answer2;
+    try {
+      answer2 = { value: kernel.json(next2.value) };
+    } catch (error) {
+      answer2 = { error };
+    }
+    next2 = "value" in answer2 ? step.next(answer2.value) : step.throw(answer2.error);
+  }
+  return next2.value;
+}
+function tooLarge(got) {
+  if (got > DEV_READ_MAX) throw new JsCallError("EFBIG", "readFile");
+}
+function liveness(path) {
+  let open = true;
+  return {
+    live: () => {
+      if (!open) throw new JsCallError("EBADF", path);
+    },
+    end: () => {
+      open = false;
+    }
+  };
+}
+function allowed(may, what) {
+  if (!may) throw new JsCallError("EBADF", what);
+}
+function streamFile(fd, path, io, access) {
+  const { live, end } = liveness(path);
+  const file = {
+    fd,
+    path,
+    async size() {
+      live();
+      return 0;
+    },
+    async read(position, length) {
+      index2(position, "read");
+      index2(length, "read");
+      live();
+      allowed(access.read, "read");
+      return length === 0 ? new Uint8Array(0) : io.read(fd, Math.min(length, MAX_IO));
+    },
+    async write(position, data) {
+      index2(position, "write");
+      live();
+      allowed(access.write, "write");
+      await io.write(fd, data);
+      return data.length;
+    },
+    async truncate(size) {
+      live();
+      index2(size, "truncate");
+      throw new JsCallError("EINVAL", "truncate");
+    },
+    sync: async () => live(),
+    async close() {
+      live();
+      end();
+      await io.close(fd);
+    }
+  };
+  return { file, invalidate: end };
+}
+function streamSyncFile(fd, path, io, access) {
+  const { live, end } = liveness(path);
+  const file = {
+    fd,
+    path,
+    size() {
+      live();
+      return 0;
+    },
+    read(position, length) {
+      index2(position, "read");
+      index2(length, "read");
+      live();
+      allowed(access.read, "read");
+      return length === 0 ? new Uint8Array(0) : io.read(fd, Math.min(length, MAX_IO));
+    },
+    write(position, data) {
+      index2(position, "write");
+      live();
+      allowed(access.write, "write");
+      io.write(fd, data);
+      return data.length;
+    },
+    truncate(size) {
+      live();
+      index2(size, "truncate");
+      throw new JsCallError("EINVAL", "truncate");
+    },
+    sync: () => live(),
+    close() {
+      live();
+      end();
+      io.close(fd);
+    }
+  };
+  return { file, invalidate: end };
+}
+async function readWhole(file) {
+  try {
+    const parts = [];
+    let got = 0;
+    for (; ; ) {
+      const chunk = await file.read(got, MAX_IO);
+      if (chunk.length === 0) return joined(parts, got);
+      got += chunk.length;
+      tooLarge(got);
+      parts.push(chunk);
+    }
+  } finally {
+    await file.close();
+  }
+}
+function readWholeSync(file) {
+  try {
+    const parts = [];
+    let got = 0;
+    for (; ; ) {
+      const chunk = file.read(got, MAX_IO);
+      if (chunk.length === 0) return joined(parts, got);
+      got += chunk.length;
+      tooLarge(got);
+      parts.push(chunk);
+    }
+  } finally {
+    file.close();
+  }
+}
+var DEV_READ_MAX, DEVICES2, STDIO3, SELF_FD, S_IFMT2, DIR, LINK, CHAR, BORN;
+var init_js_dev = __esm({
+  "src/process/js/js-dev.ts"() {
+    "use strict";
+    init_sync_fs_wire();
+    init_js_io();
+    init_js_kernel();
+    DEV_READ_MAX = 64 * 1024 * 1024;
+    DEVICES2 = ["null", "zero", "full", "random", "urandom"];
+    STDIO3 = ["stdin", "stdout", "stderr"];
+    SELF_FD = "/proc/self/fd";
+    S_IFMT2 = 61440;
+    DIR = 16384;
+    LINK = 40960;
+    CHAR = 8192;
+    BORN = Date.now();
+  }
+});
+
 // src/process/js/js-exit.ts
 function json(r) {
   return r.ok && r.kind === "json" ? r.json : void 0;
@@ -11178,10 +11568,10 @@ function restoreMode(lane, { terminal, fd, termios }) {
     lane({ op: "tty-set", fd: at, termios });
     return;
   }
-  const opened = json(lane({ op: "fd-open-tty", name: terminal }));
-  if (typeof opened !== "number") return;
-  lane({ op: "tty-set", fd: opened, termios });
-  lane({ op: "fd-close", fd: opened });
+  const opened2 = json(lane({ op: "fd-open-tty", name: terminal }));
+  if (typeof opened2 !== "number") return;
+  lane({ op: "tty-set", fd: opened2, termios });
+  lane({ op: "fd-close", fd: opened2 });
 }
 function writeOut(lane, fd, data) {
   let at = 0;
@@ -11630,7 +12020,7 @@ function netOps(kernel, io) {
     const r = await kernel.blocking({ op: "sock-resolve", name: host, family: 4 }, signal);
     return (r.ok && r.kind === "json" ? r.json : [])[0];
   };
-  const opened = async (use) => {
+  const opened2 = async (use) => {
     const fd = await kernel.json({ op: "sock-open", domain: "inet" });
     try {
       return await use(fd);
@@ -11672,7 +12062,7 @@ function netOps(kernel, io) {
     };
   };
   return {
-    listen: (options = {}) => opened(async (fd) => {
+    listen: (options = {}) => opened2(async (fd) => {
       const addr = {
         family: "inet",
         host: options.host ?? "127.0.0.1",
@@ -11692,7 +12082,7 @@ function netOps(kernel, io) {
         host: await resolve(host, signal),
         port: port(options.port)
       };
-      return opened(async (fd) => {
+      return opened2(async (fd) => {
         const r = await kernel.raw({ op: "sock-connect", fd, addr, nonblock: true });
         if (!r.ok && r.errno !== "EINPROGRESS") throw new JsCallError(r.errno, "connect");
         await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
@@ -11726,9 +12116,13 @@ var init_js_net = __esm({
 // src/process/js/js-run.ts
 function stdioOf(how) {
   if (how === void 0) return "pipe";
-  if (!STDIO3.has(how)) throw new JsCallError("EINVAL", "run");
+  if (typeof how === "number" && Number.isInteger(how) && how >= 0) return how;
+  if (!STDIO4.has(how)) throw new JsCallError("EINVAL", "run");
   return how;
 }
+function stderrOf(how) {
+  return how === "stdout" ? how : stdioOf(how);
+}
 function limit(value2) {
   if (value2 === void 0 || value2 === Number.POSITIVE_INFINITY) return value2;
   if (!(value2 >= 0)) throw new JsCallError("EINVAL", "run");
@@ -11753,7 +12147,7 @@ function runSync(kernel, d, o) {
   const [file] = o.argv;
   if (file === void 0) throw new JsCallError("EINVAL", "run");
   const stdout = stdioOf(o.stdout);
-  const stderr = stdioOf(o.stderr);
+  const stderr = stderrOf(o.stderr);
   const input = typeof o.input === "string" ? encoder2.encode(o.input) : o.input;
   const maxBuffer = limit(o.maxBuffer);
   const timeout = limit(o.timeout);
@@ -11774,13 +12168,13 @@ function runSync(kernel, d, o) {
   });
   return decodeRun(bytes, stdout, stderr);
 }
-var encoder2, STDIO3;
+var encoder2, STDIO4;
 var init_js_run = __esm({
   "src/process/js/js-run.ts"() {
     "use strict";
     init_js_kernel();
     encoder2 = new TextEncoder();
-    STDIO3 = /* @__PURE__ */ new Set(["pipe", "ignore", "inherit"]);
+    STDIO4 = /* @__PURE__ */ new Set(["pipe", "ignore", "inherit"]);
   }
 });
 
@@ -11823,13 +12217,30 @@ function syncOps(kernel, shared) {
   };
   const statOf = (op, path) => {
     const abs = resolve(path);
+    if (inDev(abs)) return devSync(kernel, devStat(abs, op === "stat"));
     kernel.call({ op: "fd-path-flush", path: abs });
     const s = parseSyncFsStat(kernel.json({ op, path: abs }));
     if (!s) throw new JsCallError("EIO", op);
     return s;
   };
+  const openDev2 = (abs, options) => {
+    const { fd, file, ...access } = devSync(kernel, devOpen(abs, options));
+    const forget = () => {
+      infos.delete(fd);
+      handles.delete(fd);
+    };
+    if (file) infos.set(fd, { kind: "file" });
+    const close = (n) => {
+      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);
+    handles.set(fd, handle.invalidate);
+    return handle.file;
+  };
   const open = (path, options = {}) => {
     const abs = resolve(path);
+    if (inDev(abs)) return openDev2(abs, options);
     let existing;
     try {
       existing = statOf(isExclusive(options) ? "lstat" : "stat", abs);
@@ -11933,17 +12344,30 @@ function syncPathOps(kernel, resolve, statOf, open) {
   return {
     stat: (path) => statOf("stat", path),
     lstat: (path) => statOf("lstat", path),
-    exists: (path) => kernel.json({ op: "exists", path: resolve(path) }) === true,
-    readdir: (path) => kernel.json({ op: "readdir", path: resolve(path) }),
+    exists(path) {
+      const abs = resolve(path);
+      if (inDev(abs)) return devSync(kernel, devExists(abs));
+      return kernel.json({ op: "exists", path: abs }) === true;
+    },
+    readdir(path) {
+      const abs = resolve(path);
+      if (inDev(abs)) return devSync(kernel, devReaddir(abs));
+      return kernel.json({ op: "readdir", path: abs });
+    },
     mkdir: (path) => void kernel.call({ op: "mkdir", path: resolve(path) }),
     rm: (path) => void kernel.call({ op: "rm", path: resolve(path) }),
     unlink: (path) => void kernel.call({ op: "unlink", path: resolve(path) }),
     rename: (from, to) => void kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
     link: (from, to) => void kernel.call({ op: "link", path: resolve(from), arg2: resolve(to) }),
     symlink: (target, path) => void kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
-    readlink: (path) => String(kernel.json({ op: "readlink", path: resolve(path) })),
+    readlink(path) {
+      const abs = resolve(path);
+      if (inDev(abs)) return devSync(kernel, devReadlink(abs));
+      return String(kernel.json({ op: "readlink", path: abs }));
+    },
     readFile(path) {
       const abs = resolve(path);
+      if (inDev(abs)) return readWholeSync(open(abs));
       kernel.call({ op: "fd-path-flush", path: abs });
       return kernel.bytes({ op: "read", path: abs });
     },
@@ -11964,6 +12388,7 @@ var init_js_sync = __esm({
     init_signals();
     init_sync_fs_wire();
     init_sync_sab_bridge();
+    init_js_dev();
     init_js_io();
     init_js_kernel();
     encoder3 = new TextEncoder();
@@ -12364,6 +12789,7 @@ function createContext(o) {
   const writable2 = (fd) => new WritableStream({ write: (chunk) => write2(fd, chunk) });
   const statOf = async (op, path) => {
     const abs = resolve(path);
+    if (inDev(abs)) return devAsync(kernel, devStat(abs, op === "stat"));
     await kernel.call({ op: "fd-path-flush", path: abs });
     const s = parseSyncFsStat(await kernel.json({ op, path: abs }));
     if (!s) throw new JsCallError("EIO", op);
@@ -12371,6 +12797,7 @@ function createContext(o) {
   };
   const open = async (path, options = {}) => {
     const abs = resolve(path);
+    if (inDev(abs)) return openDev(kernel, abs, options, { infos, handles, read: read2, write: writeAll });
     const existing = await statOf(isExclusive(options) ? "lstat" : "stat", abs).catch(absent);
     checkOpen(abs, options, existing);
     const fd = await kernel.json(openRequest(abs, options));
@@ -12390,6 +12817,7 @@ function createContext(o) {
   };
   const fs = pathOps(kernel, resolve, statOf, open);
   const lane = o.lane ?? laneOf(void 0);
+  if (o.lane) kernel.syncLane = o.lane;
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
   const terminal = ttyOps(kernel);
   const sync = {
@@ -12470,6 +12898,26 @@ 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 forget = () => {
+    state.infos.delete(fd);
+    state.handles.delete(fd);
+  };
+  if (file) state.infos.set(fd, { kind: "file" });
+  const close = async (n) => {
+    forget();
+    await kernel.call({ op: "fd-close", fd: n });
+  };
+  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
+  );
+  state.handles.set(fd, handle.invalidate);
+  return handle.file;
+}
 function fileHandle(kernel, fd, path, append, forget) {
   let open = true;
   const live = () => {
@@ -12562,17 +13010,30 @@ function pathOps(kernel, resolve, statOf, open) {
   return {
     stat: (path) => statOf("stat", path),
     lstat: (path) => statOf("lstat", path),
-    exists: async (path) => await kernel.json({ op: "exists", path: resolve(path) }) === true,
-    readdir: async (path) => await kernel.json({ op: "readdir", path: resolve(path) }),
+    async exists(path) {
+      const abs = resolve(path);
+      if (inDev(abs)) return devAsync(kernel, devExists(abs));
+      return await kernel.json({ op: "exists", path: abs }) === true;
+    },
+    async readdir(path) {
+      const abs = resolve(path);
+      if (inDev(abs)) return devAsync(kernel, devReaddir(abs));
+      return await kernel.json({ op: "readdir", path: abs });
+    },
     mkdir: async (path) => void await kernel.call({ op: "mkdir", path: resolve(path) }),
     rm: async (path) => void await kernel.call({ op: "rm", path: resolve(path) }),
     unlink: async (path) => void await kernel.call({ op: "unlink", path: resolve(path) }),
     rename: async (from, to) => void await kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
     link: async (from, to) => void await kernel.call({ op: "link", path: resolve(from), arg2: resolve(to) }),
     symlink: async (target, path) => void await kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
-    readlink: async (path) => String(await kernel.json({ op: "readlink", path: resolve(path) })),
+    async readlink(path) {
+      const abs = resolve(path);
+      if (inDev(abs)) return devAsync(kernel, devReadlink(abs));
+      return String(await kernel.json({ op: "readlink", path: abs }));
+    },
     async readFile(path) {
       const abs = resolve(path);
+      if (inDev(abs)) return readWhole(await open(abs));
       await kernel.call({ op: "fd-path-flush", path: abs });
       return kernel.bytes({ op: "read", path: abs });
     },
@@ -12593,6 +13054,7 @@ var init_js_context = __esm({
     init_signals();
     init_sync_fs_wire();
     init_js_children();
+    init_js_dev();
     init_js_exit();
     init_js_fetch();
     init_js_io();