@ai-ecoverse/slicc-kernel 1.84.0 → 1.85.0

package/dist/node.js

@@ -3022,6 +3022,9 @@ var MemoryMeta = class {
   async remove(paths) {
     for (const path of paths) this.entries.deleteTree(path);
   }
+  absent(path) {
+    return !this.entries.has(path);
+  }
   async links(dir) {
     return [...this.entries.entries()].map(([, e]) => e).filter((entry) => entry.dir === dir);
   }
@@ -3470,7 +3473,14 @@ function sidecar(meta) {
   const guarded3 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
     throw translate(err, pathOf(args), "sidecar", false);
   });
-  return Object.fromEntries(META_OPS.map((op) => [op, guarded3(op)]));
+  const ops = Object.fromEntries(META_OPS.map((op) => [op, guarded3(op)]));
+  if (meta.absent) ops.absent = meta.absent.bind(meta);
+  const { removeFile } = meta;
+  if (removeFile)
+    ops.removeFile = (path) => removeFile.call(meta, path).catch((err) => {
+      throw translate(err, path, "sidecar", false);
+    });
+  return ops;
 }
 function missing2(err) {
   const code = err?.code;
@@ -4163,6 +4173,7 @@ var OpfsFs = class {
       throw error;
     }
     this.refuse(found.path, true);
+    if (options.file && found.handle?.kind === "directory") throw fsError("EISDIR", path);
     if (found.handle) {
       const [dir, name2] = await this.parent(found.path);
       try {
@@ -4173,8 +4184,19 @@ var OpfsFs = class {
       } catch (err) {
         throw translate(err, path);
       }
-      this.changed(found.path);
+      const file = found.handle.kind === "file";
+      if (!file || this.remote?.watched()) this.changed(found.path);
+      else this.forget(found.path);
       this.movePending(found.path);
+      if (file && this.meta.absent?.(found.path)) {
+        this.touch(parentOf4(found.path));
+        return;
+      }
+      if (file && this.meta.removeFile) {
+        await this.meta.removeFile(found.path);
+        this.touch(parentOf4(found.path));
+        return;
+      }
     }
     await this.meta.remove([found.path]);
     this.touch(parentOf4(found.path));
@@ -6999,6 +7021,10 @@ var MountTable = class {
       ...error ? { error } : {}
     });
   }
+  under(path) {
+    for (const mount of this.mounts.values()) if (within5(mount.target, path)) return true;
+    return false;
+  }
   locate(path) {
     let best;
     for (const mount of this.mounts.values()) {
@@ -7568,9 +7594,12 @@ var MountFs = class {
   }
   async rm(path, options = {}) {
     const found = this.at(path);
+    if (!found && options.recursive && this.table.under(normalizePath(path)))
+      return this.rmAround(normalizePath(path), options);
     if (!found) return this.base.rm(path, options);
     const { mount, rel: rel2 } = found;
     const real = normalizePath(path);
+    if (rel2 === "/" && options.recursive) await this.rmEach(real, mount, rel2, options);
     if (rel2 === "/") throw errnoError("EBUSY", `${real} is a mount point`);
     this.writable(mount, real);
     await this.table.commitUnder(real);
@@ -7581,16 +7610,33 @@ var MountFs = class {
       if (options.force && err.code === "ENOENT") return;
       throw err;
     }
+    if (options.file && attr2.kind === "directory") throw errnoError("EISDIR", real);
     this.table.forget(mount, real);
     if (attr2.kind === "directory" && options.recursive) {
-      for (const entry of await this.table.readdir(mount, real, rel2)) {
-        await this.rm(`${real}/${entry.name}`, { recursive: true, force: options.force ?? false });
-      }
+      await this.rmEach(real, mount, rel2, { recursive: true, force: options.force ?? false });
       this.table.forget(mount, real);
     }
     await mount.conn.call({ op: attr2.kind === "directory" ? "rmdir" : "unlink", path: rel2 });
     this.table.forget(mount, real);
   }
+  async rmEach(real, mount, rel2, options) {
+    let first;
+    for (const entry of await this.table.readdir(mount, real, rel2)) {
+      await this.rm(joinName(real, entry.name), options).catch((err) => {
+        first ??= err;
+      });
+    }
+    if (first) throw first;
+  }
+  async rmAround(path, options) {
+    let first;
+    for (const name2 of await this.base.readdir(path)) {
+      await this.rm(joinName(path, name2), options).catch((err) => {
+        first ??= err;
+      });
+    }
+    throw first ?? errnoError("EBUSY", `${path} holds a mount point`);
+  }
   async rename(from, to) {
     const a = this.at(from);
     const b = this.at(to);
@@ -7894,8 +7940,7 @@ async function run(entry, path, req) {
       await fs.link(path, fs.resolvePath(cwd, req.arg2 ?? ""), req.mode === 1);
       return done;
     case "unlink":
-      if ((await fs.lstat(path)).isDirectory) throw syncError("EISDIR", path);
-      await fs.rm(path);
+      await fs.rm(path, { file: true });
       return done;
     case "rmdir":
       if (!(await fs.lstat(path)).isDirectory) throw syncError("ENOTDIR", path);
@@ -8129,6 +8174,26 @@ async function dispatchSyncFs(req) {
     return toErrno(err);
   }
 }
+var DENIED = /* @__PURE__ */ new Set(["EACCES", "EPERM"]);
+async function rmPermitted(entry, path, req, refused2) {
+  const st = await entry.fs.lstat(path).catch(() => void 0);
+  if (!st?.isDirectory) return refused2;
+  const unlisted = await guarded(entry, path, { ...req, op: "readdir" });
+  if (unlisted) return unlisted;
+  const names = await entry.fs.readdir(path).catch(() => void 0);
+  if (!names) return refused2;
+  let first;
+  for (const name2 of names) {
+    const child = await dispatchOne(entry, {
+      ...req,
+      path: joinName(path, name2)
+    });
+    if (!child.ok) first ??= child;
+  }
+  if (first) return first;
+  const again = await guarded(entry, path, req);
+  return again ?? await run(entry, path, req);
+}
 async function dispatchOne(entry, req) {
   const { fs, cwd } = entry;
   try {
@@ -8138,6 +8203,9 @@ async function dispatchOne(entry, req) {
     if (req.op === "access") return await accessOp(entry, path, req);
     if (req.op === "hold") return await holdOp(entry, path, req);
     const refused2 = await guarded(entry, path, req);
+    if (refused2 && req.op === "rm" && !refused2.ok && DENIED.has(refused2.errno)) {
+      return await rmPermitted(entry, path, req, refused2);
+    }
     if (refused2) return refused2;
     if (req.op === "statfs") return json2(await usageAt(entry, path) ?? await storageUsage());
     if (entry.revoked?.(path)) return { ok: false, errno: "EIO", message: `${path} was unmounted` };