@ai-ecoverse/slicc-kernel 1.54.2 → 1.54.3

package/dist/process-worker.js

@@ -4813,7 +4813,7 @@ function openAccess(existing, oflags, rights) {
   return { readable: (rights & RIGHTS.FD_READ) !== 0n || !writable2, writable: writable2 };
 }
 function promoteRequest(fd, f, handed) {
-  const orphan = f.buffer.isOrphan();
+  const orphan = f.buffer.isOrphan() || (f.buffer.handle ?? 0) < 0;
   if (!orphan && f.buffer.isRanged) f.buffer.flush();
   const joins = !orphan && (handed.has(f.buffer) || f.buffer.isRanged);
   return {
@@ -6800,60 +6800,201 @@ var init_wasi_module = __esm({
 function inProc(path) {
   return path === "/proc" || path.startsWith("/proc/");
 }
+function* procWalk(path, follow2) {
+  let done = [];
+  let todo = path.split("/").filter((part) => part !== "");
+  let hops = 0;
+  while (todo.length > 0) {
+    const part = todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      done.pop();
+      continue;
+    }
+    const at = `/${[...done, part].join("/")}`;
+    const whole = normalize(`/${[...done, part, ...todo].join("/")}`);
+    if (inProc(at) && inProc(whole)) return whole;
+    if (!follow2 && todo.length === 0) return void 0;
+    const target = yield at;
+    if (target === null) return void 0;
+    if (target === void 0) done.push(part);
+    else {
+      if (++hops > MAX_HOPS2) return void 0;
+      if (target.startsWith("/")) done = [];
+      todo = [...target.split("/").filter((part2) => part2 !== ""), ...todo];
+    }
+  }
+  return void 0;
+}
+function procPath(fs, path, follow2) {
+  const walk = procWalk(path, follow2);
+  let step = walk.next();
+  while (!step.done) {
+    let target;
+    try {
+      target = fs.lstat(step.value).isSymbolicLink ? fs.readlink(step.value) : void 0;
+    } catch {
+      target = null;
+    }
+    step = walk.next(target);
+  }
+  return step.value;
+}
+function frozen(bytes) {
+  const refuse = () => {
+    throw syncError("EROFS", "/proc");
+  };
+  return {
+    readFile: () => bytes,
+    pread: (_p, at, n) => bytes.subarray(at, at + n),
+    writeFile: refuse,
+    pwrite: refuse,
+    truncate: refuse
+  };
+}
 function procfsBridge(fs, tree) {
+  const toProc = (path, follow2) => procPath(fs, path, follow2);
+  const shadowing = () => {
+    try {
+      return fs.exists("/proc");
+    } catch {
+      return false;
+    }
+  };
+  const via = (p, proc, own, follow2 = true) => {
+    if (inProc(p)) return proc(p);
+    if (shadowing()) {
+      const real = toProc(p, follow2);
+      if (real !== void 0) return proc(real);
+    }
+    try {
+      return own();
+    } catch (err) {
+      const real = toProc(p, follow2);
+      if (real === void 0) throw err;
+      return proc(real);
+    }
+  };
+  const readOnly = (paths, run) => {
+    const physical = shadowing();
+    for (const [p, follow2] of paths) {
+      if (inProc(p) || physical && toProc(p, follow2) !== void 0) throw syncError("EROFS", p);
+    }
+    return run();
+  };
+  const snapshots = /* @__PURE__ */ new Map();
+  let lastSnapshot = 0;
+  const snapshot = (q) => {
+    lastSnapshot--;
+    snapshots.set(lastSnapshot, tree.read(q));
+    return lastSnapshot;
+  };
+  const late = (p) => {
+    const q = toProc(p, true);
+    return q === void 0 ? void 0 : snapshot(q);
+  };
   const over = {
-    readFile: (p) => inProc(p) ? tree.read(p) : fs.readFile(p),
-    stat: (p) => inProc(p) ? tree.stat(p) : fs.stat(p),
-    lstat: (p) => inProc(p) ? tree.stat(p, false) : fs.lstat(p),
-    readdir: (p) => {
-      if (inProc(p)) return tree.readdir(p);
-      const names = fs.readdir(p);
-      return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
-    },
-    exists: (p) => inProc(p) ? tree.exists(p) : fs.exists(p),
-    readlink: (p) => inProc(p) ? tree.readlink(p) : fs.readlink(p),
-    readdirStat: (p) => {
-      if (!inProc(p)) {
-        const listed = fs.readdirStat(p);
-        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
-        return [...listed, ["proc", tree.stat("/proc")]];
+    readFile: (p) => via(
+      p,
+      (q) => tree.read(q),
+      () => fs.readFile(p)
+    ),
+    stat: (p) => via(
+      p,
+      (q) => tree.stat(q),
+      () => fs.stat(p)
+    ),
+    lstat: (p) => via(
+      p,
+      (q) => tree.stat(q, false),
+      () => fs.lstat(p),
+      false
+    ),
+    readdir: (p) => via(
+      p,
+      (q) => tree.readdir(q),
+      () => {
+        const names = fs.readdir(p);
+        return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
       }
-      return tree.readdir(p).map((name2) => {
+    ),
+    exists: (p) => {
+      if (inProc(p)) return tree.exists(p);
+      const real = shadowing() ? toProc(p, true) : void 0;
+      if (real !== void 0) return tree.exists(real);
+      if (fs.exists(p)) return true;
+      const late2 = toProc(p, true);
+      return late2 !== void 0 && tree.exists(late2);
+    },
+    readlink: (p) => via(
+      p,
+      (q) => tree.readlink(q),
+      () => fs.readlink(p),
+      false
+    ),
+    readdirStat: (p) => via(
+      p,
+      (q) => tree.readdir(q).map((name2) => {
         try {
-          return [name2, tree.stat(`${p}/${name2}`, false)];
+          return [name2, tree.stat(`${q}/${name2}`, false)];
         } catch {
           return [name2, null];
         }
-      });
+      }),
+      () => {
+        const listed = fs.readdirStat(p);
+        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
+        return [...listed, ["proc", tree.stat("/proc")]];
+      }
+    ),
+    rename: (from, to) => readOnly(
+      [
+        [from, false],
+        [to, false]
+      ],
+      () => fs.rename(from, to)
+    ),
+    symlink: (target, link) => readOnly([[link, false]], () => fs.symlink(target, link)),
+    hold: (p, held, open, handle) => {
+      if (handle !== void 0 && snapshots.delete(handle)) return void 0;
+      if (!held) return fs.hold?.(p, held, open, handle);
+      return via(p, snapshot, () => fs.hold?.(p, held, open) ?? late(p));
     },
-    rename: (from, to) => {
-      if (inProc(from) || inProc(to)) throw syncError("EROFS", from);
-      fs.rename(from, to);
+    kept: (handle) => snapshots.has(handle) || fs.kept?.(handle) === true,
+    pinned: (handle) => {
+      const bytes = snapshots.get(handle);
+      return bytes ? frozen(bytes) : fs.pinned?.(handle) ?? fs;
     },
-    hold: (p, ...rest2) => inProc(p) ? void 0 : fs.hold?.(p, ...rest2),
     ...fs.pread ? {
-      pread: (p, at, n, version) => inProc(p) ? tree.read(p).subarray(at, at + n) : fs.pread(p, at, n, version)
+      pread: (p, at, n, version) => via(
+        p,
+        (q) => tree.read(q).subarray(at, at + n),
+        () => fs.pread(p, at, n, version)
+      )
     } : {}
   };
-  for (const name2 of READ_ONLY) {
-    const fn = fs[name2];
-    if (!fn) continue;
-    over[name2] = (p, ...rest2) => {
-      if (inProc(p)) throw syncError("EROFS", p);
-      return fn.call(fs, p, ...rest2);
-    };
+  for (const [names, follow2] of [
+    [FOLLOWING, true],
+    [NOT_FOLLOWING, false]
+  ]) {
+    for (const name2 of names) {
+      const fn = fs[name2];
+      if (!fn) continue;
+      over[name2] = (p, ...rest2) => readOnly([[p, follow2]], () => fn.call(fs, p, ...rest2));
+    }
   }
   return new Proxy(fs, {
     get: (target, key, receiver) => key in over ? over[key] : Reflect.get(target, key, receiver)
   });
 }
-var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, READ_ONLY;
+var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, FOLLOWING, NOT_FOLLOWING, MAX_HOPS2;
 var init_wasi_procfs = __esm({
   "src/process/wasi/wasi-procfs.ts"() {
     "use strict";
     init_sync_fs_wire();
     init_process_fds();
     init_procfs();
+    init_wasi_files();
     DIR_MODE3 = 16749;
     FILE_MODE2 = 33060;
     LINK_MODE3 = 41471;
@@ -6964,20 +7105,9 @@ var init_wasi_procfs = __esm({
         }
       }
     };
-    READ_ONLY = [
-      "writeFile",
-      "mkdir",
-      "rm",
-      "unlink",
-      "rmdir",
-      "symlink",
-      "chmod",
-      "utimes",
-      "lutimes",
-      "create",
-      "pwrite",
-      "truncate"
-    ];
+    FOLLOWING = ["writeFile", "chmod", "utimes", "pwrite", "truncate"];
+    NOT_FOLLOWING = ["mkdir", "rm", "unlink", "rmdir", "lutimes", "create"];
+    MAX_HOPS2 = 40;
   }
 });