@ai-ecoverse/slicc-kernel 1.84.0 → 1.85.0

package/dist/kernel-worker.js

@@ -117,6 +117,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);
   }
@@ -136,6 +139,8 @@ function settle(transaction, value) {
     transaction.onabort = () => reject(transaction.error ?? new Error("metadata transaction aborted"));
   });
 }
+var REMOVE_BATCH = 256;
+var REMOVE_WAIT_MS = 5;
 var IndexedDbMeta = class {
   db;
   cache = new PathMap();
@@ -171,6 +176,7 @@ var IndexedDbMeta = class {
   async get(paths) {
     const missing4 = paths.filter((path) => !this.cache.has(path));
     if (missing4.length > 0) {
+      this.settleRemoves();
       const generation = this.generation;
       const [transaction, store] = this.transaction("readonly");
       const found = /* @__PURE__ */ new Map();
@@ -188,6 +194,7 @@ var IndexedDbMeta = class {
     return paths.map((path) => this.cache.get(path) ?? void 0);
   }
   async update(path, change) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readwrite");
     const request2 = store.get(path);
     let next2;
@@ -201,6 +208,7 @@ var IndexedDbMeta = class {
     this.cache.set(path, next2 ?? null);
   }
   async move(from, to, root) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readwrite");
     store.delete(to);
     store.delete(descendants(to));
@@ -217,7 +225,28 @@ var IndexedDbMeta = class {
     await settle(transaction, () => void 0);
     this.changed({ trees: [from, to] });
   }
+  absent(path) {
+    return this.cache.has(path) && this.cache.get(path) === null;
+  }
+  removing = /* @__PURE__ */ new Map();
+  removeTimer;
   async remove(paths) {
+    this.settleRemoves();
+    return this.removeNow(paths);
+  }
+  async removeFile(path) {
+    const known = this.cache.get(path);
+    if (!known) return this.remove([path]);
+    this.generation++;
+    this.cache.set(path, null);
+    this.removing.set(path, JSON.stringify(known));
+    if (this.removing.size >= REMOVE_BATCH) return this.flushRemoves();
+    this.removeTimer ??= setTimeout(
+      () => void this.flushRemoves().catch(() => void 0),
+      REMOVE_WAIT_MS
+    );
+  }
+  async removeNow(paths) {
     const [transaction, store] = this.transaction("readwrite");
     for (const path of paths) {
       store.delete(path);
@@ -226,12 +255,33 @@ var IndexedDbMeta = class {
     await settle(transaction, () => void 0);
     this.changed({ trees: paths });
   }
+  settleRemoves() {
+    if (this.removing.size > 0) void this.flushRemoves().catch(() => void 0);
+  }
+  flushRemoves() {
+    clearTimeout(this.removeTimer);
+    this.removeTimer = void 0;
+    const batch = this.removing;
+    if (batch.size === 0) return Promise.resolve();
+    this.removing = /* @__PURE__ */ new Map();
+    const [transaction, store] = this.transaction("readwrite");
+    for (const [path, seen] of batch) {
+      const request2 = store.get(path);
+      request2.onsuccess = () => {
+        if (request2.result && JSON.stringify(request2.result) === seen) store.delete(path);
+      };
+    }
+    const paths = [...batch.keys()];
+    return settle(transaction, () => void this.channel.postMessage({ paths }));
+  }
   async links(dir) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readonly");
     const request2 = store.index("dir").getAll(dir);
     return settle(transaction, () => request2.result);
   }
   async under(path) {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readonly");
     const self = store.get(path);
     const below = store.getAll(descendants(path));
@@ -243,6 +293,7 @@ var IndexedDbMeta = class {
     );
   }
   async all() {
+    this.settleRemoves();
     const [transaction, store] = this.transaction("readonly");
     const request2 = store.getAll();
     return settle(transaction, () => request2.result);
@@ -806,7 +857,14 @@ function sidecar(meta) {
   const guarded2 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
     throw translate(err, pathOf(args), "sidecar", false);
   });
-  return Object.fromEntries(META_OPS.map((op) => [op, guarded2(op)]));
+  const ops = Object.fromEntries(META_OPS.map((op) => [op, guarded2(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;
@@ -1503,6 +1561,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 {
@@ -1513,8 +1572,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(parentOf3(found.path));
+        return;
+      }
+      if (file && this.meta.removeFile) {
+        await this.meta.removeFile(found.path);
+        this.touch(parentOf3(found.path));
+        return;
+      }
     }
     await this.meta.remove([found.path]);
     this.touch(parentOf3(found.path));
@@ -8634,6 +8704,10 @@ var MountTable = class {
       ...error ? { error } : {}
     });
   }
+  under(path) {
+    for (const mount of this.mounts.values()) if (within6(mount.target, path)) return true;
+    return false;
+  }
   locate(path) {
     let best;
     for (const mount of this.mounts.values()) {
@@ -9203,9 +9277,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);
@@ -9216,16 +9293,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);
@@ -9529,8 +9623,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);
@@ -9764,6 +9857,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 {
@@ -9773,6 +9886,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` };