@ai-ecoverse/slicc-kernel 1.40.1 → 1.41.1

package/dist/process-worker.js

@@ -166,7 +166,7 @@ var init_pages = __esm({
         }
         const last = runs[runs.length - 1];
         if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
-        return runs.map(([start, n]) => [start, Math.min(n, this.stored - start)]);
+        return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
       }
       partial(at, length) {
         if (length === 0) return [];
@@ -174,16 +174,16 @@ var init_pages = __esm({
         const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length - 1) / PAGE)]);
         const runs = [];
         for (const page of edges) {
-          const start = page * PAGE;
-          const covered = at <= start && at + length >= start + PAGE;
-          if (covered || this.pages.has(page) || start >= this.stored) continue;
-          runs.push([start, Math.min(PAGE, this.stored - start)]);
+          const start2 = page * PAGE;
+          const covered = at <= start2 && at + length >= start2 + PAGE;
+          if (covered || this.pages.has(page) || start2 >= this.stored) continue;
+          runs.push([start2, Math.min(PAGE, this.stored - start2)]);
         }
         return runs;
       }
-      fill(start, bytes) {
+      fill(start2, bytes) {
         for (let at = 0; at < bytes.length; at += PAGE) {
-          const page = (start + at) / PAGE;
+          const page = (start2 + at) / PAGE;
           if (this.pages.has(page)) continue;
           const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
           const fresh = this.take(part.length);
@@ -249,14 +249,14 @@ var init_pages = __esm({
           while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
             j++;
           }
-          const start = first * PAGE;
+          const start2 = first * PAGE;
           const end = Math.min(this.length, (first + (j - i)) * PAGE);
-          const bytes = new Uint8Array(end - start);
+          const bytes = new Uint8Array(end - start2);
           for (let k = i; k < j; k++) {
             const page = this.pages.get(sorted[k]);
-            bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start)), (k - i) * PAGE);
+            bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
           }
-          runs.push({ offset: start, bytes });
+          runs.push({ offset: start2, bytes });
           i = j;
         }
         const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
