@ai-ecoverse/slicc-kernel 1.64.1 → 1.65.0

package/dist/node.js

@@ -5264,6 +5264,23 @@ var CONTINUED_STATUS = 65535;
 function waitStatus(code, termsig) {
   return termsig ? termsig & 127 : (code & 255) << 8;
 }
+function capturing(chunks2, max = Number.POSITIVE_INFINITY, overflow) {
+  let size = 0;
+  let over = false;
+  return (bytes) => {
+    if (over) return;
+    const room = max - size;
+    if (bytes.length > room) {
+      over = true;
+      if (room > 0) chunks2.push(bytes.slice(0, room));
+      size = max;
+      overflow?.();
+      return;
+    }
+    chunks2.push(bytes);
+    size += bytes.length;
+  };
+}
 function concat2(chunks2) {
   const out = new Uint8Array(chunks2.reduce((n, c) => n + c.length, 0));
   let offset = 0;
@@ -5297,15 +5314,15 @@ var ChildTable = class {
     const fds = new FdTable();
     const captured = /* @__PURE__ */ new Map();
     try {
-      for (const [n, slot] of stdio.entries()) fds.installAt(n, this.openSlot(slot, n, captured));
-      for (const slot of inherit2) {
-        if (slot.fd <= 2) continue;
-        if ("device" in slot) {
-          fds.installAt(slot.fd, deviceFile(slot.device, slot.access));
+      for (const [n, slot2] of stdio.entries()) fds.installAt(n, this.openSlot(slot2, n, captured));
+      for (const slot2 of inherit2) {
+        if (slot2.fd <= 2) continue;
+        if ("device" in slot2) {
+          fds.installAt(slot2.fd, deviceFile(slot2.device, slot2.access));
           continue;
         }
-        fds.installAt(slot.fd, this.parentFds.get(slot.kernel).retain());
-        if (slot.flags !== void 0) fds.setStatusFlags(slot.fd, slot.flags);
+        fds.installAt(slot2.fd, this.parentFds.get(slot2.kernel).retain());
+        if (slot2.flags !== void 0) fds.setStatusFlags(slot2.fd, slot2.flags);
       }
     } catch (e) {
       await fds.closeAll();
@@ -5346,15 +5363,15 @@ var ChildTable = class {
     this.watchers.set(pid, listener);
     if (child.stoppedBy !== void 0) listener("stopped", child.stoppedBy);
   }
-  openSlot(slot, n, captured) {
-    if ("fd" in slot) return this.parentFds.get(slot.fd).retain();
-    if ("input" in slot) return bytesSource(slot.input);
-    if ("device" in slot) return deviceFile(slot.device, slot.access);
-    if ("dir" in slot) return heldFile({ dir: slot.dir });
-    if ("capture" in slot) {
+  openSlot(slot2, n, captured) {
+    if ("fd" in slot2) return this.parentFds.get(slot2.fd).retain();
+    if ("input" in slot2) return bytesSource(slot2.input);
+    if ("device" in slot2) return deviceFile(slot2.device, slot2.access);
+    if ("dir" in slot2) return heldFile({ dir: slot2.dir });
+    if ("capture" in slot2) {
       const chunks2 = [];
       captured.set(n, chunks2);
-      return sinkFile((bytes) => chunks2.push(bytes));
+      return sinkFile(capturing(chunks2, slot2.max, slot2.overflow));
     }
     return deviceFile("null");
   }
@@ -5421,11 +5438,11 @@ var ChildTable = class {
   pids() {
     return [...this.children.keys()];
   }
-  captured(pid, slot) {
+  captured(pid, slot2) {
     const slots = this.leftovers.get(pid);
-    const chunks2 = slots?.get(slot);
+    const chunks2 = slots?.get(slot2);
     if (!slots || !chunks2) return new Uint8Array(0);
-    slots.delete(slot);
+    slots.delete(slot2);
     if (slots.size === 0) this.leftovers.delete(pid);
     return concat2(chunks2);
   }
@@ -7305,8 +7322,10 @@ var EARLY_WHOLE_FILE = 64 * 1024;
 
 // src/process/process-fds.ts
 var field2 = (text) => (text || "none").replace(/[\s\\]/g, (c) => `\\${c.charCodeAt(0).toString(8).padStart(3, "0")}`);
+var pinnedRoot;
+var rootKind = () => globalThis.navigator?.storage ? "opfs" : "memory";
 function mountTable(mounts = []) {
-  const root = globalThis.navigator?.storage ? "opfs" : "memory";
+  const root = pinnedRoot ?? rootKind();
   const lines2 = [`${root} / ${root} rw 0 0`, "devfs /dev devfs rw 0 0", "proc /proc proc rw 0 0"];
   for (const m of mounts) {
     const options = Object.entries(m.options).map(([k, v]) => v === "" ? k : `${k}=${v}`);
@@ -7684,6 +7703,7 @@ var HOST_OPS = [
   "async-resolve",
   "async-hold",
   "async-cancel",
+  "async-settle",
   "async-close"
 ];
 var json3 = (value) => ({ ok: true, kind: "json", json: value });
@@ -7715,12 +7735,16 @@ var LockTable = class {
     for (const path of [...this.held.keys()]) this.unlock(pid, path);
   }
 };
+var KEPT_OPS = /* @__PURE__ */ new Set(["fd-write"]);
+var unknownSettled = false;
 var AsyncOps = class {
   next = 1;
   results = /* @__PURE__ */ new Map();
   ready = [];
   running = /* @__PURE__ */ new Map();
   waiters = /* @__PURE__ */ new Set();
+  taken = /* @__PURE__ */ new Map();
+  kept = /* @__PURE__ */ new Set();
   closed = false;
   run;
   onReady;
@@ -7730,6 +7754,7 @@ var AsyncOps = class {
   }
   submit(req) {
     const id2 = this.hold();
+    if (KEPT_OPS.has(req.op)) this.kept.add(id2);
     const running = new AbortController();
     this.running.set(id2, running);
     this.run(req, running.signal).then(
@@ -7753,9 +7778,26 @@ var AsyncOps = class {
     const result = this.results.get(id2);
     if (!result) throw new KernelError("EAGAIN");
     this.forget(id2);
+    if (this.kept.delete(id2)) this.taken.set(id2, result);
     return result;
   }
+  ack(ids) {
+    for (const id2 of ids) this.taken.delete(id2);
+  }
+  async settle(ids) {
+    const never = new AbortController().signal;
+    while (ids.some((id2) => this.running.has(id2))) await this.sleep(void 0, never);
+    return ids.map((id2) => {
+      const result = this.results.get(id2) ?? this.taken.get(id2) ?? null;
+      if (!result && !unknownSettled) {
+        unknownSettled = true;
+        console.warn(`async-settle: no result for op ${id2}; its write counts as made`);
+      }
+      return result;
+    });
+  }
   cancel(id2) {
+    this.kept.delete(id2);
     this.running.get(id2)?.abort();
     this.forget(id2);
   }
@@ -7831,6 +7873,7 @@ async function hostSyscall(req, ctx) {
       return done2;
     case "async-submit":
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
+      if (req.ack) ctx.ops.ack(req.ack);
       return json3(ctx.ops.submit(req.req));
     case "async-wait":
       return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking));
@@ -7843,6 +7886,8 @@ async function hostSyscall(req, ctx) {
     case "async-cancel":
       ctx.ops.cancel(req.id);
       return done2;
+    case "async-settle":
+      return json3(await ctx.ops.settle(req.ids));
     case "async-close":
       ctx.ops.close();
       return done2;
@@ -9671,8 +9716,8 @@ var KernelTty = class {
   get canonical() {
     return (this.termios.c_lflag & ICANON) !== 0;
   }
-  cc(slot) {
-    return this.termios.c_cc[slot] ?? 0;
+  cc(slot2) {
+    return this.termios.c_cc[slot2] ?? 0;
   }
   key(input) {
     const { c_iflag, c_lflag } = this.termios;
@@ -10027,6 +10072,84 @@ function ptySyscall(req, ctx) {
   }
 }
 
+// src/kernel/run-child.ts
+var RUN_CAPTURE_CAP = 64 * 1024 * 1024;
+var RUN_MAX_BUFFER = 1024 * 1024;
+function capLimit(maxBuffer) {
+  const asked = maxBuffer === void 0 ? RUN_MAX_BUFFER : maxBuffer;
+  return Math.max(0, Math.min(asked, RUN_CAPTURE_CAP));
+}
+function slot(how, n, extra) {
+  if (how === "inherit") return { fd: n };
+  if (how === "ignore") return { none: true };
+  return extra;
+}
+function frame2(outcome, out, err) {
+  const head = new TextEncoder().encode(JSON.stringify(outcome));
+  const bytes = new Uint8Array(4 + head.length + out.length + err.length);
+  new DataView(bytes.buffer).setUint32(0, head.length, true);
+  bytes.set(head, 4);
+  bytes.set(out, 4 + head.length);
+  bytes.set(err, 4 + head.length + out.length);
+  return bytes;
+}
+async function reaped(deps, pid) {
+  for (; ; ) {
+    try {
+      return (await deps.children.wait(pid, false, deps.interrupt()))[1];
+    } catch (e) {
+      if (!(e instanceof KernelError && e.code === "EINTR") || deps.dying()) throw e;
+    }
+  }
+}
+async function runChild(req, deps) {
+  const max = capLimit(req.maxBuffer);
+  let failure;
+  let pid = 0;
+  const kill = () => void Promise.allSettled([deps.kill(pid, req.killSignal)]);
+  const stop = (code) => {
+    if (failure !== void 0) return;
+    failure = code;
+    if (pid !== 0) kill();
+  };
+  const capture = () => ({ capture: true, max, overflow: () => stop("ENOBUFS") });
+  const stdio = [
+    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(
+      { file: req.file, argv: req.argv, env: req.env, cwd: req.cwd },
+      stdio
+    );
+  } catch (e) {
+    if (!(e instanceof SpawnError)) throw e;
+    const outcome2 = { pid: 0, status: null, error: { code: e.code }, out: 0, err: 0 };
+    return frame2(outcome2, new Uint8Array(0), new Uint8Array(0));
+  }
+  if (failure !== void 0) kill();
+  const timer = req.timeoutMs !== void 0 && req.timeoutMs > 0 ? setTimeout(() => stop("ETIMEDOUT"), req.timeoutMs) : void 0;
+  let status;
+  try {
+    status = await reaped(deps, pid);
+  } finally {
+    clearTimeout(timer);
+  }
+  const out = deps.children.captured(pid, 1);
+  const err = deps.children.captured(pid, 2);
+  const termsig = status & 127;
+  const outcome = {
+    pid,
+    status: termsig ? null : status >> 8 & 255,
+    ...termsig ? { signal: termsig } : {},
+    ...failure !== void 0 ? { error: { code: failure } } : {},
+    out: out.length,
+    err: err.length
+  };
+  return frame2(outcome, out, err);
+}
+
 // src/kernel/select.ts
 function ready(fds, read, write) {
   const hangup = /* @__PURE__ */ new Set();
@@ -10823,6 +10946,8 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-spawn",
   "proc-wait",
   "proc-captured",
+  "proc-run",
+  "proc-exit",
   "proc-fork",
   "proc-kill",
   "thread-kill",
@@ -10943,6 +11068,14 @@ var WasmProcess = class {
     else this.adoptExec(pid);
     return pid;
   }
+  run(req) {
+    return runChild(req, {
+      children: this.children,
+      kill: (pid, sig) => this.options.kill?.(pid, sig),
+      interrupt: () => this.interrupt.signal,
+      dying: () => this.dying
+    });
+  }
   adoptExec(pid) {
     this.execChild = pid;
     this.children.watch(pid, (state, sig) => state === "stopped" ? this.stop(sig) : this.cont());
@@ -11491,6 +11624,12 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: await this.spawn(req) };
       case "proc-wait":
         return { ok: true, kind: "json", json: await this.procWait(req, cancelled) };
+      case "proc-run":
+        return { ok: true, kind: "bytes", bytes: await this.run(req) };
+      case "proc-exit":
+        if (!this.options.exitNow) throw new KernelError("ENOSYS");
+        this.options.exitNow(req.status & 255);
+        return DYING;
       case "proc-identity":
         return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
@@ -11897,6 +12036,7 @@ function processOptions(opts, header4, hooks, created3) {
     hasPending: () => Atomics.load(header4, SAB_I_SIGNALS) !== 0 || Atomics.load(header4, SAB_I_TIMERS) !== 0,
     raise: hooks.raise,
     threadKill: hooks.threadKill,
+    ...hooks.exitNow ? { exitNow: hooks.exitNow } : {},
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header4, SAB_I_SIGNALS) } : {}
   };
 }
@@ -11913,7 +12053,8 @@ function spawnWasmProcess(opts) {
       header4,
       {
         raise: (sig) => signal(sig),
-        threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.signalMasks().caught, sig)
+        threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.signalMasks().caught, sig),
+        ...opts.program.abi === "js" ? { exitNow: (code) => exitNow(code) } : {}
       },
       created3
     )
@@ -11954,12 +12095,15 @@ function spawnWasmProcess(opts) {
       () => settle(code)
     );
   };
+  const exitNow = (code) => {
+    queueMicrotask(() => finish(...dying.status(code)));
+  };
   const handle = (data) => {
     if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
       if (!dying.ending) opts.onError?.(String(data.message));
-      finish(...dying.status(CRASHED));
+      finish(...dying.status(data.code));
     } else if (data?.type === WASM_THREAD_SPAWN && data.thread) {
       spawnThread(data.thread);
     }
@@ -12689,15 +12833,15 @@ function granted(handle) {
   );
 }
 function removableMedium(onLost, open = (handle) => new OpfsFs(handle)) {
-  const slot = mediumSlot(
+  const slot2 = mediumSlot(
     async (err, handle) => denied(err) && !await granted(handle),
     onLost
   );
   return {
-    handlers: slot.handlers,
-    present: slot.present,
-    insert: (handle) => slot.insert(handle, kernelFsHandlers(open(handle))),
-    eject: slot.eject
+    handlers: slot2.handlers,
+    present: slot2.present,
+    insert: (handle) => slot2.insert(handle, kernelFsHandlers(open(handle))),
+    eject: slot2.eject
   };
 }
 
@@ -13575,7 +13719,7 @@ function grantConnect(hook, fetch2, liveness = {}) {
 async function openHostfs(spec, connect, timing = {}) {
   const readonly2 = spec.options?.ro !== void 0;
   const { port1, port2 } = new MessageChannel();
-  const slot = mediumSlot(
+  const slot2 = mediumSlot(
     async (err) => unreachable(err),
     () => watching.kick()
   );
@@ -13588,7 +13732,7 @@ async function openHostfs(spec, connect, timing = {}) {
   });
   const served = serveFilesystem(
     port2,
-    { ...slot.handlers, mount: ranged2 },
+    { ...slot2.handlers, mount: ranged2 },
     {
       symlinks: true,
       chmod: true,
@@ -13602,12 +13746,12 @@ async function openHostfs(spec, connect, timing = {}) {
       connect: () => connect(spec.source, { readonly: readonly2 }),
       up(client) {
         active = timed(client, timing.callMs ?? HOSTFS_CALL_MS);
-        slot.insert(client, handlers);
+        slot2.insert(client, handlers);
         served.invalidate(true);
       },
       event: (event) => served.invalidate(invalidation(event)),
       down() {
-        slot.eject();
+        slot2.eject();
         served.invalidate(true);
       },
       ...timing
@@ -13617,7 +13761,7 @@ async function openHostfs(spec, connect, timing = {}) {
   await watching.ready;
   return {
     port: port1,
-    present: slot.present,
+    present: slot2.present,
     dispose() {
       stop.abort();
       port1.close();
@@ -14920,16 +15064,16 @@ var Launcher = class {
   }
   async insert(target, handle, source) {
     const at = normalizePath(target);
-    const slot = this.removable.get(at);
-    if (!slot) throw fsError("EINVAL", `${at} is not a removable mount`);
-    if (source !== void 0 && source !== `fsa:${slot.id}`) {
+    const slot2 = this.removable.get(at);
+    if (!slot2) throw fsError("EINVAL", `${at} is not a removable mount`);
+    if (source !== void 0 && source !== `fsa:${slot2.id}`) {
       throw fsError("EINVAL", `${at} is no longer the drive ${source}`);
     }
     if (!await granted(handle)) throw fsError("EACCES", `${at}: no permission for this folder`);
-    this.inserted.set(slot.id, handle);
-    await this.media.put(slot.id, handle);
-    slot.medium.insert(handle);
-    slot.served.invalidate(true);
+    this.inserted.set(slot2.id, handle);
+    await this.media.put(slot2.id, handle);
+    slot2.medium.insert(handle);
+    slot2.served.invalidate(true);
     void this.unlinked.sweep(at);
   }
   umount(target, detach = false) {