@ai-ecoverse/slicc-kernel 1.69.0 → 1.70.0

package/README.md

@@ -254,7 +254,7 @@ The module's default export (or its `main` export) is called with a context and
 - `signals`: `on(signal, handler)` catches a signal (by number or as `'SIGINT'`), `ignore(signal)` ignores it and `reset(signal)` restores its default action. A call blocked in a read or write is restarted after a handler runs; signals without a handler keep their default actions, so an uncaught `SIGINT` ends the program with 130 and `SIGKILL` always does;
 - `sync`: `read`, `write`, `close`, `open` (whose files' methods are synchronous too) and `fs`, made synchronously, for code that cannot `await`, such as a compiled program's file system or a `readFileSync`. A synchronous call holds the worker until the kernel answers, so nothing else of the program runs meanwhile, timers and callbacks included; a signal that arrives during a blocked read or write runs its handler, and the call is then restarted. Descriptors are shared with the rest of the context, so a file opened with `sync.open` can be closed with `close`, and the other way around; `sync.run` and `sync.exit` are described next;
 - `sync.run({ argv, env, cwd, input, stdin, stdout, stderr, maxBuffer, timeout, killSignal })` runs a command to its end and answers `{ pid, status, signal, stdout, stderr, error }`, as Node's `spawnSync` does. It suits `execSync`, `spawnSync` and `execFileSync`. The kernel does the whole run while the program's worker waits; other processes go on.
-  - Each stdio is `'pipe'` (the default), `'ignore'` or `'inherit'` (the program's own, a terminal included). With `'pipe'`, stdin gets `input` (bytes, or a string as UTF-8) and then its end, so `cat` stops; `stdout` and `stderr` come back as bytes and are absent for the other choices. Both are drained while the child runs, so a child that writes more than a pipe holds never stalls.
+  - Each stdio is `'pipe'` (the default), `'ignore'`, `'inherit'` (the program's own, a terminal included), or one of the program's descriptors by number, which the child gets as it is (two slots on one descriptor share it, so their writes keep their order). `stderr: 'stdout'` sends stderr to whatever stdout is, the stdout capture included, in the order the child writes. With `'pipe'`, stdin gets `input` (bytes, or a string as UTF-8) and then its end, so `cat` stops; `stdout` and `stderr` come back as bytes and are absent for the other choices. Both are drained while the child runs, so a child that writes more than a pipe holds never stalls. As in Node, the call returns once the child has exited and every captured stream has reached its end, so output a background grandchild writes later is still collected; `timeout` bounds that wait too. Once the outcome is decided (the end of output, an overflow or a timeout), the captured streams are closed, so a writer still left on them gets `EPIPE` (and `SIGPIPE`) instead of running on.
   - `status` is the exit status, or `null` with `signal` set when a signal ended the child. A non-zero status is not an error. A command that cannot start (it does not exist, or is not executable) answers `error: { code: 'ENOENT' }` (or the errno), `status: null` and `pid: 0` instead of throwing.
   - More than `maxBuffer` bytes on `stdout` or `stderr` (1 MiB by default) sends the child `killSignal` (`SIGTERM` by default), keeps the first `maxBuffer` bytes, and answers `error: { code: 'ENOBUFS' }`. The kernel keeps at most 64 MiB of each stream whatever `maxBuffer` says, `Infinity` included, since the buffers live in the kernel worker that all processes share. `timeout` (ms) sends `killSignal` when it runs out and answers `error: { code: 'ETIMEDOUT' }`. A child that ignores `killSignal` is still waited for, as in Node.
   - The child is in the program's process group, so `^C` reaches it. The kernel reaps it, so it leaves no zombie, and its CPU time counts as the program's children's. A signal the program catches does not cut the run short; its handler runs when the call returns. A signal that kills the program kills it as usual;

package/dist/kernel-worker.js

@@ -6960,6 +6960,18 @@ function capturing(chunks, max = Number.POSITIVE_INFINITY, overflow) {
     size += bytes.length;
   };
 }
+function captureFile(onData, control) {
+  if (!control) return sinkFile(onData);
+  control.opened = true;
+  return new OpenFile({
+    write: async (bytes) => {
+      if (control.shut) throw new KernelError("EPIPE");
+      onData(bytes.slice());
+      return bytes.length;
+    },
+    close: () => control.ended()
+  });
+}
 function concat3(chunks) {
   const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
   let offset = 0;
@@ -6994,7 +7006,12 @@ var ChildTable = class {
     const fds = new FdTable();
     const captured = /* @__PURE__ */ new Map();
     try {
-      for (const [n, slot2] of stdio.entries()) fds.installAt(n, this.openSlot(slot2, n, captured));
+      for (const [n, slot2] of stdio.entries()) {
+        fds.installAt(
+          n,
+          "sameAs" in slot2 ? fds.get(slot2.sameAs).retain() : this.openSlot(slot2, n, captured)
+        );
+      }
       for (const slot2 of inherit2) {
         if (slot2.fd <= 2) continue;
         if ("device" in slot2) {
@@ -7051,7 +7068,7 @@ var ChildTable = class {
     if ("capture" in slot2) {
       const chunks = [];
       captured.set(n, chunks);
-      return sinkFile(capturing(chunks, slot2.max, slot2.overflow));
+      return captureFile(capturing(chunks, slot2.max, slot2.overflow), slot2.control);
     }
     return deviceFile("null");
   }
@@ -10558,9 +10575,11 @@ function capLimit(maxBuffer) {
   return Math.min(asked, RUN_CAPTURE_CAP);
 }
 function slot(how, n, extra) {
+  if (how === "stdout") return { sameAs: 1 };
+  if (typeof how === "number") return { fd: how };
   if (how === "inherit") return { fd: n };
   if (how === "ignore") return { none: true };
-  return extra;
+  return extra();
 }
 function frame2(outcome, out, err) {
   const head = new TextEncoder().encode(JSON.stringify(outcome));
@@ -10590,12 +10609,20 @@ async function runChild(req, deps) {
     if (failure2 !== void 0) return;
     failure2 = code;
     if (pid !== 0) kill();
+    decided.resolve();
+  };
+  const controls = [];
+  const capture = () => {
+    const { promise, resolve } = Promise.withResolvers();
+    const control = { shut: false, ended: resolve, eof: promise };
+    controls.push(control);
+    return { capture: true, max, overflow: () => stop("ENOBUFS"), control };
   };
-  const capture = () => ({ capture: true, max, overflow: () => stop("ENOBUFS") });
+  const decided = Promise.withResolvers();
   const stdio = [
-    slot(req.stdin, 0, { input: req.input ?? new Uint8Array(0) }),
-    slot(req.stdout, 1, capture()),
-    slot(req.stderr, 2, capture())
+    slot(req.stdin, 0, () => ({ input: req.input ?? new Uint8Array(0) })),
+    slot(req.stdout, 1, capture),
+    slot(req.stderr, 2, capture)
   ];
   try {
     pid = await deps.children.spawn(
@@ -10612,8 +10639,11 @@ async function runChild(req, deps) {
   let status;
   try {
     status = await reaped(deps, pid);
+    const open = controls.filter((c) => c.opened);
+    await Promise.race([Promise.all(open.map((c) => c.eof)), decided.promise]);
   } finally {
     clearTimeout(timer);
+    for (const control of controls) control.shut = true;
   }
   const out = deps.children.captured(pid, 1);
   const err = deps.children.captured(pid, 2);