@ai-ecoverse/slicc-kernel 1.125.10 → 1.125.11

package/dist/process-worker.js

@@ -2655,7 +2655,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.125.10" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.125.11" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -4016,7 +4016,7 @@ var init_kernel_streams = __esm({
           }
         }
       }
-      openNode(stream, path, opener) {
+      openNode(stream, path, opener, terminal = false) {
         let kfd;
         try {
           kfd = this.call(() => opener.call(this.sys, stream.flags & 3));
@@ -4024,7 +4024,7 @@ var init_kernel_streams = __esm({
           this.Fs.closeStream(stream.fd);
           throw e;
         }
-        this.attach(stream, kfd, false);
+        this.attach(stream, kfd, terminal);
         this.nameStream(stream, path);
         if (path === CLIPBOARD_PATH) this.reportClose(kfd);
       }
@@ -4114,8 +4114,10 @@ var init_kernel_streams = __esm({
         const make = (parent, name2) => {
           const dir = getPath.call(fs, parent);
           if (dir === "/dev" && name2 === "pts") mkdir.call(fs, "/dev/pts", 493);
+          else if (dir === "/dev" && name2 === "ptmx" && this.sys.openPty)
+            this.ptyNode("/dev/ptmx", makedev.call(fs, 5, 2));
           else if (dir === "/dev/pts" && numbers().includes(Number(name2)) && /^\d+$/.test(name2))
-            mkdev.call(fs, `/dev/pts/${name2}`, makedev.call(fs, PTS_MAJOR, Number(name2)));
+            this.ptyNode(`/dev/pts/${name2}`, makedev.call(fs, PTS_MAJOR, Number(name2)));
           else return false;
           return true;
         };
@@ -4139,9 +4141,23 @@ var init_kernel_streams = __esm({
           const at = path.replace(/\/+$/, "");
           if (at === "/dev/pts") return [".", "..", ...numbers().map(String)];
           const names = readdir.call(fs, path);
-          return at === "/dev" && !names.includes("pts") ? [...names, "pts"] : names;
+          if (at !== "/dev") return names;
+          const extra = ["pts", ...this.sys.openPty ? ["ptmx"] : []];
+          return [...names, ...extra.filter((name2) => !names.includes(name2))];
         };
       }
+      ptyNode(path, dev) {
+        const fs = this.Fs;
+        fs.registerDevice?.call(fs, dev, {
+          open: (stream) => {
+            const n = PTY_PATH.exec(path)?.[1];
+            const { openPty, openPts } = this.sys;
+            const opener = () => n === void 0 ? openPty.call(this.sys) : openPts.call(this.sys, Number(n), (stream.flags & O_NOCTTY) !== 0);
+            this.openNode(stream, path, opener, true);
+          }
+        });
+        fs.mkdev?.call(fs, path, dev);
+      }
       ptsTarget(path, st) {
         if ((st?.rdev ?? 0) < PTS_MAJOR << 8) return void 0;
         const { lookupPath } = this.Fs;
@@ -4342,7 +4358,8 @@ var init_kernel_streams = __esm({
             if (!isPtyPath(path))
               return this.pathStat(path, original.call(fs, path, ...rest2), name2, owned);
             this.existingPty(path);
-            return ptyStat(path);
+            const st = ptyStat(path);
+            return this.options.owners === true ? { ...st, uid: 0, gid: 0 } : st;
           };
         }
       }
@@ -14953,6 +14970,7 @@ function childOps(kernel, io, defaults, sync) {
     const group = groupOf(o, "spawn");
     const named = argv0Of(o.argv0, "spawn");
     const death = deathOf(o.parentDeathSignal, defaults);
+    const inherit = fdsOf(o.fds);
     return (stdio) => ({
       op: "proc-spawn",
       file,
@@ -14962,6 +14980,7 @@ function childOps(kernel, io, defaults, sync) {
       cwd: o.cwd ?? defaults.cwd,
       ...o.cwd !== void 0 ? { chdir: true } : {},
       stdio,
+      ...inherit.length > 0 ? { inherit } : {},
       ...group,
       ...death
     });
@@ -14997,6 +15016,20 @@ function childOps(kernel, io, defaults, sync) {
   };
   return { spawn, wait: wait2, kill, spawnSync };
 }
+function fdsOf(fds) {
+  if (fds === void 0) return [];
+  if (typeof fds !== "object" || fds === null || Array.isArray(fds)) {
+    throw new JsCallError("EINVAL", "spawn");
+  }
+  return Object.entries(fds).map(([key, from]) => {
+    const fd = Number(key);
+    const valid = Number.isInteger(fd) && fd >= 3 && String(fd) === key;
+    if (!valid || !Number.isInteger(from) || from < 0) {
+      throw new JsCallError("EINVAL", "spawn");
+    }
+    return { fd, kernel: from };
+  });
+}
 function groupOf(o, call2) {
   const { pgid, session } = o;
   const valid = pgid === void 0 || Number.isInteger(pgid) && pgid >= 0;
@@ -16302,8 +16335,11 @@ function syncOps(kernel, shared) {
       handles.get(fd)?.();
       handles.delete(fd);
       infos.delete(fd);
+      shared.closing?.(fd);
       kernel.call({ op: "fd-close", fd });
     },
+    socketpair: () => kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    pipe: () => kernel.json({ op: "fd-pipe" }),
     open: procOpenSync(open, kernel, { resolve, pid: shared.pid }),
     fs: procFsSync(syncPathOps(kernel, resolve, statOf, open, tryDevSync), kernel, {
       resolve,
@@ -17010,12 +17046,37 @@ function watchingSyncOps(kernel, syncKernel, shared) {
   };
   return { ...ops, fs: { ...ops.fs, watch } };
 }
+function pendingReads(kernel, info, random) {
+  const reading = /* @__PURE__ */ new Map();
+  const read2 = async (fd, max = CHUNK, signal) => {
+    index2(max, "read");
+    const emulated = readDevice(await info(fd), max, random);
+    if (emulated) return emulated;
+    const stop = new AbortController();
+    const waits = reading.get(fd) ?? /* @__PURE__ */ new Set();
+    reading.set(fd, waits.add(stop));
+    try {
+      const n = Math.min(max, MAX_IO);
+      if (signal) return await readPipe(kernel, fd, n, AbortSignal.any([signal, stop.signal]));
+      const r = await kernel.blocking({ op: "fd-read", fd, max: n }, stop.signal);
+      return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+    } finally {
+      waits.delete(stop);
+      if (waits.size === 0 && reading.get(fd) === waits) reading.delete(fd);
+    }
+  };
+  const closing = (fd) => {
+    for (const stop of reading.get(fd) ?? []) stop.abort(new JsCallError("EBADF", "read"));
+    reading.delete(fd);
+  };
+  return { read: read2, closing };
+}
 function createContext(o) {
   const { kernel } = o;
   const infos = /* @__PURE__ */ new Map();
   const handles = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Set();
-  const random = o.random ?? ((bytes) => void crypto.getRandomValues(bytes));
+  const random = o.random ?? cryptoRandom;
   const resolve = (path) => resolvePath(o.cwd, path);
   const tryDev = (abs) => resolveDevAsync(kernel, abs);
   let exiting;
@@ -17035,12 +17096,7 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const read2 = async (fd, max = CHUNK, signal) => {
-    index2(max, "read");
-    const emulated = readDevice(await info(fd), max, random);
-    if (emulated) return emulated;
-    return readPipe(kernel, fd, Math.min(max, MAX_IO), signal);
-  };
+  const { read: read2, closing } = pendingReads(kernel, info, random);
   const { writes, writeAll } = writer(kernel, info, o.pid);
   const write2 = (fd, data) => {
     const bytes = typeof data === "string" ? encoder4.encode(data) : data;
@@ -17083,9 +17139,10 @@ function createContext(o) {
   if (o.lane && o.lane !== noLane) kernel.syncLane = o.lane;
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
   const terminal = ttyOps(kernel);
+  const shared = { pid: o.pid, resolve, random, infos, handles, closing };
   const sync = {
     kernel: KERNEL_INFO,
-    ...watchingSyncOps(kernel, syncKernel, { pid: o.pid, resolve, random, infos, handles }),
+    ...watchingSyncOps(kernel, syncKernel, shared),
     run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve, signal: signalNumber }, options),
     spawn: (options) => spawnSync(options),
     exit: (status2 = 0) => {
@@ -17124,8 +17181,11 @@ function createContext(o) {
       handles.get(fd)?.();
       handles.delete(fd);
       infos.delete(fd);
+      closing(fd);
       await kernel.call({ op: "fd-close", fd });
     },
+    socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    pipe: async () => await kernel.json({ op: "fd-pipe" }),
     async fdStatus(fd) {
       const type = typeOf(await info(fd));
       return { type, tty: type === "tty", seekable: type === "file" };
@@ -17350,7 +17410,7 @@ function pathOps(kernel, resolve, statOf, open, tryDev) {
     }
   };
 }
-var KERNEL_INFO, JsExit, encoder4;
+var KERNEL_INFO, JsExit, encoder4, cryptoRandom;
 var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
@@ -17381,6 +17441,7 @@ var init_js_context = __esm({
       }
     };
     encoder4 = new TextEncoder();
+    cryptoRandom = (bytes) => void crypto.getRandomValues(bytes);
   }
 });