@ai-ecoverse/slicc-kernel 1.56.1 → 1.56.2

package/README.md

@@ -183,6 +183,8 @@ That's for programs that walk to the root, such as Go's (`GOOS=wasip1`) and esbu
 
 A descriptor a program inherits at one of those numbers (from bash's `3<file`, or a `posix_spawn` file action) moves to the first free number above them. One above the range keeps its number. A command that takes descriptors by number from its caller should leave `preopenRoot` off, which keeps the shorter range.
 
+**Paths with `..`.** A `..` after a symlinked directory goes to the parent of the link's target, as on Linux: with `/a/link -> /x/y`, `/a/link/../f` is `/x/f`, for a WASI program as for bash. A `..` after a file or a missing name fails with `ENOTDIR` or `ENOENT`. Paths without `..` are joined as they are.
+
 On top of preview1 a WASI program gets:
 
 - **Threads**: `wasi.thread-spawn` (wasm32-wasip1-threads) and WASIX `thread_spawn_v2` start a worker per thread on the process's shared memory, sized from the module's own import (a 2 GiB maximum when the engine cannot reserve more). The threads share one descriptor table; `exit` or a trap in any thread ends the process. At most 64 threads per process; `SLICC_WASM_THREADS` sets another cap, up to 256.

package/dist/kernel-worker.js

@@ -438,12 +438,34 @@ var OpfsFs = class {
         const link2 = await this.linkAlong(current);
         if (!link2) throw err;
         if (link2.path === current && !follow2) return { path: current, link: link2 };
-        const rest2 = current.slice(link2.path.length);
-        current = resolvePath(parentOf2(link2.path), `${link2.link}${rest2}`);
+        const target = `${link2.link}${current.slice(link2.path.length)}`;
+        current = target.split("/").includes("..") ? await this.physical(parentOf2(link2.path), target, hops + 1) : resolvePath(parentOf2(link2.path), target);
       }
     }
     throw fsError("ELOOP", path);
   }
+  async physical(base, path, used) {
+    let done4 = [];
+    let todo = (path.startsWith("/") ? path : `${base}/${path}`).split("/").filter((p) => p !== "" && p !== ".");
+    for (let hops = used; todo.length > 0; ) {
+      const part = todo.shift();
+      if (part === "..") done4.pop();
+      else if (!todo.includes("..")) done4.push(part);
+      else {
+        const at = `/${[...done4, part].join("/")}`;
+        const st = await this.lstat(at);
+        if (!st.isSymbolicLink && !st.isDirectory) throw fsError("ENOTDIR", at);
+        if (!st.isSymbolicLink) done4.push(part);
+        else if (++hops > MAX_LINKS) throw fsError("ELOOP", path);
+        else {
+          const link2 = await this.readlink(at);
+          if (link2.startsWith("/")) done4 = [];
+          todo = [...link2.split("/").filter((p) => p !== "" && p !== "."), ...todo];
+        }
+      }
+    }
+    return `/${done4.join("/")}`;
+  }
   mode(path, directory, meta) {
     const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
     return (directory ? S_IFDIR : S_IFREG) | (meta?.mode ?? fallback);
@@ -9631,6 +9653,11 @@ var MAX_LINKS5 = 40;
 function parentOf6(path) {
   return path.slice(0, path.lastIndexOf("/")) || "/";
 }
+async function mustBeDir(fs, path) {
+  if (!fs.lstat) return;
+  const st = await fs.lstat(path);
+  if (st.isDirectory !== true) throw fsError("ENOTDIR", path);
+}
 async function linkOf(fs, path) {
   return fs.readlink?.(path).catch(() => void 0);
 }
@@ -9647,6 +9674,7 @@ async function realDir(fs, dir, budget = { hops: 0 }) {
     const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
     const link2 = await linkOf(fs, next2);
     if (link2 === void 0) {
+      if (queue.find((p) => p !== ".") === "..") await mustBeDir(fs, next2);
       at = next2;
       continue;
     }