@ai-ecoverse/slicc-kernel 1.39.2 → 1.40.1

package/dist/process-worker.js

@@ -2730,13 +2730,13 @@ function describeInherited(Fs, sys, streams, livePath, actions = []) {
     if (from) table.set(target, { stream: from.stream, cloexec: false });
     else table.delete(target);
   }
-  const slots = /* @__PURE__ */ new Map();
+  const slots2 = /* @__PURE__ */ new Map();
   for (const [fd, { stream, cloexec }] of table) {
-    if (fd > 2 && !cloexec) slots.set(fd, stream);
+    if (fd > 2 && !cloexec) slots2.set(fd, stream);
   }
   const promote = vfsPromoter(Fs, sys, streams, livePath);
   const out = [];
-  for (const [fd, stream] of slots) {
+  for (const [fd, stream] of slots2) {
     promote(stream);
     const slot = inheritedSlot(fd, stream);
     if (slot) out.push(slot);
@@ -2928,6 +2928,7 @@ function createProcessKernel(deps) {
     if (!stream) return { none: true };
     promote?.(stream);
     if (stream.sliccKernelFd !== void 0) return { fd: stream.sliccKernelFd };
+    if (((stream.node?.mode ?? 0) & S_IFMT) === S_IFDIR2 && stream.path) return { dir: stream.path };
     const device2 = deviceOfStream(stream);
     if (device2) return device2;
     return n === 0 ? { input: drain(Fs, stream) } : { capture: true };
@@ -3071,12 +3072,14 @@ function createProcessKernel(deps) {
     }
   };
 }
-var POLLIN2, POLLOUT2, POLLERR2, POLLHUP2, POLLNVAL, SELECT_SLICE_MS, WUNTRACED, WCONTINUED;
+var S_IFMT, S_IFDIR2, POLLIN2, POLLOUT2, POLLERR2, POLLHUP2, POLLNVAL, SELECT_SLICE_MS, WUNTRACED, WCONTINUED;
 var init_process_children = __esm({
   "src/process/process-children.ts"() {
     "use strict";
     init_process_fork();
     init_wasi_errno();
+    S_IFMT = 61440;
+    S_IFDIR2 = 16384;
     POLLIN2 = 1;
     POLLOUT2 = 4;
     POLLERR2 = 8;
@@ -3785,7 +3788,7 @@ function kernelSys(transport) {
     kind(fd) {
       return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.kind;
     },
-    device(fd) {
+    heldMeta(fd) {
       return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`)).meta;
     },
     size(fd) {
@@ -3849,9 +3852,15 @@ function wireKernelFd(Fs, streams, entry) {
 }
 function openDevice(Fs, fd, meta) {
   const flags = meta.access === "read" ? O_RDONLY : meta.access === "write" ? O_WRONLY3 : O_RDWR3;
+  return openAt(Fs, fd, `/dev/${meta.device}`, flags);
+}
+function openHeld(Fs, fd, meta) {
+  return "dir" in meta ? openAt(Fs, fd, meta.dir, O_RDONLY | O_DIRECTORY) : openDevice(Fs, fd, meta);
+}
+function openAt(Fs, fd, path, flags) {
   let stream;
   try {
-    stream = Fs.open(`/dev/${meta.device}`, flags);
+    stream = Fs.open(path, flags);
   } catch {
     return false;
   }
@@ -3866,8 +3875,8 @@ function wireKernelStdio(Fs, streams, sys) {
     const stream = Fs.getStream(fd);
     if (!stream) continue;
     const kind = sys?.kind?.(fd);
-    const device2 = kind === "device" ? sys?.device?.(fd) : void 0;
-    if (device2 && openDevice(Fs, fd, device2)) continue;
+    const meta = kind === "device" || kind === "held" ? sys?.heldMeta?.(fd) : void 0;
+    if (meta && openHeld(Fs, fd, meta)) continue;
     if (kind && PLACED.has(kind)) {
       const { flags } = stream;
       Fs.closeStream(fd);
@@ -4119,7 +4128,7 @@ function runMain(running, init) {
     return status2;
   }
 }
-var FS_OPS, O_RDONLY, O_WRONLY3, O_RDWR3, PLACED, GLUE_TRAILER, evaluateGlue, EVAL_BLOCKED;
+var FS_OPS, O_RDONLY, O_WRONLY3, O_RDWR3, O_DIRECTORY, PLACED, GLUE_TRAILER, evaluateGlue, EVAL_BLOCKED;
 var init_process_runtime = __esm({
   "src/process/process-runtime.ts"() {
     "use strict";
@@ -4144,6 +4153,7 @@ var init_process_runtime = __esm({
     O_RDONLY = 0;
     O_WRONLY3 = 1;
     O_RDWR3 = 2;
+    O_DIRECTORY = 65536;
     PLACED = /* @__PURE__ */ new Set(["stream", "file", "socket"]);
     GLUE_TRAILER = [
       "if (typeof ENV !== 'undefined') Object.assign(ENV, Module.sliccEnv);",
@@ -4507,10 +4517,10 @@ var init_wasi_files = __esm({
       readable;
       writable;
       append;
-      constructor(buffer, readable, writable, append) {
+      constructor(buffer, readable2, writable2, append) {
         this.buffer = buffer;
-        this.readable = readable;
-        this.writable = writable;
+        this.readable = readable2;
+        this.writable = writable2;
         this.append = append;
       }
       get path() {
@@ -4592,9 +4602,9 @@ function entryOf(info) {
 function openAccess(existing, oflags, rights) {
   const readonly = existing?.readonly === true;
   const mutating = readonly ? OFLAGS.TRUNC : OFLAGS.CREAT | OFLAGS.TRUNC;
-  const writable = (rights & RIGHTS.FD_WRITE) !== 0n || (oflags & mutating) !== 0;
-  if (writable && readonly) throw new WasiError("EROFS");
-  return { readable: (rights & RIGHTS.FD_READ) !== 0n || !writable, writable };
+  const writable2 = (rights & RIGHTS.FD_WRITE) !== 0n || (oflags & mutating) !== 0;
+  if (writable2 && readonly) throw new WasiError("EROFS");
+  return { readable: (rights & RIGHTS.FD_READ) !== 0n || !writable2, writable: writable2 };
 }
 function promoteRequest(fd, f, handed) {
   const orphan = f.buffer.isOrphan();
@@ -4640,7 +4650,7 @@ var init_wasi_fds = __esm({
         this.fs = fs;
       }
       setup(cwd, inherited, root = false) {
-        for (const fd of [0, 1, 2]) this.table.set(fd, kernelEntry2());
+        for (const fd of [0, 1, 2]) this.table.set(fd, this.stdioEntry(fd));
         const preopens = this.preopens(cwd, root);
         const top = 3 + preopens.length;
         for (const { fd, kind, flags, device: device2 } of inherited) {
@@ -4727,6 +4737,15 @@ var init_wasi_fds = __esm({
         const gen = Atomics.add(this.shared, GEN, 1) + 1;
         if (gen - 1 === this.seen) this.seen = gen;
       }
+      stdioEntry(fd) {
+        let info;
+        try {
+          info = this.kernel.call({ op: "fd-info", fd });
+        } catch {
+          return kernelEntry2();
+        }
+        return info?.meta && "dir" in info.meta ? { type: "dir", path: info.meta.dir } : kernelEntry2();
+      }
       fetch(fd) {
         let info;
         try {
@@ -5016,13 +5035,17 @@ var init_wasi_fds = __esm({
         if (oflags & OFLAGS.DIRECTORY && !s?.isDirectory) {
           throw new WasiError(s ? "ENOTDIR" : "ENOENT");
         }
-        if (s?.isDirectory) return this.install({ type: "dir", path });
+        if (s?.isDirectory) {
+          const asked = (oflags & OFLAGS.DIRECTORY) === 0 && (rights & RIGHTS.FD_WRITE) !== 0n;
+          if (asked || (oflags & (OFLAGS.CREAT | OFLAGS.TRUNC)) !== 0) throw new WasiError("EISDIR");
+          return this.install({ type: "dir", path });
+        }
         if (!s && !(oflags & OFLAGS.CREAT)) throw new WasiError("ENOENT");
         if (this.shared) return this.kernelFile(path, s, oflags, rights, fdflags);
         return this.install({ type: "file", file: this.file(path, s, oflags, rights, fdflags) });
       }
       file(path, existing, oflags, rights, fdflags) {
-        const { readable, writable } = openAccess(existing, oflags, rights);
+        const { readable: readable2, writable: writable2 } = openAccess(existing, oflags, rights);
         let buffer = this.buffers.get(path);
         if (buffer) {
           if (oflags & OFLAGS.TRUNC) buffer.truncate(0);
@@ -5037,12 +5060,12 @@ var init_wasi_fds = __esm({
           this.fs.hold?.(path, true, true);
         }
         buffer.opens++;
-        return new LocalFile(buffer, readable, writable, (fdflags & FDFLAGS.APPEND) !== 0);
+        return new LocalFile(buffer, readable2, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
       }
       kernelFile(path, existing, oflags, rights, fdflags) {
-        const { readable, writable } = openAccess(existing, oflags, rights);
+        const { readable: readable2, writable: writable2 } = openAccess(existing, oflags, rights);
         const append = (fdflags & FDFLAGS.APPEND) !== 0;
-        const flags = (writable ? readable ? O_RDWR4 : O_WRONLY4 : 0) | (append ? O_APPEND : 0);
+        const flags = (writable2 ? readable2 ? O_RDWR4 : O_WRONLY4 : 0) | (append ? O_APPEND : 0);
         const made = !existing && this.createNew(path, oflags);
         const truncate = made || (oflags & OFLAGS.TRUNC) !== 0;
         const fd = this.kernel.sys.openVfs(path, flags, 0, truncate ? { truncate } : {});
@@ -6824,8 +6847,8 @@ var init_wasix_process = __esm({
         ];
         return { stdio, inherit, cwd, opened };
       }
-      applyFdOp(op, slots, cwd) {
-        const { map, nulls, opened } = slots;
+      applyFdOp(op, slots2, cwd) {
+        const { map, nulls, opened } = slots2;
         const { fds } = this.host;
         const point = (fd, kfd) => {
           if (kfd === void 0) {
@@ -8188,6 +8211,17 @@ var init_async_sab = __esm({
 });
 
 // src/process/js/js-kernel.ts
+function untilAborted(work, signal) {
+  if (!signal) return work;
+  return new Promise((resolve) => {
+    const done = () => {
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    signal.addEventListener("abort", done, { once: true });
+    work.then(done, done);
+  });
+}
 var JsCallError, JsKernel;
 var init_js_kernel = __esm({
   "src/process/js/js-kernel.ts"() {
@@ -8239,20 +8273,24 @@ var init_js_kernel = __esm({
         const result = await this.call(req);
         return result.ok && result.kind === "bytes" ? result.bytes : new Uint8Array(0);
       }
-      async blocking(req) {
+      async blocking(req, signal) {
         for (; ; ) {
           const id = await this.json({ op: "async-submit", req });
-          const result = await this.settled(id);
+          const result = await this.settled(id, signal);
           if (result.ok) return result;
           if (result.errno !== "EINTR") throw new JsCallError(result.errno, req.op);
         }
       }
-      async settled(id) {
+      async settled(id, signal) {
         for (; ; ) {
           const seen = Atomics.load(this.header, SAB_I_ASYNC);
           const taken = await this.raw({ op: "async-take", id });
           if (taken.ok || taken.errno !== "EAGAIN") return taken;
-          await changed(this.header, SAB_I_ASYNC, seen, this.waitAsync);
+          if (signal?.aborted) {
+            await this.raw({ op: "async-cancel", id });
+            throw signal.reason;
+          }
+          await untilAborted(changed(this.header, SAB_I_ASYNC, seen, this.waitAsync), signal);
         }
       }
       deliver() {
@@ -8325,6 +8363,125 @@ var init_js_kernel = __esm({
   }
 });
 
+// src/process/js/js-children.ts
+function exitedOf(status2) {
+  const signal = status2 & 127;
+  return signal ? { status: 128 + signal, signal } : { status: status2 >> 8 & 255 };
+}
+function readable(io, fd) {
+  const cancelled = new AbortController();
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        const chunk = await io.read(fd, void 0, cancelled.signal).catch((err) => {
+          if (cancelled.signal.aborted) return void 0;
+          throw err;
+        });
+        if (chunk === void 0) return;
+        if (chunk.length > 0) {
+          controller.enqueue(chunk);
+          return;
+        }
+        controller.close();
+        await io.close(fd);
+      },
+      cancel: () => {
+        cancelled.abort();
+        return io.close(fd);
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+function writable(io, fd) {
+  return new WritableStream({
+    write: (chunk, controller) => io.send(fd, chunk, controller.signal),
+    close: () => io.close(fd),
+    abort: () => io.close(fd)
+  });
+}
+function childOps(kernel, io, defaults) {
+  const wait = async (pid) => {
+    const r = await kernel.blocking({ op: "proc-wait", pid, nohang: false });
+    const [, status2] = r.ok && r.kind === "json" ? r.json : [0, 0];
+    return exitedOf(status2);
+  };
+  const kill = async (pid, signal = SIGTERM) => {
+    await kernel.call({ op: "proc-kill", pid, sig: signal === 0 ? 0 : defaults.signal(signal) });
+  };
+  const childOf = (pid, mine) => {
+    const [stdin, stdout, stderr] = mine;
+    return {
+      pid,
+      ...stdin !== void 0 ? { stdin: writable(io, stdin) } : {},
+      ...stdout !== void 0 ? { stdout: readable(io, stdout) } : {},
+      ...stderr !== void 0 ? { stderr: readable(io, stderr) } : {},
+      wait: () => wait(pid),
+      kill: (signal) => kill(pid, signal)
+    };
+  };
+  const spawn = async (o) => {
+    const [file] = o.argv;
+    if (file === void 0) throw new JsCallError("EINVAL", "spawn");
+    const mine = [];
+    const theirs = [];
+    try {
+      const stdio = await slots(kernel, o, mine, theirs);
+      const pid = await kernel.json({
+        op: "proc-spawn",
+        file,
+        argv: [...o.argv],
+        env: { ...o.env ?? defaults.env },
+        cwd: o.cwd ?? defaults.cwd,
+        stdio
+      });
+      return childOf(pid, mine);
+    } catch (err) {
+      await closeAll(io, mine);
+      throw err;
+    } finally {
+      await closeAll(io, theirs);
+    }
+  };
+  return { spawn, wait, kill };
+}
+async function closeAll(io, fds) {
+  for (const fd of fds) if (fd !== void 0) await io.close(fd).catch(() => void 0);
+}
+async function preflight(kernel, hows) {
+  for (const [n, how] of hows.entries()) {
+    if (how === "pipe" || how === "null") continue;
+    if (how !== "inherit" && typeof how !== "number") throw new JsCallError("EINVAL", "spawn");
+    await kernel.json({ op: "fd-info", fd: how === "inherit" ? n : how });
+  }
+}
+async function slots(kernel, o, mine, theirs) {
+  const hows = STDIO2.map((name) => o[name] ?? "inherit");
+  await preflight(kernel, hows);
+  const stdio = [];
+  for (const [n, how] of hows.entries()) {
+    if (how === "inherit") stdio.push({ fd: n });
+    else if (how === "null") stdio.push({ none: true });
+    else if (typeof how === "number") stdio.push({ fd: how });
+    else {
+      const [read, write] = await kernel.json({ op: "fd-pipe" });
+      mine[n] = n === 0 ? write : read;
+      theirs.push(n === 0 ? read : write);
+      stdio.push({ fd: n === 0 ? read : write });
+    }
+  }
+  return stdio;
+}
+var STDIO2, SIGTERM;
+var init_js_children = __esm({
+  "src/process/js/js-children.ts"() {
+    "use strict";
+    init_js_kernel();
+    STDIO2 = ["stdin", "stdout", "stderr"];
+    SIGTERM = 15;
+  }
+});
+
 // src/process/js/js-io.ts
 function typeOf(info) {
   if (info.meta && "dir" in info.meta) return "directory";
@@ -8689,22 +8846,20 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const read = async (fd, max = CHUNK) => {
+  const read = async (fd, max = CHUNK, signal) => {
     index(max, "read");
     const emulated = readDevice(await info(fd), max, random);
     if (emulated) return emulated;
-    const r = await kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
-    return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+    return readPipe(kernel, fd, Math.min(max, MAX_IO), signal);
   };
-  const writeAll = async (fd, data) => {
+  const writeAll = async (fd, data, signal) => {
     const i = await info(fd);
     if (writeDevice(i)) return;
     let at = 0;
     while (at < data.length) {
       const body = data.subarray(at, at + MAX_IO);
       try {
-        const r = await kernel.blocking({ op: "fd-write", fd, body });
-        at += written(r, body.length);
+        at += signal ? await sendSome(kernel, fd, body, signal) : written(await kernel.blocking({ op: "fd-write", fd, body }), body.length);
       } catch (err) {
         if (brokenPipe(err, i)) await kernel.call({ op: "proc-kill", pid: o.pid, sig: SIG.PIPE });
         throw err;
@@ -8725,7 +8880,7 @@ function createContext(o) {
       }
     })();
   };
-  const writable = (fd) => new WritableStream({ write: (chunk) => write(fd, chunk) });
+  const writable2 = (fd) => new WritableStream({ write: (chunk) => write(fd, chunk) });
   const statOf = async (op, path) => {
     const abs = resolve(path);
     await kernel.call({ op: "fd-path-flush", path: abs });
@@ -8760,6 +8915,11 @@ function createContext(o) {
     infos,
     handles
   });
+  const children = childOps(
+    kernel,
+    { read, send: writeAll, close: (fd) => ctx.close(fd) },
+    { env: o.env, cwd: o.cwd, signal: signalNumber }
+  );
   const ctx = {
     argv: o.argv,
     env: o.env,
@@ -8778,8 +8938,8 @@ function createContext(o) {
       },
       { highWaterMark: 0 }
     ),
-    stdout: writable(1),
-    stderr: writable(2),
+    stdout: writable2(1),
+    stderr: writable2(2),
     read,
     write,
     async close(fd) {
@@ -8802,6 +8962,7 @@ function createContext(o) {
       reset: async (signal) => kernel.setHandler(signalNumber(signal), "default")
     },
     sync,
+    ...children,
     exit
   };
   const drain2 = async () => {
@@ -8878,6 +9039,29 @@ function fileHandle(kernel, fd, path, append, forget) {
     }
   };
 }
+async function readPipe(kernel, fd, max, signal) {
+  if (signal) return receiveSome(kernel, fd, max, signal);
+  const r = await kernel.blocking({ op: "fd-read", fd, max });
+  return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+}
+async function receiveSome(kernel, fd, max, signal) {
+  for (; ; ) {
+    signal.throwIfAborted();
+    const r = await kernel.raw({ op: "fd-read", fd, max, nonblock: true });
+    if (r.ok) return r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+    if (r.errno !== "EAGAIN") throw new JsCallError(r.errno, "fd-read");
+    await kernel.blocking({ op: "fd-select", read: [fd], write: [], timeoutMs: -1 }, signal);
+  }
+}
+async function sendSome(kernel, fd, body, signal) {
+  for (; ; ) {
+    signal.throwIfAborted();
+    const r = await kernel.raw({ op: "fd-write", fd, body, nonblock: true });
+    if (r.ok) return written(r, body.length);
+    if (r.errno !== "EAGAIN") throw new JsCallError(r.errno, "fd-write");
+    await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
+  }
+}
 function pathOps(kernel, resolve, statOf, open) {
   return {
     stat: (path) => statOf("stat", path),
@@ -8911,6 +9095,7 @@ var init_js_context = __esm({
     "use strict";
     init_signals();
     init_sync_fs_wire();
+    init_js_children();
     init_js_io();
     init_js_kernel();
     init_js_sync();