@ai-ecoverse/slicc-kernel 1.147.4 → 1.147.6

package/dist/node.js

@@ -3305,7 +3305,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.147.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.147.6" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -6913,13 +6913,14 @@ var FsWatchers = class {
       this.watchers.delete(watcher);
     };
   }
-  typedWatch(root, recursive, alias) {
+  typedWatch(root, recursive, alias, directory = recursive) {
     const main = normalizePath(root);
     const other = alias === void 0 ? main : normalizePath(alias);
     const watch = {
       roots: other === main ? [main] : [main, other],
       names: /* @__PURE__ */ new Map(),
       recursive,
+      directory,
       notes: [],
       overflowed: false,
       ended: false,
@@ -7007,6 +7008,19 @@ var FsWatchers = class {
         if (!followed2.has(watch)) route(watch, "rename", at, seq2);
     }
   }
+  heard(type, paths) {
+    if (this.typed.size === 0) return;
+    for (const path of paths) {
+      const at = normalizePath(path);
+      const seq2 = ++this.seq;
+      for (const watch of [...this.typed]) {
+        if (type === "rename" && watch.roots.some((root) => at === root || under2(root, at)))
+          continue;
+        if (type === "change" && watch.directory && watch.roots.includes(at)) continue;
+        route(watch, type, at, seq2);
+      }
+    }
+  }
   changed(...paths) {
     this.report(paths);
     this.emit("change", paths);
@@ -18255,6 +18269,17 @@ var VfsNode = class {
     this.queue = next3.catch(() => void 0);
     return next3;
   }
+  named = 0;
+  byName(op) {
+    return this.serial(async () => {
+      this.named++;
+      try {
+        return await op();
+      } finally {
+        this.named--;
+      }
+    });
+  }
   revoke() {
     this.revoked = true;
     clearTimeout(this.writeBack);
@@ -18262,7 +18287,7 @@ var VfsNode = class {
     this.data = void 0;
     this.ranged = void 0;
   }
-  async prepare() {
+  async prepare(onFd = this.named === 0) {
     if (this.revoked) throw new KernelError("EIO");
     if (this.ranged || this.data) return this.ranged;
     const io = rangedOps(this.fs);
@@ -18277,15 +18302,15 @@ var VfsNode = class {
       this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0, st.version);
       return this.ranged;
     }
-    await this.load();
+    await this.load(onFd);
     return void 0;
   }
   async keep() {
-    const ranged2 = await this.prepare();
-    if (ranged2) await this.followed(() => ranged2.pin());
+    const ranged2 = await this.prepare(false);
+    if (ranged2) await this.followed(() => ranged2.pin(), false);
   }
   moving = /* @__PURE__ */ new Set();
-  async followed(op) {
+  async followed(op, onFd = this.named === 0) {
     for (; ; ) {
       const at = this.path;
       try {
@@ -18293,11 +18318,11 @@ var VfsNode = class {
       } catch (err) {
         if (!isMissing(err)) throw err;
         while (this.moving.size > 0) await Promise.all(this.moving);
-        if (this.path === at) throw err;
+        if (this.path === at) throw onFd && !this.made ? new KernelError("EIO") : err;
       }
     }
   }
-  async load() {
+  async load(onFd = this.named === 0) {
     if (this.revoked) throw new KernelError("EIO");
     while (!this.data) {
       const at = this.path;
@@ -18307,7 +18332,7 @@ var VfsNode = class {
         if (!isMissing(err)) throw err;
         while (this.moving.size > 0) await Promise.all(this.moving);
         if (this.path !== at) continue;
-        if (!this.made) throw new KernelError("ENOENT");
+        if (!this.made) throw new KernelError(onFd ? "EIO" : "ENOENT");
         this.data = new Uint8Array(0);
         this.missing = true;
       }
@@ -18812,7 +18837,7 @@ function heldIo(fs, nodes, changed) {
   const write = async (path, op, fallback) => {
     const held = await node(path);
     if (!held) return fallback();
-    const out = await held.serial(async () => {
+    const out = await held.byName(async () => {
       const done4 = await op(held);
       await held.flush();
       return done4;
@@ -18844,22 +18869,22 @@ function heldIo(fs, nodes, changed) {
     async stat(path) {
       const st = await fs.stat(path);
       const held = st.isFile ? await node(path) : void 0;
-      return held ? { ...st, size: await held.serial(() => held.size()) } : st;
+      return held ? { ...st, size: await held.byName(() => held.size()) } : st;
     },
     async lstat(path) {
       const st = await fs.lstat(path);
       const held = st.isFile && !st.isSymbolicLink ? await node(path) : void 0;
-      return held ? { ...st, size: await held.serial(() => held.size()) } : st;
+      return held ? { ...st, size: await held.byName(() => held.size()) } : st;
     },
     async readFileBuffer(path) {
       const held = await node(path);
       if (!held) return fs.readFileBuffer(path);
-      return held.serial(async () => held.pread(await held.size(), 0));
+      return held.byName(async () => held.pread(await held.size(), 0));
     },
     ...ranged2 ? {
       pread: async (path, at, n, version) => {
         const held = await node(path);
-        return held ? held.serial(() => held.pread(n, at)) : ranged2.pread(path, at, n, version);
+        return held ? held.byName(() => held.pread(n, at)) : ranged2.pread(path, at, n, version);
       },
       pwrite: (path, at, bytes, transfer) => write(
         path,
@@ -18912,7 +18937,7 @@ function keepingOpen(fs, nodes, changed = () => {
       const held = await heldAt(fs, nodes, at);
       if (!held) return nodes.onEntry(at, () => fs.writeFile(path, content, owner));
       const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
-      return held.serial(async () => {
+      return held.byName(async () => {
         await held.truncate(0);
         await held.pwrite(bytes, 0);
         await held.flush();
@@ -21784,7 +21809,7 @@ var RemoteWatch = class {
     if (data.ack !== void 0 && data.to === this.tab && data.from !== void 0) {
       this.acked(data.ack, data.from);
     }
-    if (data.changed !== void 0) this.emit({ paths: data.changed, trees: [] });
+    if (data.changed !== void 0) this.emit({ paths: data.changed, trees: [], content: true });
   }
   arrived(peer) {
     this.peers.add(peer);
@@ -23402,6 +23427,18 @@ var Extent = class {
 };
 var LOCKED = /* @__PURE__ */ new Set(["NotReadableError", "NoModificationAllowedError", "InvalidStateError"]);
 var SYNC_BACKOFF_MS = [5, 10, 20, 40, 80];
+async function unlocked(name2, op) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await op();
+    } catch (err) {
+      if (!LOCKED.has(err?.name)) throw err;
+      const delay = SYNC_BACKOFF_MS[attempt];
+      if (delay === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+    }
+  }
+}
 async function openSync(handle) {
   const sync = handle.createSyncAccessHandle;
   if (!sync) return void 0;
@@ -23524,7 +23561,12 @@ var OpfsFs = class {
       meta.listen?.((c) => {
         for (const path of [...c.paths ?? [], ...c.trees ?? []]) this.forget(path);
         const moved2 = movedOf(c.moved);
-        remote?.emit({ paths: c.paths ?? [], trees: c.trees ?? [], ...moved2 ? { moved: moved2 } : {} });
+        remote?.emit({
+          paths: c.paths ?? [],
+          trees: c.trees ?? [],
+          content: true,
+          ...moved2 ? { moved: moved2 } : {}
+        });
       });
       remote?.listen((c) => {
         for (const path of [...c.paths, ...c.trees]) this.forget(path);
@@ -24592,7 +24634,10 @@ var OpfsFs = class {
       try {
         await this.inDir(
           dir,
-          (parent) => this.io(parent.removeEntry(name2, { recursive: options.recursive === true }))
+          (parent) => unlocked(
+            name2,
+            () => this.io(parent.removeEntry(name2, { recursive: options.recursive === true }))
+          )
         );
       } catch (err) {
         throw translate(err, path);
@@ -28284,6 +28329,8 @@ var Launcher = class {
       this.changes.flush();
       this.cwds.touched(change.paths, change.trees);
       this.rewritten(change.paths, change.trees);
+      this.watchers.heard(change.content ? "change" : "rename", change.paths);
+      this.watchers.heard("rename", change.trees ?? []);
     });
     const holders = [this.held, this.openFiles];
     this.unlinked = new UnlinkedKeeper(
@@ -29962,7 +30009,12 @@ var Launcher = class {
         if (g) await readable(g, "watch", at);
         const st = await this.fs.stat(at);
         const real = await this.fs.realpath?.(at, true).catch(() => at) ?? at;
-        const watch = this.watchers.typedWatch(real, recursive && st.isDirectory, at);
+        const watch = this.watchers.typedWatch(
+          real,
+          recursive && st.isDirectory,
+          at,
+          st.isDirectory
+        );
         if (!g || g.cred.euid === 0) return watch;
         return visibleTo(watch, real, async (dir) => {
           const walked = await access(g.fs, g.cred, dir, R_OK | X_OK, { directory: true });