@ai-ecoverse/slicc-kernel 1.164.3 → 1.164.5

package/dist/node.js

@@ -3684,7 +3684,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.164.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.164.5" : "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
@@ -4771,7 +4771,7 @@ var UnlinkedKeeper = class {
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
         const kept = await keeper.peerKeep(target, false, () => keeper.removable(target, options));
-        if (kept.whole) return;
+        if (kept.whole) return kept.undoing(async () => void 0);
         await kept.undoing(
           () => replace(target, async (gated, sealed) => {
             const pinned = await keeper.pin(target, gated, sealed);
@@ -4965,54 +4965,60 @@ var UnlinkedKeeper = class {
         void peers.ask(tab, { kept: { items: [], paths } }, PEER_RM_MS);
       throw fsError("EBUSY", `${target}: open in another tab that did not answer`);
     }
-    const { whole, moved: moved2 } = await this.setAside(peers, target, asked, heard);
-    return { whole, undoing: (op) => this.undoing(op, moved2) };
+    const { whole, sends } = await this.setAside(target, asked);
+    return { whole, undoing: (op) => this.undoing(op, peers, sends, heard) };
   }
-  async setAside(peers, target, asked, heard) {
+  async setAside(target, asked) {
     const mine = this.heldWithin(target);
     const taken = /* @__PURE__ */ new Set();
     let whole = false;
-    const told = [];
-    const moved2 = [];
-    for (const [i, { tab, holders, paths }] of asked.entries()) {
+    const sends = [];
+    for (const { tab, holders, paths } of asked) {
       const items = [];
       for (const holder of holders) {
         const free = !mine.has(holder.path) && !taken.has(holder.path);
         const hidden = free ? await this.asideFor(holder.path, holder.instance) : void 0;
         if (hidden !== void 0) {
           taken.add(holder.path);
-          moved2.push({ tab, path: holder.path, hidden, fid: holder.fid });
           if (holder.path === target) whole = true;
         }
         items.push({ path: holder.path, hidden, fid: holder.fid });
       }
-      const answer2 = peers.ask(tab, { kept: { items, paths } }, PEER_RM_MS);
-      if (heard[i]) told.push(answer2);
+      sends.push({ tab, items, paths });
     }
-    await Promise.all(told);
-    return { whole, moved: moved2 };
+    return { whole, sends };
   }
-  async undoing(op, moved2) {
+  async undoing(op, peers, sends, heard) {
+    let failed3;
+    let out;
     try {
-      return await op();
+      out = await op();
     } catch (err) {
-      for (const { tab, path, hidden, fid } of moved2) {
-        const back = await this.serial(async () => {
-          if (await this.present(path)) return false;
-          return this.fs.rename(hidden, path).then(
-            () => true,
-            () => false
-          );
-        });
-        if (!back) continue;
-        void this.peers?.ask(
-          tab,
-          { kept: { items: [{ path, hidden: void 0, fid, undo: hidden }], paths: [] } },
-          PEER_RM_MS
-        );
+      failed3 = err ?? new Error("failed");
+      for (const send2 of sends) {
+        for (const item of send2.items) {
+          const { hidden, path } = item;
+          if (hidden !== void 0 && await this.moveBack(hidden, path)) item.hidden = void 0;
+        }
       }
-      throw err;
     }
+    await Promise.all(
+      sends.map(({ tab, items, paths }, i) => {
+        const told = peers.ask(tab, { kept: { items, paths } }, PEER_RM_MS);
+        return heard[i] ? told : void 0;
+      })
+    );
+    if (failed3 !== void 0) throw failed3;
+    return out;
+  }
+  moveBack(hidden, path) {
+    return this.serial(async () => {
+      if (await this.present(path)) return false;
+      return this.fs.rename(hidden, path).then(
+        () => true,
+        () => false
+      );
+    });
   }
   async removable(target, options) {
     const st = await this.fs.lstat(target).catch(() => void 0);
@@ -9189,9 +9195,6 @@ var HeldPaths = class extends Map {
     this.uses.set(file, Math.max(fresh3.length, 1));
     this.unlinked.set(path, file);
   }
-  unkeepAt(path, hidden) {
-    for (const file of [...this.uses.keys()]) if (file.hidden === hidden) this.unkeep(path, file);
-  }
   unkeep(path, file) {
     for (const [id2, kept] of this.keptHandles) if (kept === file) this.keptHandles.delete(id2);
     this.uses.delete(file);
@@ -23791,12 +23794,8 @@ var RemoteWatch = class {
     if (data.holds !== void 0) this.heldBy(data);
     if (data.to === this.tab && (data.keeping || data.kept)) void this.keepAsked(data);
   }
-  keepChains = /* @__PURE__ */ new Map();
   keepAsked(data) {
-    const from = data.tab;
-    const next3 = (this.keepChains.get(from) ?? Promise.resolve()).then(() => this.keepOne(data));
-    this.keepChains.set(from, next3);
-    return next3;
+    return this.keepOne(data);
   }
   async keepOne({ tab, seq: seq2, keeping, kept }) {
     const from = tab;
@@ -32571,52 +32570,49 @@ var Launcher = class {
     const gone = /* @__PURE__ */ new Set();
     const instance = this.unlinked.id;
     const ours = (hidden) => hidden.startsWith(`/${UNLINKED_DIR}/${instance}.p`) && /^[0-9a-f]+$/.test(hidden.slice(`/${UNLINKED_DIR}/${instance}.p`.length));
-    const open = (tab, paths) => {
-      for (const [key, release] of [...gates]) {
+    const gate = async (tab, path) => {
+      const release = await this.unlinked.gate.acquire(path);
+      let done4 = false;
+      const once2 = () => {
+        if (done4) return;
+        done4 = true;
+        clearTimeout(timer);
+        release();
+      };
+      const timer = setTimeout(once2, PEER_GATE_MS);
+      if (gone.has(tab)) once2();
+      return once2;
+    };
+    const open = async (tab, paths, all = false) => {
+      for (const [key, queue] of [...gates]) {
         const [owner, path] = key.split("\0");
         if (owner !== tab || paths && !paths.includes(path)) continue;
-        gates.delete(key);
-        release();
+        const taken = all ? queue.splice(0) : queue.splice(0, 1);
+        if (queue.length === 0) gates.delete(key);
+        for (const entry of taken) (await entry)();
       }
     };
     return {
       keeping: async (tab, paths) => {
-        for (const path of paths) {
-          if (gone.has(tab)) return;
-          const release = await this.unlinked.gate.acquire(path);
+        if (gone.has(tab)) return;
+        const mine = paths.map((path) => {
           const key = `${tab}\0${path}`;
-          let done4 = false;
-          const once2 = () => {
-            if (done4) return;
-            done4 = true;
-            clearTimeout(timer);
-            release();
-          };
-          const timer = setTimeout(() => {
-            if (gates.get(key) === once2) gates.delete(key);
-            once2();
-          }, PEER_GATE_MS);
-          if (gone.has(tab)) once2();
-          else gates.set(key, once2);
-        }
+          const entry = gate(tab, path);
+          gates.set(key, [...gates.get(key) ?? [], entry]);
+          return entry;
+        });
+        await Promise.all(mine);
       },
       kept: async (tab, items, paths) => {
-        for (const { path, hidden, fid, undo } of items) {
-          if (undo !== void 0) this.unadopt(path, undo, fid);
-          else this.adoptKept(path, hidden, fid, ours);
-        }
-        open(tab, paths);
+        for (const { path, hidden, fid } of items) this.adoptKept(path, hidden, fid, ours);
+        await open(tab, paths);
       },
       left: (tab) => {
         gone.add(tab);
-        open(tab);
+        void open(tab, void 0, true);
       }
     };
   }
-  unadopt(path, undo, fid) {
-    for (const holds2 of this.held) holds2.unkeepAt(path, undo);
-    void this.rootFs.announceHolds?.([[path, fid]], [], false);
-  }
   adoptKept(path, hidden, fid, ours) {
     if (hidden === void 0 || !ours(hidden)) {
       this.held.doubt([path]);