@ai-ecoverse/slicc-kernel 1.47.3 → 1.48.1

package/dist/node-process-worker.js

@@ -1673,7 +1673,7 @@ function ptyStat(path) {
 function nonblocking(stream) {
   return (stream.flags & O_NONBLOCK) !== 0 ? { nonblock: true } : void 0;
 }
-var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, TTY_NAME, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
+var POLLIN, POLLOUT, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, TCSETSF, O_NONBLOCK, SOCKET_MODE, PTY_PATH, TTY_PATH, TTY_NAME, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, KILLED_BY_SIGPIPE, ProcessExit, SyscallError, KernelStreams;
 var init_kernel_streams = __esm({
   "src/process/kernel-streams.ts"() {
     "use strict";
@@ -1684,6 +1684,7 @@ var init_kernel_streams = __esm({
     POLLHUP = 16;
     POLLRDNORM = 64;
     POLLWRNORM = 256;
+    TCSETSF = 21508;
     O_NONBLOCK = 2048;
     SOCKET_MODE = 49663;
     PTY_PATH = /^\/dev\/(?:ptmx|pts\/(\d+))$/;
@@ -1802,8 +1803,8 @@ var init_kernel_streams = __esm({
         return {
           ops: {
             ioctl_tcgets: () => this.call(() => this.sys.tcgets?.(kfd)),
-            ioctl_tcsets: (_tty, _op, termios) => this.call(() => {
-              this.sys.tcsets?.(kfd, termios);
+            ioctl_tcsets: (_tty, op, termios) => this.call(() => {
+              this.sys.tcsets?.(kfd, termios, op === TCSETSF);
               return 0;
             }),
             ioctl_tiocgwinsz: () => this.call(() => this.sys.winsize?.(kfd) ?? [24, 80]),
@@ -3926,8 +3927,8 @@ function kernelSys(transport) {
     tcgets(fd) {
       return json(call2({ op: "tty-get", fd }, `tty-get ${fd}`));
     },
-    tcsets(fd, termios) {
-      call2({ op: "tty-set", fd, termios }, `tty-set ${fd}`);
+    tcsets(fd, termios, flush) {
+      call2({ op: "tty-set", fd, termios, ...flush ? { flush } : {} }, `tty-set ${fd}`);
     },
     winsize(fd) {
       return json(call2({ op: "tty-winsz", fd }, `tty-winsz ${fd}`));
@@ -5460,6 +5461,75 @@ var init_wasi_poll = __esm({
   }
 });
 
+// src/process/wasi/wasi-termios.ts
+function writeTermios(mem, ptr, termios) {
+  mem.bytes(ptr, OSPEED + 4).fill(0);
+  const v = mem.view();
+  v.setUint32(ptr, termios.c_iflag, true);
+  v.setUint32(ptr + 4, termios.c_oflag, true);
+  v.setUint32(ptr + 8, termios.c_cflag, true);
+  v.setUint32(ptr + 12, termios.c_lflag, true);
+  for (let i = 0; i < NCCS; i++) v.setUint8(ptr + C_CC + i, termios.c_cc[i] ?? 0);
+  v.setUint8(ptr + C_LINE, 0);
+  v.setUint32(ptr + ISPEED, B38400, true);
+  v.setUint32(ptr + OSPEED, B38400, true);
+}
+function readTermios(mem, ptr) {
+  const v = mem.view();
+  return {
+    c_iflag: v.getUint32(ptr, true),
+    c_oflag: v.getUint32(ptr + 4, true),
+    c_cflag: v.getUint32(ptr + 8, true),
+    c_lflag: v.getUint32(ptr + 12, true),
+    c_cc: Array.from({ length: NCCS }, (_, i) => v.getUint8(ptr + C_CC + i))
+  };
+}
+function sliccTty(mem, fds, kernel) {
+  const { sys } = kernel;
+  const terminal = (fd) => {
+    const e = fds.find(fd);
+    if (!e) throw new WasiError("EBADF");
+    if (e.type !== "kernel" || fds.kind(fd, e) !== "tty") throw new WasiError("ENOTTY");
+    return fd;
+  };
+  const needs = (value2) => {
+    if (value2 === void 0) throw new WasiError("ENOTTY");
+    return value2;
+  };
+  const setAttr = (fd, actions, ptr) => {
+    if (actions < 0 || actions > TCSAFLUSH) throw new WasiError("EINVAL");
+    const at = terminal(fd);
+    needs(sys.tcsets);
+    sys.tcsets?.(at, readTermios(mem, ptr), actions === TCSAFLUSH);
+  };
+  const size = (fd, ptr) => {
+    const [rows, cols] = needs(sys.winsize?.(terminal(fd)));
+    mem.bytes(ptr, 8).fill(0);
+    const v = mem.view();
+    v.setUint16(ptr, rows, true);
+    v.setUint16(ptr + 2, cols, true);
+  };
+  return {
+    tcgetattr: (fd, ptr) => void writeTermios(mem, ptr, needs(sys.tcgets?.(terminal(fd)))),
+    tcsetattr: (fd, actions, ptr) => void setAttr(fd, actions, ptr),
+    winsize: (fd, ptr) => void size(fd, ptr)
+  };
+}
+var NCCS, C_LINE, C_CC, ISPEED, OSPEED, B38400, TCSAFLUSH;
+var init_wasi_termios = __esm({
+  "src/process/wasi/wasi-termios.ts"() {
+    "use strict";
+    init_wasi_files();
+    NCCS = 32;
+    C_LINE = 16;
+    C_CC = 17;
+    ISPEED = 52;
+    OSPEED = 56;
+    B38400 = 15;
+    TCSAFLUSH = 2;
+  }
+});
+
 // src/process/wasi/wasi-host.ts
 function filetypeOf(s) {
   if (!s) return FILETYPE.UNKNOWN;
@@ -5529,6 +5599,7 @@ var init_wasi_host = __esm({
     init_wasi_files();
     init_wasi_memory();
     init_wasi_poll();
+    init_wasi_termios();
     WasiExit = class extends Error {
       code;
       constructor(code2) {
@@ -5587,6 +5658,9 @@ var init_wasi_host = __esm({
         const umask = this.o.kernel.call({ op: "proc-umask" });
         if (umask !== DEFAULT_UMASK) this.o.fs.chmod(path, mode & ~umask);
       }
+      sliccTtyImports() {
+        return wrap(sliccTty(this.mem, this.fds, this.o.kernel));
+      }
       sliccFsImports() {
         const { mem, fds } = this;
         const at = (dirfd, p, l) => fds.resolve(dirfd, mem.string(p, l));
@@ -6242,7 +6316,7 @@ function restarted2(issue) {
 function resolveFrom(cwd, path) {
   return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
 }
-var O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUNC, WasixProcess;
+var O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUNC, JOIN_NON_BLOCKING, JOIN_WAKE_STOPPED, JOIN_STOPPED, WasixProcess;
 var init_wasix_process = __esm({
   "src/process/wasi/wasix-process.ts"() {
     "use strict";
@@ -6254,6 +6328,9 @@ var init_wasix_process = __esm({
     O_APPEND2 = 1024;
     OFLAG_CREAT = 1;
     OFLAG_TRUNC = 8;
+    JOIN_NON_BLOCKING = 1;
+    JOIN_WAKE_STOPPED = 2;
+    JOIN_STOPPED = 3;
     WasixProcess = class {
       host;
       driver;
@@ -6383,13 +6460,21 @@ var init_wasix_process = __esm({
         const v = this.host.mem.view();
         const pid = v.getUint8(pidPtr) === 1 ? v.getUint32(pidPtr + 4, true) : -1;
         this.host.mem.bytes(statusPtr, 6).fill(0);
-        const [child, status2] = this.call({ op: "proc-wait", pid, nohang: (flags & 1) !== 0 });
+        const [child, status2] = this.call({
+          op: "proc-wait",
+          pid,
+          nohang: (flags & JOIN_NON_BLOCKING) !== 0,
+          ...flags & JOIN_WAKE_STOPPED ? { untraced: true } : {}
+        });
         if (child === 0) return;
         this.host.o.fs.invalidate?.();
         v.setUint8(pidPtr, 1);
         v.setUint32(pidPtr + 4, child, true);
         const sig = status2 & 127;
-        if (sig) {
+        if (sig === 127) {
+          v.setUint8(statusPtr, JOIN_STOPPED);
+          v.setUint8(statusPtr + 2, status2 >> 8 & 255);
+        } else if (sig) {
           v.setUint8(statusPtr, 2);
           v.setUint8(statusPtr + 4, sig);
         } else {
@@ -7929,11 +8014,7 @@ var init_wasix_host = __esm({
         v.setUint8(ptr + 16, isTty(0));
         v.setUint8(ptr + 17, isTty(1));
         v.setUint8(ptr + 18, isTty(2));
-        if (fd === void 0) {
-          v.setUint32(ptr, 80, true);
-          v.setUint32(ptr + 4, 24, true);
-          return;
-        }
+        if (fd === void 0) throw new WasiError("ENOTTY");
         const [rows, cols] = host.o.kernel.sys.winsize?.(fd) ?? [24, 80];
         const termios = host.o.kernel.sys.tcgets?.(fd);
         v.setUint32(ptr, cols, true);
@@ -8082,15 +8163,16 @@ function unsupportedImport(module, memory, extended = false, foreign = {}) {
   }
   return void 0;
 }
-function linkImports(module, preview1, wasix, memory, threads, program = {}, foreign, slicc = {}, sliccFs = {}) {
+function linkImports(module, preview1, wasix, memory, threads, program = {}, foreign, slicc = {}, sliccFs = {}, sliccTty2 = {}) {
   for (const ns of Object.keys(program)) {
-    if (RESERVED2.has(ns) || ns === SLICC || ns === SLICC_FS)
+    if (RESERVED2.has(ns) || ns === SLICC || ns === SLICC_FS || ns === SLICC_TTY)
       throw new Error(`the imports module may not define ${ns}`);
   }
   const imports = {
     ...program,
     [SLICC]: { ...slicc },
     [SLICC_FS]: { ...sliccFs },
+    [SLICC_TTY]: { ...sliccTty2 },
     [PREVIEW1]: preview1,
     ...wasix ? { [WASIX]: { ...wasix } } : {},
     ...threads ? { wasi: { "thread-spawn": (arg) => threads.spawn(arg) } } : {}
@@ -8219,6 +8301,7 @@ async function instantiate(host, module, memory, threads, {
   );
   const slicc = traced(stats, "slicc", host.sliccImports());
   const sliccFs = traced(stats, "slicc_fs", host.sliccFsImports());
+  const sliccTty2 = traced(stats, "slicc_tty", host.sliccTtyImports());
   const hostImports = linkImports(
     module,
     preview1,
@@ -8228,7 +8311,8 @@ async function instantiate(host, module, memory, threads, {
     extra,
     foreign,
     slicc,
-    sliccFs
+    sliccFs,
+    sliccTty2
   );
   const imports = sync ? merge(hostImports, sync.linker.mainImports(module)) : hostImports;
   instance = await WebAssembly.instantiate(module, imports);
@@ -8435,7 +8519,7 @@ async function runWasiThread(init, port3) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, SLICC_FS, RESERVED2, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, SLICC_FS, SLICC_TTY, RESERVED2, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -8468,6 +8552,7 @@ var init_wasi_runtime = __esm({
       if (defaultAction(sig) === "terminate") throw new WasiExit(128 + sig);
     };
     SLICC_FS = "slicc_fs";
+    SLICC_TTY = "slicc_tty";
     RESERVED2 = RESERVED_NAMESPACES;
     importsSigactionHook = (module) => WebAssembly.Module.imports(module).some((i) => i.module === SLICC && i.name === "sigaction_set");
     noErrno = (key) => `imports ${key}: its result cannot carry ENOSYS, and this host does not provide it`;
@@ -8916,6 +9001,56 @@ function latin1(bytes) {
   }
   return text;
 }
+function quoted(input, from) {
+  let value2 = "";
+  let at = from + 1;
+  while (at < input.length) {
+    const char = input[at++];
+    if (char === '"') break;
+    if (char !== "\\") value2 += char;
+    else if (at < input.length) value2 += input[at++];
+    else value2 += char;
+  }
+  return [value2, at];
+}
+function parameter(text, from, params) {
+  let at = from + 1;
+  while (SPACE.test(text[at] ?? "")) at++;
+  let end = at;
+  while (end < text.length && text[end] !== ";" && text[end] !== "=") end++;
+  const name = text.slice(at, end).toLowerCase();
+  if (text[end] !== "=") return end;
+  const start2 = end + 1;
+  let value2;
+  if (text[start2] === '"') {
+    [value2, at] = quoted(text, start2);
+    end = text.indexOf(";", at);
+  } else {
+    end = text.indexOf(";", start2);
+    value2 = text.slice(start2, end < 0 ? void 0 : end).replace(/[\t\n\r ]+$/, "");
+    if (!value2) return end < 0 ? text.length : end;
+  }
+  if (end < 0) end = text.length;
+  if (TOKEN.test(name) && QUOTABLE.test(value2) && !params.has(name)) {
+    params.set(name, value2);
+  }
+  return end;
+}
+function mimeType(input) {
+  const text = input.replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, "");
+  const slash = text.indexOf("/");
+  const semi = text.indexOf(";", slash);
+  const type = text.slice(0, slash);
+  const subtype = text.slice(slash + 1, semi < 0 ? void 0 : semi).replace(/[\t\n\r ]+$/, "");
+  if (slash < 0 || !TOKEN.test(type) || !TOKEN.test(subtype)) return void 0;
+  const params = /* @__PURE__ */ new Map();
+  for (let at = semi < 0 ? text.length : semi; at < text.length; ) at = parameter(text, at, params);
+  let out = `${type}/${subtype}`.toLowerCase();
+  for (const [name, value2] of params) {
+    out += `;${name}=${TOKEN.test(value2) ? value2 : `"${value2.replace(/["\\]/g, "\\$&")}"`}`;
+  }
+  return out;
+}
 function dataResponse(request) {
   const url = withoutFragment(new URL(request.url));
   const rest2 = url.slice("data:".length);
@@ -8925,7 +9060,7 @@ function dataResponse(request) {
   let body = percentDecode(rest2.slice(comma + 1));
   const base642 = BASE64.exec(type);
   if (base642) {
-    type = type.slice(0, base642.index).replace(/[\t\n\f\r ]+$/, "");
+    type = type.slice(0, base642.index);
     let binary;
     try {
       binary = atob(latin1(body));
@@ -8935,11 +9070,10 @@ function dataResponse(request) {
     body = Uint8Array.from(binary, (c) => c.charCodeAt(0));
   }
   if (type.startsWith(";")) type = `text/plain${type}`;
-  if (!MIME.test(type)) type = "text/plain;charset=US-ASCII";
-  const response = new Response(body, {
-    status: 200,
-    headers: { "content-type": type }
-  });
+  const response = new Response(
+    request.method === "HEAD" ? null : body,
+    { status: 200, headers: { "content-type": mimeType(type) ?? "text/plain;charset=US-ASCII" } }
+  );
   return withMeta(response, url, false);
 }
 function withMeta(response, url, redirected) {
@@ -9127,7 +9261,7 @@ function fetchOp(kernel) {
     }
   };
 }
-var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER, MIME, BASE64, SLICE;
+var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER, TOKEN, QUOTABLE, SPACE, BASE64, SLICE;
 var init_js_fetch = __esm({
   "src/process/js/js-fetch.ts"() {
     "use strict";
@@ -9146,7 +9280,9 @@ var init_js_fetch = __esm({
     DECODED = /* @__PURE__ */ new Set(["gzip", "x-gzip", "deflate"]);
     CREDENTIALS = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2"]);
     OVER = /* @__PURE__ */ Symbol("over");
-    MIME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+(?:[\t ]*;.*)?$/s;
+    TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+    QUOTABLE = /^[\t\x20-\x7e\x80-\xff]*$/;
+    SPACE = /[\t\n\r ]/;
     BASE64 = /; *base64$/i;
     SLICE = 32768;
   }
@@ -9623,6 +9759,7 @@ function rawOf(termios) {
 }
 function ttyOps(kernel) {
   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 });
   const setAttr = async (fd, termios) => {
     await kernel.call({ op: "tty-set", fd, termios: copy(termios) });
@@ -9631,14 +9768,15 @@ function ttyOps(kernel) {
     getAttr,
     setAttr,
     async setRaw(fd, raw) {
+      const terminal = await terminalOf(fd);
       if (!raw) {
-        const original = saved.get(fd);
-        saved.delete(fd);
-        if (original) await setAttr(fd, original);
+        const original = saved.get(terminal);
+        saved.delete(terminal);
+        if (original) await setAttr(fd, original.termios);
         return;
       }
       const current = await getAttr(fd);
-      if (!saved.has(fd)) saved.set(fd, current);
+      if (!saved.has(terminal)) saved.set(terminal, { fd, termios: current });
       await setAttr(fd, rawOf(current));
     },
     async size(fd) {
@@ -9651,9 +9789,9 @@ function ttyOps(kernel) {
     }
   };
   const restore = async () => {
-    for (const [fd, original] of [...saved].reverse()) {
-      saved.delete(fd);
-      await setAttr(fd, original).catch(() => void 0);
+    for (const [terminal, { fd, termios }] of [...saved].reverse()) {
+      saved.delete(terminal);
+      await setAttr(fd, termios).catch(() => void 0);
     }
   };
   return { tty, restore };