@ai-ecoverse/slicc-kernel 1.6.0 → 1.6.1

package/dist/process-worker.js

@@ -469,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 ?? []) {
@@ -495,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;
@@ -516,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)"
@@ -536,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"() {
@@ -580,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);
@@ -595,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) {
@@ -1626,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);
@@ -1720,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";
@@ -1743,6 +1817,7 @@ var init_process_fds = __esm({
       ioctl: "__syscall_ioctl",
       setitimer: "_setitimer_js"
     };
+    EBADF = 8;
     DIR_MODE = 16749;
     LINK_MODE = 41408;
   }
@@ -2403,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);