@ai-ecoverse/slicc-kernel 1.124.2 → 1.124.4

package/dist/node.js

@@ -4112,6 +4112,8 @@ var ProtectedFs = class {
 // src/fs/remote.ts
 var ANNOUNCE_WAIT_MS = 500;
 var PRUNE_EVERY_MS = 3e4;
+var MOURN_TRIES = 5;
+var MOURN_RETRY_MS = 100;
 function lockManager() {
   return globalThis.navigator?.locks;
 }
@@ -4120,6 +4122,7 @@ var RemoteWatch = class {
   name;
   tab = crypto.randomUUID();
   peers = /* @__PURE__ */ new Set();
+  mourned = /* @__PURE__ */ new Set();
   others = /* @__PURE__ */ new Map();
   union = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
@@ -4188,8 +4191,7 @@ var RemoteWatch = class {
   receive(data) {
     if (data.hello !== void 0) this.greeted(data.hello);
     if (data.here !== void 0 && data.to === this.tab) {
-      this.peers.add(data.here);
-      this.recount();
+      this.arrived(data.here);
       this.met?.();
     }
     if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
@@ -4198,9 +4200,36 @@ var RemoteWatch = class {
     }
     if (data.changed !== void 0) this.emit({ paths: data.changed, trees: [] });
   }
-  greeted(peer) {
+  arrived(peer) {
     this.peers.add(peer);
     this.recount();
+    void this.mourn(peer);
+  }
+  async mourn(peer, tries = MOURN_TRIES) {
+    if (!this.locks || this.mourned.has(peer)) return;
+    this.mourned.add(peer);
+    const name2 = this.lockOf(peer);
+    const { held = [], pending = [] } = await this.locks.query();
+    if (![...held, ...pending].some((lock) => lock.name === name2)) {
+      this.mourned.delete(peer);
+      if (tries > 1 && this.peers.has(peer)) {
+        setTimeout(() => void this.mourn(peer, tries - 1), MOURN_RETRY_MS);
+      }
+      return;
+    }
+    void this.locks.request(name2, async () => {
+      this.mourned.delete(peer);
+      this.others.delete(peer);
+      this.peers.delete(peer);
+      this.rebuild();
+      this.recount();
+      for (const wait2 of this.waiting.values()) {
+        if (wait2.left.delete(peer) && wait2.left.size === 0) wait2.done();
+      }
+    });
+  }
+  greeted(peer) {
+    this.arrived(peer);
     const answer = () => {
       this.channel.postMessage({ here: this.tab, to: peer });
       if (this.mine.length > 0) void this.announce(this.mine);
@@ -4210,8 +4239,7 @@ var RemoteWatch = class {
   }
   announced({ tab, paths, seq: seq2 }) {
     const from = tab;
-    this.peers.add(from);
-    this.recount();
+    this.arrived(from);
     if (paths.length > 0) this.others.set(from, paths);
     else this.others.delete(from);
     this.rebuild();
@@ -4819,7 +4847,8 @@ var OpfsFs = class {
   async linkAlong(path) {
     for (const entry of await this.meta.get(prefixes(path))) {
       if (entry?.link === void 0) continue;
-      if (!await this.real(entry.path) && await this.real(parentOf4(entry.path))) return entry;
+      if (entry.path !== path && await this.real(entry.path)) continue;
+      if (await this.real(parentOf4(entry.path))) return entry;
     }
     return void 0;
   }
@@ -5796,15 +5825,21 @@ var UnlinkedKeeper = class {
     };
     const unreplaced = async (path, op) => {
       const at = fs.resolvePath("/", path);
+      const pending = async () => {
+        for (let p = at; replacing.size > 0; p = parentOf5(p)) {
+          await replacing.get(p)?.done;
+          if (p === "/") return;
+        }
+      };
       for (let attempt = 1; ; attempt++) {
-        await replacing.get(at)?.done;
+        await pending();
         const seen = keeper.replaced;
         try {
           return await op();
         } catch (err) {
           const code = err?.code;
           if (attempt >= 3 || code !== "ENOENT") throw err;
-          await replacing.get(at)?.done;
+          await pending();
           if (keeper.replaced === seen) throw err;
         }
       }
@@ -5829,9 +5864,11 @@ var UnlinkedKeeper = class {
       lstat: (path) => unreplaced(path, async () => counted3(await fs.lstat(path))),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
-        const pinned = await keeper.pin(target);
-        if (pinned.moved.has(target)) pinned.commit();
-        else await keeper.settle(pinned, () => fs.rm(path, options));
+        await replace(target, async (gated) => {
+          const pinned = await keeper.pin(target, gated);
+          if (pinned.moved.has(target)) pinned.commit();
+          else await keeper.settle(pinned, () => fs.rm(path, options));
+        });
       },
       async rename(from, to) {
         const target = fs.resolvePath("/", to);
@@ -5866,9 +5903,22 @@ var UnlinkedKeeper = class {
     return held;
   }
   async pin(target, gated = () => void 0) {
-    const paths = [...this.heldWithin(target).keys()].sort();
+    const paths = [];
     const releases = [];
-    for (const path of paths) releases.push(await this.gate.acquire(path));
+    for (; ; ) {
+      const fresh2 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
+      if (fresh2.length === 0) break;
+      fresh2.sort();
+      if (paths.some((path) => path > fresh2[0])) {
+        for (const release of releases.splice(0)) release();
+        fresh2.push(...paths.splice(0));
+        fresh2.sort();
+      }
+      for (const path of fresh2) {
+        paths.push(path);
+        releases.push(await this.gate.acquire(path));
+      }
+    }
     gated();
     const now = this.heldWithin(target);
     const held = new Map(
@@ -6541,7 +6591,7 @@ var CdpFacade = class {
     for (const conn of this.connections) conn.close();
   }
   async acceptLoop() {
-    const served = /* @__PURE__ */ new Set();
+    const served2 = /* @__PURE__ */ new Set();
     for (; ; ) {
       let conn;
       try {
@@ -6549,10 +6599,10 @@ var CdpFacade = class {
       } catch {
         break;
       }
-      const done4 = this.serve(conn).finally(() => served.delete(done4));
-      served.add(done4);
+      const done4 = this.serve(conn).finally(() => served2.delete(done4));
+      served2.add(done4);
     }
-    await Promise.allSettled([...served]);
+    await Promise.allSettled([...served2]);
   }
   async serve(conn) {
     this.connections.add(conn);
@@ -6944,7 +6994,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.124.4" : "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
@@ -8359,7 +8409,7 @@ var RealmProxy = class {
     for (const conn of this.connections) conn.close();
   }
   async acceptLoop() {
-    const served = /* @__PURE__ */ new Set();
+    const served2 = /* @__PURE__ */ new Set();
     try {
       for (; ; ) {
         await this.slots.acquire(1, this.stop.signal);
@@ -8372,13 +8422,13 @@ var RealmProxy = class {
         }
         const done4 = this.serve(conn).finally(() => {
           this.slots.release(1);
-          served.delete(done4);
+          served2.delete(done4);
         });
-        served.add(done4);
+        served2.add(done4);
       }
     } catch {
     }
-    await Promise.allSettled([...served]);
+    await Promise.allSettled([...served2]);
   }
   async serve(conn) {
     this.connections.add(conn);
@@ -12110,7 +12160,12 @@ var IDENTITY_OPS = /* @__PURE__ */ new Set([
   "chown",
   "lchown"
 ]);
+var served = 0;
+function servedFsCalls() {
+  return served;
+}
 async function dispatchSyncFs(req) {
+  served++;
   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);
@@ -12819,6 +12874,8 @@ var SYS_TREE = {
     slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0} ${listing.wasm?.source ?? "none"}
 `,
     slicc_shared_root: (listing) => `${listing.peers ?? 0}
+`,
+    slicc_fs_calls: (listing) => `${listing.fsCalls ?? 0}
 `
   }
 };
@@ -23122,7 +23179,7 @@ async function openHostfs(spec, connect2, timing = {}) {
     ...active?.capabilities.ranges === true ? { ranges: true } : {},
     ...active ? { maxIo: Math.min(active.maxIo, HOSTFS_IO) } : {}
   });
-  const served = serveFilesystem(
+  const served2 = serveFilesystem(
     port2,
     { ...slot2.handlers, mount: ranged2 },
     {
@@ -23139,12 +23196,12 @@ async function openHostfs(spec, connect2, timing = {}) {
       up(client) {
         active = timed(client, timing.callMs ?? HOSTFS_CALL_MS);
         slot2.insert(client, handlers);
-        served.invalidate(true);
+        served2.invalidate(true);
       },
-      event: (event) => served.invalidate(invalidation(event)),
+      event: (event) => served2.invalidate(invalidation(event)),
       down() {
         slot2.eject();
-        served.invalidate(true);
+        served2.invalidate(true);
       },
       ...timing
     },
@@ -25322,7 +25379,8 @@ var Launcher = class {
         load: this.loadAverage(),
         cpu: this.cpuTotal(),
         wasm: this.memories.count(),
-        peers: Number(this.locks.shared?.() === true)
+        peers: Number(this.locks.shared?.() === true),
+        fsCalls: servedFsCalls()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -25816,7 +25874,7 @@ var Launcher = class {
     const worker = this.createDriverWorker();
     const driver = new MessageChannel();
     const client = new MessageChannel();
-    const served = serveClient(client.port1, {
+    const served2 = serveClient(client.port1, {
       launcher: async () => this,
       scope: "transport"
     });
@@ -25828,7 +25886,7 @@ var Launcher = class {
       port: driver.port1,
       dispose: () => {
         worker.terminate();
-        served.detach();
+        served2.detach();
         driver.port1.close();
       },
       onCrash: (listener) => worker.addEventListener("error", (event) => {
@@ -25842,12 +25900,12 @@ var Launcher = class {
     const ask = (handle) => this.onMountPending?.({ target, source, ...handle ? { handle } : {} });
     const { port1, port2 } = new MessageChannel();
     const medium = removableMedium((handle) => {
-      served.invalidate(true);
+      served2.invalidate(true);
       ask(handle);
     });
-    const served = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
+    const served2 = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
     const id2 = source.slice("fsa:".length);
-    this.removable.set(target, { id: id2, medium, served });
+    this.removable.set(target, { id: id2, medium, served: served2 });
     const stored = this.inserted.get(id2) ?? await this.media.get(id2);
     if (stored && await granted(stored)) medium.insert(stored);
     else ask(stored);
@@ -27906,14 +27964,14 @@ async function createNodeKernel(options = {}) {
         throw fsError("ENOENT", `no user ${String(user)}`);
       }
       const { port1, port2 } = new MessageChannel2();
-      const served = serveClient(port1, {
+      const served2 = serveClient(port1, {
         launcher: async () => launcher,
         signal: signalNumber,
         ...user !== void 0 ? { user } : {},
         ...tag !== void 0 ? { tag } : {}
       });
-      clients.add(served);
-      void served.closed.then(() => clients.delete(served));
+      clients.add(served2);
+      void served2.closed.then(() => clients.delete(served2));
       return port2;
     },
     terminate() {