@ai-ecoverse/slicc-kernel 1.39.3 → 1.40.0

package/dist/node-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);
@@ -4517,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() {
@@ -4602,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();
@@ -5041,7 +5041,7 @@ var init_wasi_fds = __esm({
         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);
@@ -5056,12 +5056,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 } : {});
@@ -6843,8 +6843,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) {
@@ -8207,6 +8207,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"() {
@@ -8258,20 +8269,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() {
@@ -8344,6 +8359,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";
@@ -8708,22 +8842,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;
@@ -8744,7 +8876,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 });
@@ -8779,6 +8911,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,
@@ -8797,8 +8934,8 @@ function createContext(o) {
       },
       { highWaterMark: 0 }
     ),
-    stdout: writable(1),
-    stderr: writable(2),
+    stdout: writable2(1),
+    stderr: writable2(2),
     read,
     write,
     async close(fd) {
@@ -8821,6 +8958,7 @@ function createContext(o) {
       reset: async (signal) => kernel.setHandler(signalNumber(signal), "default")
     },
     sync,
+    ...children,
     exit
   };
   const drain2 = async () => {
@@ -8897,6 +9035,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),
@@ -8930,6 +9091,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();