@ai-ecoverse/slicc-kernel 1.166.4 → 1.167.0

package/dist/node.js

@@ -3684,7 +3684,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.166.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.167.0" : "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
@@ -4648,8 +4648,41 @@ var within2 = (path, target) => path === target || target === "/" || path.starts
 var TOUCHED_MAX = 4096;
 var parentOf2 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var PEER_RM_MS = 1e3;
+var SHARED_ACK_MS = 24 * 60 * 60 * 1e3;
+var delay = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var PEER_RENAME_MS = 1e4;
 var PEER_GATE_MS = PEER_RENAME_MS + 5e3;
+var SHARED_PREFIX = "shared.";
+var keptLock = (hidden) => `slicc-kept:${hidden}`;
+function sharedKept(hidden) {
+  const at = `/${UNLINKED_DIR}/${SHARED_PREFIX}`;
+  return hidden.startsWith(at) && /^[0-9a-f]+$/.test(hidden.slice(at.length));
+}
+function holdShared(locks, name2) {
+  if (!locks) return Promise.resolve(async () => void 0);
+  return new Promise((resolve2) => {
+    const settled = locks.request(name2, { mode: "shared" }, () => {
+      const { promise, resolve: done4 } = Promise.withResolvers();
+      resolve2(async () => {
+        done4();
+        await settled.catch(() => void 0);
+      });
+      return promise;
+    });
+  });
+}
+async function whenLast(locks, name2, op) {
+  if (!locks) {
+    await op();
+    return true;
+  }
+  let free = false;
+  await locks.request(name2, { mode: "exclusive", ifAvailable: true }, async (lock) => {
+    free = lock !== null;
+    if (free) await op();
+  });
+  return free;
+}
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
 var PathGate = class {
@@ -4965,52 +4998,124 @@ 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, sends } = await this.setAside(target, asked);
-    return { whole, undoing: (op) => this.undoing(op, peers, sends, heard) };
+    const { whole, sends, shared } = await this.setAside(target, asked);
+    return { whole, undoing: (op) => this.undoing(op, peers, sends, heard, shared) };
   }
   async setAside(target, asked) {
     const mine = this.heldWithin(target);
-    const taken = /* @__PURE__ */ new Set();
-    let whole = false;
+    const tabsOf = /* @__PURE__ */ new Map();
+    for (const { holders } of asked)
+      for (const { path } of holders) tabsOf.set(path, (tabsOf.get(path) ?? 0) + 1);
+    const done4 = /* @__PURE__ */ new Map();
+    const shared = [];
     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);
-          if (holder.path === target) whole = true;
+        if (!done4.has(holder.path)) {
+          const many = mine.has(holder.path) || (tabsOf.get(holder.path) ?? 0) > 1;
+          done4.set(holder.path, await this.asideOne(holder, many, mine, shared));
         }
-        items.push({ path: holder.path, hidden, fid: holder.fid });
+        items.push({ path: holder.path, hidden: done4.get(holder.path), fid: holder.fid });
       }
       sends.push({ tab, items, paths });
     }
