@ai-ecoverse/slicc-kernel 1.62.0 → 1.62.1

package/dist/node.js

@@ -6740,9 +6740,37 @@ async function holdOp(entry, path, req) {
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
 }
+var IDENTITY_OPS = /* @__PURE__ */ new Set([
+  "write",
+  "pwrite",
+  "truncate",
+  "chmod",
+  "utimes",
+  "chown",
+  "lchown"
+]);
 async function dispatchSyncFs(req) {
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
+  if (!req.identity || !IDENTITY_OPS.has(req.op)) return dispatchOne(entry, req);
+  const { fs, cwd } = entry;
+  const path = fs.resolvePath(cwd, req.path);
+  const identified = async (held) => {
+    const own = held ? { ...entry, fs: { ...fs, writeFile: held.writeFile } } : entry;
+    const result = await dispatchOne(own, req);
+    if (!result.ok) return result;
+    if (held && !held.direct) return json2(null);
+    const look = req.op === "lchown" ? fs.lstat : fs.stat;
+    const st = await look.call(fs, path).catch(() => void 0);
+    return json2(st ? statJson(st) : null);
+  };
+  try {
+    return await (fs.exclusive ? fs.exclusive(path, identified, req.op !== "lchown") : identified());
+  } catch (err) {
+    return toErrno(err);
+  }
+}
+async function dispatchOne(entry, req) {
   const { fs, cwd } = entry;
   try {
     const path = fs.resolvePath(cwd, req.path);
@@ -10090,7 +10118,9 @@ var VfsNode = class {
       this.ranged = new AsyncRangedFile(io, this.path, this.pin.size, this.pin.version);
       return this.ranged;
     }
-    const st = io && !this.orphaned ? await this.fs.stat?.(this.path).catch(() => void 0) : void 0;
+    const at = this.path;
+    const st = io && !this.orphaned ? await this.fs.stat?.(at).catch(() => void 0) : void 0;
+    this.note(at, st);
     if (io && st?.ranged) {
       this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0, st.version);
       return this.ranged;
@@ -10150,12 +10180,23 @@ var VfsNode = class {
     const stat = this.fs.stat?.bind(this.fs);
     if (!stat || this.orphaned) return Promise.resolve(void 0);
     const parent = this.path.slice(0, this.path.lastIndexOf("/")) || "/";
-    this.cap ??= stat(this.path).catch(() => stat(parent)).then(
+    const at = this.path;
+    this.cap ??= stat(at).then((st) => {
+      this.note(at, st);
+      return st;
+    }).catch(() => stat(parent)).then(
       (st) => st.maxFile,
       () => void 0
     );
     return this.cap;
   }
+  seen;
+  note(path, st) {
+    if (st?.ino !== void 0) this.seen = { path, ino: st.ino };
+  }
+  known() {
+    return this.seen?.path === this.path && !this.orphaned ? this.seen.ino : void 0;
+  }
   async fits(end) {
     const max = await this.limit();
     if (max !== void 0 && end > max) throw new KernelError("EFBIG");
@@ -10469,6 +10510,18 @@ async function refuseReadonly(fs, path, flags, opts = {}) {
 function keepingOpen(fs, nodes) {
   return {
     ...fs,
+    async exclusive(path, run2, follow2 = true) {
+      const at = fs.resolvePath("/", path);
+      const key = follow2 ? nodes.targetKey(at) : nodes.entryKey(at);
+      const locked = await key.catch(() => at);
+      return nodes.onEntry(
+        locked,
+        () => run2({
+          writeFile: (p, content, owner) => fs.writeFile(p, content, owner),
+          direct: locked === at
+        })
+      );
+    },
     async rm(path, options) {
       const at = await nodes.entryKey(fs.resolvePath("/", path));
       await nodes.unlinking(at);
@@ -10561,6 +10614,7 @@ function vfsFile(fs, opts, nodes) {
       size: await node.size(),
       ...node.orphaned ? { orphan: true } : {}
     })),
+    known: () => node.known(),
     flush: () => serial(() => node.flush()),
     close: () => node.serial(async () => {
       try {
@@ -10955,6 +11009,20 @@ var WasmProcess = class {
     }
     return fd;
   }
+  async identified(stat, known) {
+    const first = await stat();
+    if (first.orphan) return first;
+    const ino = known?.();
+    if (ino !== void 0) return { ...first, ino };
+    const { fs } = this.options;
+    const look = async () => {
+      const now = await stat();
+      if (now.path !== first.path || now.orphan) return now;
+      const st = await fs.stat?.(now.path).catch(() => void 0);
+      return st?.ino === void 0 ? now : { ...now, ino: st.ino };
+    };
+    return fs.exclusive ? fs.exclusive(first.path, look) : look();
+  }
   newOwner() {
     if (!this.options.owners) return void 0;
     return { uid: this.cred.euid, gid: this.cred.egid, mode: 438 & ~this.umask };
@@ -11116,7 +11184,11 @@ var WasmProcess = class {
         await file.resize(req.size);
         return { ok: true, kind: "void" };
       case "fd-vfs-stat":
-        return { ok: true, kind: "json", json: await file.stat() };
+        return {
+          ok: true,
+          kind: "json",
+          json: req.identity ? await this.identified(file.stat.bind(file), file.known?.bind(file)) : await file.stat()
+        };
     }
   }
   keptPath;