@ai-ecoverse/slicc-kernel 1.125.11 → 1.126.0

package/dist/node-process-worker.js

@@ -6392,7 +6392,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.125.11" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.126.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7269,7 +7269,8 @@ function sessionOf(r) {
   }
   return Object.freeze({
     path: "kernel",
-    substitutes: false,
+    substitutes: r.substitutes === true,
+    verified: r.verified === true,
     protocol: r.protocol ?? "TLSv1.2",
     alpnProtocol: r.alpnProtocol,
     authorized: r.authorized === true,
@@ -11226,20 +11227,24 @@ function syncOps(kernel, shared) {
     const r = kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
     return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
   };
-  const write2 = (fd, data) => {
+  const write2 = (fd, data, options) => {
     const bytes = typeof data === "string" ? encoder3.encode(data) : data;
     const i = info(fd);
-    if (writeDevice(i)) return;
+    if (writeDevice(i)) return bytes.length;
+    const nonblock = options?.nonblock === true;
     let at = 0;
     while (at < bytes.length) {
       const body = bytes.subarray(at, at + MAX_IO);
       try {
-        at += written(kernel.blocking({ op: "fd-write", fd, body }), body.length);
+        const req = { op: "fd-write", fd, body, ...nonblock ? { nonblock } : {} };
+        at += written(kernel.blocking(req), body.length);
       } catch (err) {
         if (brokenPipe(err, i)) kernel.call({ op: "proc-kill", pid: shared.pid, sig: SIG.PIPE });
         throw err;
       }
+      if (nonblock) break;
     }
+    return at;
   };
   const statOf = (op, path) => {
     const abs = resolve(path);
@@ -11530,7 +11535,7 @@ function rawOf(termios) {
   raw.c_cc[VTIME] = 0;
   return raw;
 }
-function ttyOps(kernel) {
+function ttyOps(kernel, syncKernel) {
   const saved = /* @__PURE__ */ new Map();
   const terminalOf = async (fd) => (await kernel.json({ op: "fd-info", fd })).terminal ?? `fd ${fd}`;
   const getAttr = async (fd) => await kernel.json({ op: "tty-get", fd });
@@ -11582,8 +11587,27 @@ function ttyOps(kernel) {
       await back.catch(() => void 0);
     }
   };
+  const syncGet = (fd) => syncKernel.json({ op: "tty-get", fd });
+  const syncSet = (fd, termios) => void syncKernel.json({ op: "tty-set", fd, termios: copy(termios) });
+  const syncTty = {
+    getAttr: syncGet,
+    setAttr: syncSet,
+    setRaw(fd, raw) {
+      const info = syncKernel.json({ op: "fd-info", fd });
+      const terminal = info.terminal ?? `fd ${fd}`;
+      if (!raw) {
+        const original = saved.get(terminal);
+        saved.delete(terminal);
+        if (original) syncSet(fd, original.termios);
+        return;
+      }
+      const current = syncGet(fd);
+      if (!saved.has(terminal)) saved.set(terminal, { fd, termios: current });
+      syncSet(fd, rawOf(current));
+    }
+  };
   const modes = () => [...saved].reverse().map(([terminal, { fd, termios }]) => ({ terminal, fd, termios }));
-  return { tty, restore, modes };
+  return { tty, syncTty, restore, modes };
 }
 var BRKINT, INPCK, ISTRIP, ICRNL, IXON, ONLCR, CS8, ISIG, ICANON, ECHO, IEXTEN, VTIME, VMIN;
 var init_js_tty = __esm({
@@ -11809,6 +11833,26 @@ var init_js_websocket = __esm({
 });
 
 // src/process/js/js-context.ts
+function fdList(list) {
+  const fds = [...list ?? []];
+  if (!fds.every((fd) => Number.isInteger(fd) && fd >= 0))
+    throw new JsCallError("EINVAL", "select", "ERR_INVALID_ARG_VALUE: fds must be integers >= 0");
+  return fds;
+}
+async function selectOp(kernel, sets, signal) {
+  signal?.throwIfAborted();
+  const read2 = fdList(sets.read);
+  const write2 = fdList(sets.write);
+  const timeoutMs2 = sets.timeoutMs ?? -1;
+  if (!Number.isFinite(timeoutMs2))
+    throw new JsCallError("EINVAL", "select", "ERR_INVALID_ARG_VALUE: timeoutMs");
+  const r = await kernel.blocking(
+    { op: "fd-select", read: read2, write: write2, timeoutMs: Math.max(-1, Math.floor(timeoutMs2)) },
+    signal
+  );
+  const got = r.ok && r.kind === "json" ? r.json : {};
+  return { read: got.read ?? [], write: got.write ?? [] };
+}
 function listen(listeners, listener) {
   const own = (error, promise) => listener(error, promise);
   listeners.add(own);
@@ -11898,7 +11942,17 @@ function writer(kernel, info, pid) {
       writes.delete(w);
     }
   };
-  return { writes, writeAll };
+  const writeSome = async (fd, data) => {
+    const i = await info(fd);
+    if (writeDevice(i)) return data.length;
+    const body = data.subarray(0, MAX_IO);
+    const r = await kernel.raw({ op: "fd-write", fd, body, nonblock: true });
+    if (r.ok) return written(r, body.length);
+    if (brokenPipe(callError(r, "fd-write"), i))
+      await kernel.call({ op: "proc-kill", pid, sig: SIG.PIPE });
+    throw callError(r, "fd-write");
+  };
+  return { writes, writeAll, writeSome };
 }
 function readable2(read2) {
   return new ReadableStream(
@@ -12046,6 +12100,24 @@ function pendingReads(kernel, info, random) {
   };
   return { read: read2, closing };
 }
+function tracked2(pending, writeAll, writeSome) {
+  return (fd, data, options) => {
+    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
+    let settle;
+    const settled2 = new Promise((resolve) => settle = resolve);
+    pending.add(settled2);
+    return (async () => {
+      try {
+        if (options?.nonblock === true) return await writeSome(fd, bytes);
+        await writeAll(fd, bytes);
+        return bytes.length;
+      } finally {
+        pending.delete(settled2);
+        settle();
+      }
+    })();
+  };
+}
 function createContext(o) {
   const { kernel } = o;
   const infos = /* @__PURE__ */ new Map();
@@ -12072,22 +12144,13 @@ function createContext(o) {
     return got;
   };
   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;
-    let settle;
-    const settled2 = new Promise((resolve2) => settle = resolve2);
-    pending.add(settled2);
-    return (async () => {
-      try {
-        await writeAll(fd, bytes);
-      } finally {
-        pending.delete(settled2);
-        settle();
-      }
-    })();
-  };
-  const writable2 = (fd) => new WritableStream({ write: (chunk) => write2(fd, chunk) });
+  const { writes, writeAll, writeSome } = writer(kernel, info, o.pid);
+  const write2 = tracked2(pending, writeAll, writeSome);
+  const writable2 = (fd) => new WritableStream({
+    write: async (chunk) => {
+      await write2(fd, chunk);
+    }
+  });
   const statOf = async (op, path) => {
     const abs = resolve(path);
     if (inDev(abs)) return devAsync(kernel, devStat(abs, op === "stat"));
@@ -12113,10 +12176,11 @@ function createContext(o) {
   const lane = o.lane ?? laneOf(void 0);
   if (o.lane && o.lane !== noLane) kernel.syncLane = o.lane;
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
-  const terminal = ttyOps(kernel);
+  const terminal = ttyOps(kernel, syncKernel);
   const shared = { pid: o.pid, resolve, random, infos, handles, closing };
   const sync = {
     kernel: KERNEL_INFO,
+    tty: terminal.syncTty,
     ...watchingSyncOps(kernel, syncKernel, shared),
     run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve, signal: signalNumber }, options),
     spawn: (options) => spawnSync(options),
@@ -12161,6 +12225,7 @@ function createContext(o) {
     },
     socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
     pipe: async () => await kernel.json({ op: "fd-pipe" }),
+    select: (sets, options) => selectOp(kernel, sets, options?.signal),
     async fdStatus(fd) {
       const type = typeOf(await info(fd));
       return { type, tty: type === "tty", seekable: type === "file" };