@ai-ecoverse/slicc-kernel 1.5.0 → 1.6.1

package/dist/process-worker.js

@@ -14,7 +14,7 @@ var __export = (target, all) => {
 };
 
 // src/kernel/protocol.ts
-var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS;
+var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS, WASM_DEFAULT_THREADS;
 var init_protocol = __esm({
   "src/kernel/protocol.ts"() {
     "use strict";
@@ -24,7 +24,8 @@ var init_protocol = __esm({
     WASM_THREAD_SPAWN = "wasm-thread-spawn";
     WASM_THREAD_INIT = "wasm-thread-init";
     WASM_THREAD_EXIT = "wasm-thread-exit";
-    WASM_MAX_THREADS = 64;
+    WASM_MAX_THREADS = 256;
+    WASM_DEFAULT_THREADS = 64;
   }
 });
 
@@ -468,7 +469,7 @@ function createLiveVfsPlugin(Fs) {
   };
 }
 function ownedBy(plugin, node) {
-  return !!node && plugin.mounts.has(node.mount);
+  return !!node?.live && plugin.mounts.has(node.mount);
 }
 function flushLiveVfs(Fs, plugin) {
   for (const head of Fs.nameTable ?? []) {
@@ -494,7 +495,7 @@ function invalidateLiveVfs(Fs, plugin) {
       s.stat = void 0;
       s.listed = void 0;
       if (s.openCount === 0) {
-        if (node !== node.mount.root) drop.push(node);
+        if (node !== node.mount.root && !node.mounted) drop.push(node);
       } else if (s.loaded && !s.dirty) {
         s.data = void 0;
         s.len = 0;
@@ -515,6 +516,7 @@ function describeMountError(err) {
   return typeof errno2 === "number" ? `errno ${errno2}` : String(err);
 }
 function mountLiveVfsDirs(Fs, bridge, dirs, warn) {
+  if (Fs.root?.memfs) Fs.root.node_ops = Fs.root.memfs;
   if (typeof Fs.filesystems !== "object" || !Fs.filesystems) {
     throw new Error(
       "the module was linked without filesystem support, so the VFS cannot be mounted (link it with -sFORCE_FILESYSTEM=1)"
@@ -535,6 +537,55 @@ function mountLiveVfsDirs(Fs, bridge, dirs, warn) {
   }
   return { plugin, mounted };
 }
+function liveRoot(Fs, bridge) {
+  const root = Fs.root;
+  const plugin = Fs.filesystems.SLICC_LIVE_FS;
+  if (!root || !plugin) return;
+  root.mount.opts = { root: "/", bridge };
+  root.live = { len: 0, loaded: false, dirty: false, openCount: 0 };
+  plugin.mounts.add(root.mount);
+  invalidateLiveVfs(Fs, plugin);
+  guardRenames(Fs);
+  const memfs = root.memfs ?? root.node_ops;
+  const live = plugin.node_ops;
+  root.memfs = memfs;
+  const own = (name) => Object.hasOwn(root.contents ?? {}, name);
+  root.node_ops = {
+    ...memfs,
+    lookup: (parent, name) => live.lookup(parent, name),
+    mknod: (parent, name, mode, dev) => live.mknod(parent, name, mode, dev),
+    unlink: (parent, name) => live.unlink(parent, name),
+    rmdir: (parent, name) => (own(name) ? memfs : live).rmdir(parent, name),
+    symlink: (parent, name, target) => live.symlink(parent, name, target),
+    rename: (node, dir, name) => (node.live ? live : memfs).rename(node, dir, name),
+    readdir(node) {
+      const names = new Set(memfs.readdir(node));
+      for (const name of live.readdir(node)) names.add(name);
+      return [...names];
+    }
+  };
+}
+function crosses(Fs, from, to) {
+  const parentOf = (path) => Fs.lookupPath?.(path, { parent: true }).node;
+  const name = from.replace(/\/+$/, "").split("/").pop() ?? "";
+  try {
+    const fromDir = parentOf(from);
+    const node = fromDir && Fs.lookupNode?.(fromDir, name);
+    const dir = parentOf(to);
+    return !!node && !!dir && !!node.live !== !!dir.live;
+  } catch {
+    return false;
+  }
+}
+function guardRenames(Fs) {
+  const rename = Fs.rename?.bind(Fs);
+  if (!rename || Fs.sliccRename) return;
+  Fs.sliccRename = true;
+  Fs.rename = (from, to) => {
+    if (crosses(Fs, from, to)) throw new Fs.ErrnoError(ERRNO_BY_CODE.EXDEV);
+    rename(from, to);
+  };
+}
 var ERRNO_BY_CODE, EIO, S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR, SEEK_END;
 var init_live_vfs_fs = __esm({
   "src/realm/live-vfs-fs.ts"() {
@@ -579,7 +630,7 @@ function topLevelDirs(bridge, warn) {
     names = bridge.readdir("/");
   } catch (err) {
     warn(`cannot list the VFS root, nothing mounted: ${String(err)}`);
-    return [];
+    return void 0;
   }
   const candidates = names.filter((name) => name && !name.includes("/") && !MODULE_OWNED_DIRS.has(name)).map((name) => `/${name}`);
   for (const dir of SYNTHETIC_DIRS) if (!candidates.includes(dir)) candidates.push(dir);
@@ -594,7 +645,9 @@ function topLevelDirs(bridge, warn) {
 }
 function mountVfsIntoEmscripten(Fs, deps) {
   const { bridge, warn } = deps;
-  const { plugin, mounted } = mountLiveVfsDirs(Fs, bridge, topLevelDirs(bridge, warn), warn);
+  const dirs = topLevelDirs(bridge, warn);
+  const { plugin, mounted } = mountLiveVfsDirs(Fs, bridge, dirs ?? [], warn);
+  if (dirs) liveRoot(Fs, bridge);
   try {
     Fs.chdir(deps.cwd);
   } catch (err) {
@@ -1625,6 +1678,28 @@ function wrapCloexecSyscalls(imports, glue, deps) {
     }
   }
 }
+function persistsItself(stream) {
+  const type = stream.node.mount?.type;
+  return typeof type?.syncfs === "function";
+}
+function syncFsync(imports, fs) {
+  for (const namespace of Object.values(imports)) {
+    const original = namespace?.fd_sync;
+    if (typeof original !== "function" || !original.isAsync) continue;
+    namespace.fd_sync = (fd) => {
+      const stream = fs()?.getStream(fd);
+      if (!stream) return EBADF;
+      if (persistsItself(stream)) return original(fd);
+      try {
+        const result = stream.stream_ops.fsync?.(stream);
+        return typeof result === "number" ? result : 0;
+      } catch (err) {
+        const { errno: errno2, code: code2 } = err;
+        return typeof errno2 === "number" ? errno2 : wasiErrno(String(code2));
+      }
+    };
+  }
+}
 function wasmMemory(instance, imports) {
   const isMemory = (v) => v instanceof WebAssembly.Memory;
   const exported = Object.values(instance.exports).find(isMemory);
@@ -1719,7 +1794,7 @@ function useDevFd(Fs) {
     return fstat.call(Fs, fd);
   };
 }
-var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, DIR_MODE, LINK_MODE;
+var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, DIR_MODE, LINK_MODE;
 var init_process_fds = __esm({
   "src/process/process-fds.ts"() {
     "use strict";
@@ -1742,6 +1817,7 @@ var init_process_fds = __esm({
       ioctl: "__syscall_ioctl",
       setitimer: "_setitimer_js"
     };
+    EBADF = 8;
     DIR_MODE = 16749;
     LINK_MODE = 41408;
   }
@@ -2402,6 +2478,7 @@ async function runWasmProcess(init, port, deps = {}) {
             }
           }
         });
+        syncFsync(imports, () => ownValue(module, "FS"));
         return WebAssembly.instantiate(init.program.module, imports);
       }).then((instance) => {
         memory = wasmMemory(instance, imports);
@@ -4255,6 +4332,7 @@ function importsContext({
     fs,
     fds,
     syscall: call2,
+    ...processes(host, call2),
     async: {
       submit: (req) => call2({ op: "async-submit", req }),
       wait(timeoutMs) {
@@ -4284,13 +4362,69 @@ function importsContext({
     errno: (err) => wasiErrnoOf(code(err))
   };
 }
-var UID;
+function processes(host, call2) {
+  const close = (fd) => void call2({ op: "fd-close", fd });
+  const slot = (n, how, mine, theirs) => {
+    if (how === "inherit") return { fd: n };
+    if (how === "null") return { none: true };
+    const [read, write] = call2({ op: "fd-pipe" });
+    mine[n] = n === 0 ? write : read;
+    theirs.push(n === 0 ? read : write);
+    return { fd: n === 0 ? read : write };
+  };
+  return {
+    spawn(o) {
+      const mine = [];
+      const theirs = [];
+      host.fds.promoteFiles();
+      try {
+        const stdio = STDIO.map((name, n) => slot(n, o[name] ?? "inherit", mine, theirs));
+        const pid = call2({
+          op: "proc-spawn",
+          file: o.argv[0],
+          argv: o.argv,
+          env: o.env ?? { ...host.o.env },
+          cwd: o.cwd ?? host.cwd,
+          stdio
+        });
+        const out = { pid };
+        STDIO.forEach((name, n) => {
+          if (mine[n] !== void 0) out[name] = mine[n];
+        });
+        return out;
+      } catch (err) {
+        for (const fd of mine) if (fd !== void 0) close(fd);
+        throw err;
+      } finally {
+        for (const fd of theirs) close(fd);
+        host.o.fs.invalidate?.();
+      }
+    },
+    wait(pid) {
+      for (; ; ) {
+        try {
+          const [, status2] = call2({ op: "proc-wait", pid, nohang: false });
+          host.o.fs.invalidate?.();
+          const signal = status2 & 127;
+          return signal ? { status: 128 + signal, signal } : { status: status2 >> 8 & 255 };
+        } catch (err) {
+          if (code(err) !== "EINTR") throw err;
+        }
+      }
+    },
+    kill(pid, sig) {
+      call2({ op: "proc-kill", pid, sig });
+    }
+  };
+}
+var UID, STDIO;
 var init_wasi_imports = __esm({
   "src/process/wasi/wasi-imports.ts"() {
     "use strict";
     init_wasi_abi();
     init_wasi_files();
     UID = 1e3;
+    STDIO = ["stdin", "stdout", "stderr"];
   }
 });
 
@@ -4409,7 +4543,7 @@ var init_wasi_stats = __esm({
 // src/process/wasi/wasi-threads.ts
 function threadCap(env) {
   const asked = Number.parseInt(env.SLICC_WASM_THREADS ?? "", 10);
-  return asked >= 1 ? Math.min(asked, WASM_MAX_THREADS) : WASM_MAX_THREADS;
+  return asked >= 1 ? Math.min(asked, WASM_MAX_THREADS) : WASM_DEFAULT_THREADS;
 }
 var LAST_TID, RUNNING, MAIN_TID, ThreadExit, WasiThreads;
 var init_wasi_threads = __esm({