@@ -339,8 +339,8 @@ var init_ranged = __esm({
         return this.pages.length;
       }
       fetch(runs) {
-        for (const [start, n] of runs) {
-          this.pages.fill(start, this.io.pread(this.path, start, n, this.version));
+        for (const [start2, n] of runs) {
+          this.pages.fill(start2, this.io.pread(this.path, start2, n, this.version));
         }
       }
       read(at, length) {
@@ -1794,9 +1794,9 @@ var init_kernel_streams = __esm({
         for (const name of ["stat", "lstat"]) {
           const original = fs[name];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest) => {
+          fs[name] = (path, ...rest2) => {
             const getattr = this.descriptions.get(path);
-            return getattr ? getattr() : original.call(fs, path, ...rest);
+            return getattr ? getattr() : original.call(fs, path, ...rest2);
           };
         }
       }
@@ -1884,13 +1884,13 @@ var init_kernel_streams = __esm({
         for (const name of ["chown", "lchown", "chmod", "lchmod"]) {
           const original = fs[name];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest);
+          fs[name] = (path, ...rest2) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest2);
         }
         for (const name of ["stat", "lstat"]) {
           const original = fs[name];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest) => {
-            if (!isPtyPath(path)) return original.call(fs, path, ...rest);
+          fs[name] = (path, ...rest2) => {
+            if (!isPtyPath(path)) return original.call(fs, path, ...rest2);
             this.existingPty(path);
             return ptyStat(path);
           };
@@ -2165,7 +2165,7 @@ function cloexecPipe2(pipe2, deps) {
   };
 }
 function quietTarget(dup3, deps) {
-  return (fd = -1, newfd = -1, flags = 0, ...rest) => {
+  return (fd = -1, newfd = -1, flags = 0, ...rest2) => {
     const Fs = deps.fs();
     const target = fd === newfd || flags !== 0 ? void 0 : Fs?.getStream(newfd);
     if (target && Fs?.getStream(fd)) {
@@ -2174,7 +2174,7 @@ function quietTarget(dup3, deps) {
       } catch {
       }
     }
-    return dup3(fd, newfd, flags, ...rest);
+    return dup3(fd, newfd, flags, ...rest2);
   };
 }
 function cloexecByFlag(syscall, flagArg, deps) {
@@ -2329,8 +2329,8 @@ function syncFsync(imports, fs, glue) {
     };
   }
 }
-function offsetOf(rest) {
-  const at = rest.length >= 3 ? Number(rest[1]) * 2 ** 32 + (Number(rest[0]) >>> 0) : Number(BigInt.asIntN(64, BigInt(rest[0])));
+function offsetOf(rest2) {
+  const at = rest2.length >= 3 ? Number(rest2[1]) * 2 ** 32 + (Number(rest2[0]) >>> 0) : Number(BigInt.asIntN(64, BigInt(rest2[0])));
   return at >= 0 && Number.isSafeInteger(at) ? at : void 0;
 }
 function readInto(sys, kfd, target, at) {
@@ -2344,14 +2344,14 @@ function readInto(sys, kfd, target, at) {
   return done;
 }
 function positioned(original, write, deps) {
-  return (fd, iov, iovcnt, ...rest) => {
+  return (fd, iov, iovcnt, ...rest2) => {
     const stream = deps.fs()?.getStream(Number(fd));
     const memory = deps.memory();
     const kfd = stream?.sliccKernelFile ? stream.sliccKernelFd : void 0;
     if (kfd === void 0 || !memory || !(write ? deps.sys.pwrite : deps.sys.pread)) {
-      return original(fd, iov, iovcnt, ...rest);
+      return original(fd, iov, iovcnt, ...rest2);
     }
-    const at = offsetOf(rest);
+    const at = offsetOf(rest2);
     if (at === void 0) return wasiErrno("EINVAL");
     const view = new DataView(memory.buffer);
     let done = 0;
@@ -2367,7 +2367,7 @@ function positioned(original, write, deps) {
     } catch (err) {
       return errnoOf(err);
     }
-    view.setUint32(Number(rest[rest.length - 1]), done, true);
+    view.setUint32(Number(rest2[rest2.length - 1]), done, true);
     return 0;
   };
 }
@@ -5343,11 +5343,11 @@ function kernelFiletype(kind) {
       return { filetype: FILETYPE.UNKNOWN, seeks: false };
   }
 }
-function direntRecord(next, ino, name, filetype) {
+function direntRecord(next2, ino, name, filetype) {
   const nameBytes = new TextEncoder().encode(name);
   const record = new Uint8Array(SIZE.DIRENT + nameBytes.length);
   const v = new DataView(record.buffer);
-  v.setBigUint64(0, BigInt(next), true);
+  v.setBigUint64(0, BigInt(next2), true);
   v.setBigUint64(8, ino, true);
   v.setUint32(16, nameBytes.length, true);
   v.setUint8(20, filetype);
@@ -5861,19 +5861,19 @@ var init_wasi_host = __esm({
           return { filetype: FILETYPE.CHARACTER_DEVICE, size: 0n, ino: pathInode(path), mtimeNs: 0n };
         }
         this.fds.flushPath(path);
-        const follow = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
-        return filestatOf(path, follow ? this.o.fs.stat(path) : this.o.fs.lstat(path));
+        const follow2 = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
+        return filestatOf(path, follow2 ? this.o.fs.stat(path) : this.o.fs.lstat(path));
       }
-      setTimes(path, atim, mtim, flags, follow = true) {
+      setTimes(path, atim, mtim, flags, follow2 = true) {
         const now = Date.now();
         let current;
-        const statOf = follow ? this.o.fs.stat.bind(this.o.fs) : this.o.fs.lstat.bind(this.o.fs);
+        const statOf = follow2 ? this.o.fs.stat.bind(this.o.fs) : this.o.fs.lstat.bind(this.o.fs);
         const kept = (field2) => {
           current ??= statOf(path);
           return current[field2] ?? current.mtimeMs ?? now;
         };
         const pick = (set, setNow, value2, field2) => flags & setNow ? now : flags & set ? Number(value2 / NS_PER_MS) : kept(field2);
-        (follow ? this.o.fs.utimes : this.o.fs.lutimes).call(
+        (follow2 ? this.o.fs.utimes : this.o.fs.lutimes).call(
           this.o.fs,
           path,
           pick(FSTFLAGS.ATIM, FSTFLAGS.ATIM_NOW, atim, "atimeMs"),
@@ -6779,6 +6779,61 @@ var init_wasix_linker = __esm({
   }
 });
 
+// src/fs/physical-path.ts
+function start(path) {
+  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
+}
+function next(walk) {
+  while (walk.todo.length > 0) {
+    const part = walk.todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      walk.done.pop();
+      continue;
+    }
+    return part;
+  }
+  return void 0;
+}
+function lexical(path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
+  return `/${walk.done.join("/")}`;
+}
+function rest(walk, part) {
+  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
+}
+function follow(walk, target) {
+  if (++walk.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk.done.length = 0;
+  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+  return true;
+}
+function physicalPath(fs, path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) {
+    const at = `/${[...walk.done, part].join("/")}`;
+    let target;
+    try {
+      target = fs.lstat(at).isSymbolicLink ? fs.readlink(at) : void 0;
+    } catch {
+      return rest(walk, part);
+    }
+    if (target === void 0) walk.done.push(part);
+    else if (!follow(walk, target)) {
+      throw Object.assign(new Error("too many levels of symbolic links"), { code: "ELOOP" });
+    }
+  }
+  return `/${walk.done.join("/")}`;
+}
+var MAX_HOPS;
+var init_physical_path = __esm({
+  "src/fs/physical-path.ts"() {
+    "use strict";
+    MAX_HOPS = 40;
+  }
+});
+
 // src/process/wasi/wasix-process.ts
 function resolveFrom(cwd, path) {
   return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
@@ -6787,6 +6842,7 @@ var POSIX_TO_WASI_SIGNAL, O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUN
 var init_wasix_process = __esm({
   "src/process/wasi/wasix-process.ts"() {
     "use strict";
+    init_physical_path();
     init_wasi_abi();
     init_wasi_files();
     init_wasi_host();
@@ -6873,10 +6929,13 @@ var init_wasix_process = __esm({
           const kfd = this.openFor(op, cwd);
           opened.push(kfd);
           point(op.fd, kfd);
-        } else if (op.cmd === "chdir") return resolveFrom(cwd, op.path);
-        else return fds.dir(op.fd).path;
+        } else if (op.cmd === "chdir") return this.physicalFrom(cwd, op.path);
+        else return physicalPath(this.host.o.fs, fds.dir(op.fd).path);
         return cwd;
       }
+      physicalFrom(cwd, path) {
+        return physicalPath(this.host.o.fs, path.startsWith("/") ? path : `${cwd}/${path}`);
+      }
       openFor(op, cwd) {
         const path = resolveFrom(cwd, op.path);
         const create = (op.oflags & OFLAG_CREAT) !== 0;
@@ -7100,6 +7159,18 @@ function wasixSocketImports(host, preview1) {
       fds.adopt(fd, "socket", false);
       mem.view().setUint32(out, fd, true);
     },
+    sock_pair: (af, type, _proto, out1, out2) => {
+      if (af !== UNIX)
+        throw new WasiError(af === INET4 || af === INET6 ? "EOPNOTSUPP" : "EAFNOSUPPORT");
+      if (type !== STREAM) throw new WasiError("EPROTONOSUPPORT");
+      mem.view().setUint32(out1, 0, true);
+      mem.view().setUint32(out2, 0, true);
+      const [a, b] = call2({ op: "sock-pair", domain: "unix" });
+      fds.adopt(a, "socket", false);
+      fds.adopt(b, "socket", false);
+      mem.view().setUint32(out1, a, true);
+      mem.view().setUint32(out2, b, true);
+    },
     sock_bind: (fd, addr) => {
       socket(fd);
       call2({ op: "sock-bind", fd, addr: readAddr(mem.view(), addr) });
@@ -7898,8 +7969,8 @@ function linkerHost(host, imports) {
       }
     },
     hostImports: () => {
-      const { env: _env, "GOT.mem": _mem, "GOT.func": _func, ...rest } = imports();
-      return rest;
+      const { env: _env, "GOT.mem": _mem, "GOT.func": _func, ...rest2 } = imports();
+      return rest2;
     }
   };
 }
@@ -8041,9 +8112,9 @@ async function runWasiThread(init, port) {
     foreign: init.program.foreign,
     ...program ? { program } : {}
   });
-  const start = instance.exports.wasi_thread_start;
+  const start2 = instance.exports.wasi_thread_start;
   try {
-    start(thread.tid, thread.arg);
+    start2(thread.tid, thread.arg);
     threads.exited();
   } catch (e) {
     if (e instanceof ThreadExit) {