-    return { whole, sends };
+    return { whole: done4.get(target) !== void 0, sends, shared };
+  }
+  async asideOne(holder, many, mine, shared) {
+    if (!many) return this.asideFor(holder.path, holder.instance);
+    const one = await this.sharedAside(holder.path, mine);
+    if (one) shared.push(one);
+    return one?.hidden;
+  }
+  async sharedAside(path, mine) {
+    const hidden = `${dirOf("/")}/${SHARED_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
+    const release = await holdShared(this.sharedLocks(), keptLock(hidden));
+    const moved2 = await this.serial(async () => {
+      try {
+        const owner = this.dirOwner;
+        await this.fs.mkdir(dirOf("/"), { recursive: true, ...owner ? { owner } : {} });
+        await this.fs.rename(path, hidden);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!moved2) {
+      await release();
+      return void 0;
+    }
+    const local2 = mine.get(path) ?? [];
+    const file = local2.length > 0 ? await this.sharedFile(hidden, local2.length) : void 0;
+    if (file) for (const holder of local2) holder.keep(path, file);
+    return { path, hidden, release, local: local2, file };
+  }
+  async sharedFile(hidden, refs) {
+    const locks = this.sharedLocks();
+    const mine = await holdShared(locks, keptLock(hidden));
+    let left = refs;
+    return {
+      hidden,
+      release: () => {
+        if (--left > 0) return;
+        void mine().then(() => this.dropIfLast(hidden));
+      }
+    };
+  }
+  dropIfLast(hidden) {
+    return this.serial(
+      () => whenLast(this.sharedLocks(), keptLock(hidden), () => this.drop(hidden))
+    );
+  }
+  sharedLocks() {
+    return this.locks;
   }
-  async undoing(op, peers, sends, heard) {
+  async undoing(op, peers, sends, heard, shared = []) {
     let failed3;
     let out;
     try {
       out = await op();
     } catch (err) {
       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;
-        }
-      }
+      await this.rollBackAsides(sends, shared);
     }
+    const hiddenShared = new Set(shared.map((one) => one.hidden));
+    const answers2 = sends.map(({ tab, items, paths }) => {
+      const keeps = items.some((item) => item.hidden && hiddenShared.has(item.hidden));
+      return {
+        keeps,
+        told: peers.ask(tab, { kept: { items, paths } }, keeps ? SHARED_ACK_MS : PEER_RM_MS)
+      };
+    });
     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;
-      })
+      answers2.map(({ told }, i) => heard[i] ? Promise.race([told, delay(PEER_RM_MS)]) : void 0)
     );
+    for (const one of shared) {
+      const waits = answers2.filter(
+        ({ keeps }, i) => keeps && sends[i]?.items.some((item) => item.hidden === one.hidden)
+      );
+      const done4 = () => one.release().then(() => this.dropIfLast(one.hidden));
+      void Promise.all(waits.map(({ told }) => told)).then(done4, done4);
+    }
     if (failed3 !== void 0) throw failed3;
     return out;
   }
+  async rollBackAsides(sends, shared) {
+    const back = /* @__PURE__ */ new Map();
+    for (const item of sends.flatMap((send2) => send2.items)) {
+      const { hidden, path } = item;
+      if (hidden === void 0) continue;
+      if (!back.has(hidden)) back.set(hidden, await this.moveBack(hidden, path));
+      if (back.get(hidden)) item.hidden = void 0;
+    }
+    for (const { hidden, path, local: local2, file } of shared) {
+      if (!back.get(hidden) || !file) continue;
+      for (const holder of local2) {
+        holder.unkeep(path, file);
+        file.release();
+      }
+    }
+  }
   moveBack(hidden, path) {
     return this.serial(async () => {
       if (await this.present(path)) return false;
@@ -5119,6 +5224,15 @@ var UnlinkedKeeper = class {
       for (const name2 of names2) {
         const id2 = name2.slice(0, name2.lastIndexOf("."));
         const at = id2.indexOf("~");
+        if (name2.startsWith(SHARED_PREFIX)) {
+          const at2 = `${dir}/${name2}`;
+          await whenLast(
+            this.sharedLocks(),
+            keptLock(at2),
+            () => this.fs.rm(at2, { recursive: true }).catch(() => void 0)
+          );
+          continue;
+        }
         const dead = id2 !== this.instance && (at < 0 ? held !== void 0 && !held.has(lockName(id2)) : owner?.alive(id2.slice(0, at)) === false);
         if (dead) await this.fs.rm(`${dir}/${name2}`, { recursive: true }).catch(() => void 0);
       }
@@ -20273,13 +20387,13 @@ var VfsNode = class {
     this.recount();
     if (!this.orphaned) this.onDirty?.();
     if (this.writeBack !== void 0 || this.orphaned) return;
-    const delay = Math.max(WRITEBACK_MS, this.writeBackCost * WRITEBACK_COST_FACTOR);
+    const delay2 = Math.max(WRITEBACK_MS, this.writeBackCost * WRITEBACK_COST_FACTOR);
     this.writeBack = setTimeout(() => {
       this.writeBack = void 0;
       this.serial(() => this.flush()).catch(() => {
         this.failed = true;
       });
-    }, delay);
+    }, delay2);
   }
   ensure(need2) {
     const cur = this.data ?? new Uint8Array(0);
@@ -23955,6 +24069,7 @@ var RemoteWatch = class {
       };
       const left = /* @__PURE__ */ new Set([to]);
       const timer = setTimeout(done4, cap);
+      timer.unref?.();
       this.waiting.set(seq2, { left, done: done4 });
     });
   }
@@ -23996,6 +24111,9 @@ var RemoteWatch = class {
         this.keeps?.left(tab);
         this.ackers.delete(tab);
         this.holders.delete(tab);
+        for (const wait2 of [...this.waiting.values()]) {
+          if (wait2.left.delete(tab) && wait2.left.size === 0) wait2.done();
+        }
       }
     }
     this.rebuild();
@@ -25550,9 +25668,9 @@ async function unlocked(name2, op) {
       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));
+      const delay2 = SYNC_BACKOFF_MS[attempt];
+      if (delay2 === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay2));
     }
   }
 }
@@ -25563,10 +25681,10 @@ async function openSync(handle) {
     try {
       return await sync.call(handle, { mode: "readwrite-unsafe" });
     } catch (err) {
-      const delay = SYNC_BACKOFF_MS[attempt];
+      const delay2 = SYNC_BACKOFF_MS[attempt];
       if (!LOCKED.has(err?.name)) throw err;
-      if (delay === void 0) return void 0;
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      if (delay2 === void 0) return void 0;
+      await new Promise((resolve2) => setTimeout(resolve2, delay2));
     }
   }
 }
@@ -27571,9 +27689,9 @@ var OpfsFs = class {
       if (!failed3) return true;
       const error = failed3.err?.name;
       if (handle.kind !== "file" || !LOCKED.has(error)) return false;
-      const delay = SYNC_BACKOFF_MS[attempt];
-      if (delay === void 0) throw fsError("EBUSY", name2);
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      const delay2 = SYNC_BACKOFF_MS[attempt];
+      if (delay2 === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay2));
     }
   }
   async copy(handle, dir, name2, copies, rest2 = "") {
@@ -32679,7 +32797,10 @@ var Launcher = class {
         await Promise.all(mine);
       },
       kept: async (tab, items, paths) => {
-        for (const { path, hidden, fid } of items) this.adoptKept(path, hidden, fid, ours);
+        for (const { path, hidden, fid } of items) {
+          if (hidden !== void 0 && sharedKept(hidden)) await this.adoptShared(path, hidden, fid);
+          else this.adoptKept(path, hidden, fid, ours);
+        }
         await open(tab, paths);
       },
       left: (tab) => {
@@ -32688,6 +32809,33 @@ var Launcher = class {
       }
     };
   }
+  async adoptShared(path, hidden, fid) {
+    const bound3 = [...this.held].map(
+      (holds2) => [holds2, [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)]]
+    );
+    const keeping = bound3.filter(([, ids]) => ids.length > 0);
+    const nodes = [...this.openFiles].filter(
+      (open) => [path, hidden].some((at) => open.holdsAt(at))
+    );
+    const refs = keeping.length + nodes.length;
+    if (refs === 0) {
+      this.held.doubt([path]);
+      return;
+    }
+    const file = await this.unlinked.sharedFile(hidden, refs);
+    if (!await this.rootFs.lstat(hidden).then(
+      () => true,
+      () => false
+    )) {
+      for (let i = 0; i < refs; i++) file.release();
+      this.held.doubt([path]);
+      return;
+    }
+    const kept = nodes.filter((open) => open.keepBound([hidden, path], fid, file)).length;
+    for (let i = kept; i < nodes.length; i++) file.release();
+    for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
+    void this.rootFs.announceHolds?.([], [path, hidden], false);
+  }
   adoptKept(path, hidden, fid, ours) {
     if (hidden === void 0 || !ours(hidden)) {
       this.held.doubt([path]);
@@ -32830,7 +32978,6 @@ var Launcher = class {
   moved(from, to, source) {
     this.renameLog.add(from, to);
     for (const holds2 of this.held) holds2.renamed(from, to);
-    if (this.mounts.locate(to) === void 0) this.rootFs.rehold?.(from, to);
     if (source) return;
     for (const nodes of this.openFiles) nodes.renamed(from, to);
     this.watchers.moved(from, to);