@ai-ecoverse/slicc-kernel 1.160.3 → 1.161.0

package/dist/node.js

@@ -3675,7 +3675,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.160.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.161.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
@@ -8919,12 +8919,15 @@ function linkedTo(mount, path) {
 var within5 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var HeldSet = class extends Set {
   idle;
-  constructor(idle2) {
+  moved;
+  constructor(idle2, moved2) {
     super();
     this.idle = idle2;
+    this.moved = moved2;
   }
   add(holds2) {
     holds2.onIdle = this.idle;
+    holds2.onMoved = this.moved;
     return super.add(holds2);
   }
   doubt(paths, over) {
@@ -8961,6 +8964,7 @@ var HeldPaths = class extends Map {
   doubted = /* @__PURE__ */ new Map();
   doubts = 0;
   onIdle;
+  onMoved;
   keyOf(path) {
     return this.aliases.get(path) ?? path;
   }
@@ -9121,6 +9125,7 @@ var HeldPaths = class extends Map {
     for (const [id2, key] of this.handles) {
       if (within5(key, from)) this.handles.set(id2, to + key.slice(from.length));
     }
+    this.onMoved?.(from, to);
   }
   isRevoked(path) {
     return this.revoked.has(path);
@@ -10748,12 +10753,18 @@ async function holdOp(entry, path, req) {
       if (req.nofollow && !await ownEntry(entry, path, real ?? path)) continue;
       const fid = req.ino === void 0 ? void 0 : await idOf(entry, real ?? path);
       if (!r || !r.missed(path) && !r.changedSince(path, gen) && !r.inFlight?.(path))
-        return json2(entry.hold?.(path, on, open, real, void 0, req.ino, fid) ?? null);
+        return json2(await heldOpen(entry, path, real, req, fid));
     }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
 }
+async function heldOpen(entry, path, real, req, fid) {
+  const handle = entry.hold?.(path, true, true, real, void 0, req.ino, fid);
+  if (handle === void 0) return null;
+  await entry.announceHold?.(real ?? path, fid, ((req.mode ?? 0) & HOLD_CREATED) !== 0);
+  return handle;
+}
 async function idOf(entry, path) {
   return await entry.fileId?.(path)?.catch(() => void 0) ?? void 0;
 }
@@ -11771,6 +11782,10 @@ var SYS_TREE = {
 `,
     slicc_file_ids: (listing) => `${listing.fileIds ?? 0}
 `,
+    slicc_peer_holds: ({ holds: holds2 }) => `${holds2?.mine ?? 0} ${holds2?.peers ?? 0} ${holds2?.sent ?? 0}
+`,
+    slicc_peer_held: ({ holds: holds2 }) => (holds2?.held ?? []).map((path) => `${path}
+`).join(""),
     slicc_rename_acks: (listing) => {
       const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
       const median = samples[Math.floor(samples.length / 2)] ?? 0;
@@ -22853,6 +22868,7 @@ function holdingToken(opts, holds2, caller) {
     ...opts.statfs ? { statfs: opts.statfs } : {},
     ...opts.renames ? { renames: opts.renames } : {},
     ...opts.fileId ? { fileId: opts.fileId } : {},
+    ...opts.announceHold ? { announceHold: opts.announceHold } : {},
     ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
     hold: (path, on, open, real, handle, ino, fid) => holds2.hold(path, on, open, real, handle, ino, fid),
     boundIno: holds2.boundIno.bind(holds2),
@@ -23404,6 +23420,11 @@ var RemoteWatch = class {
   mourned = /* @__PURE__ */ new Set();
   others = /* @__PURE__ */ new Map();
   union = /* @__PURE__ */ new Set();
+  myHolds = /* @__PURE__ */ new Map();
+  peerHolds = /* @__PURE__ */ new Map();
+  holdsSent = 0;
+  silent = /* @__PURE__ */ new Set();
+  holders = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
   waiting = /* @__PURE__ */ new Map();
   locks;
@@ -23447,7 +23468,7 @@ var RemoteWatch = class {
       this.settled = true;
       this.recount();
     });
-    this.channel.postMessage({ hello: this.tab, renames: true });
+    this.channel.postMessage({ hello: this.tab, renames: true, keeps: true });
   }
   async join() {
     if (!this.locks) return;
@@ -23507,8 +23528,12 @@ var RemoteWatch = class {
     return `${this.name}:${tab}`;
   }
   receive(data) {
+    const spoke = data.hello ?? data.here ?? data.tab ?? data.from;
+    if (spoke !== void 0) this.silent.delete(spoke);
     const sender = data.hello ?? data.here ?? (data.paths !== void 0 ? data.tab : void 0);
     if (sender !== void 0 && data.renames) this.ackers.add(sender);
+    const keeper = data.hello ?? data.here;
+    if (keeper !== void 0 && data.keeps) this.holders.add(keeper);
     if (data.hello !== void 0) this.greeted(data.hello);
     if (data.renaming !== void 0 && data.tab !== void 0) this.heard(data);
     if (data.renamed !== void 0) this.renamed?.(data.renamed);
@@ -23519,6 +23544,7 @@ var RemoteWatch = class {
       this.met?.();
     }
     if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
+    if (data.tab !== void 0 && data.holds !== void 0) this.heldBy(data);
     if (data.ack !== void 0 && data.to === this.tab && data.from !== void 0) {
       this.acked(data.ack, data.from);
     }
@@ -23545,8 +23571,10 @@ var RemoteWatch = class {
     void this.locks.request(name2, async () => {
       this.mourned.delete(peer);
       this.others.delete(peer);
+      this.peerHolds.delete(peer);
       this.peers.delete(peer);
       this.ackers.delete(peer);
+      this.holders.delete(peer);
       this.flushedAt(peer);
       this.rebuild();
       this.recount();
@@ -23559,8 +23587,9 @@ var RemoteWatch = class {
   greeted(peer) {
     this.arrived(peer);
     const answer2 = () => {
-      this.channel.postMessage({ here: this.tab, to: peer, renames: true });
+      this.channel.postMessage({ here: this.tab, to: peer, renames: true, keeps: true });
       if (this.mine.length > 0) void this.announce(this.mine);
+      if (this.myHolds.size > 0) this.sendHolds([...this.myHolds], []);
     };
     if (!this.quiet) {
       answer2();
@@ -23583,6 +23612,69 @@ var RemoteWatch = class {
     this.rebuild();
     this.channel.postMessage({ ack: seq2, from: this.tab, to: from });
   }
+  heldBy({ tab, holds: holds2, seq: seq2 }) {
+    const from = tab;
+    const { add, drop } = holds2;
+    const held = this.peerHolds.get(from) ?? /* @__PURE__ */ new Map();
+    for (const path of drop) held.delete(path);
+    for (const [path, fid] of add) held.set(path, fid);
+    if (held.size > 0) this.peerHolds.set(from, held);
+    else this.peerHolds.delete(from);
+    this.channel.postMessage({ ack: seq2, from: this.tab, to: from });
+  }
+  hold(add, drop, wait2) {
+    const fresh3 = add.filter(
+      ([path, fid]) => !this.myHolds.has(path) || this.myHolds.get(path) !== fid
+    );
+    const gone = drop.filter((path) => this.myHolds.has(path));
+    for (const path of gone) this.myHolds.delete(path);
+    for (const [path, fid] of fresh3) this.myHolds.set(path, fid);
+    if (fresh3.length === 0 && gone.length === 0 || this.peers.size === 0)
+      return Promise.resolve();
+    const seq2 = this.sendHolds(fresh3, gone);
+    if (!wait2) return Promise.resolve();
+    const heard = new Set(
+      [...this.peers].filter((peer) => this.holders.has(peer) && !this.silent.has(peer))
+    );
+    return this.acks(seq2, heard, (left) => {
+      for (const peer of left) this.silent.add(peer);
+    });
+  }
+  rehold(from, to) {
+    const add = [];
+    const drop = [];
+    for (const [path, fid] of [...this.myHolds]) {
+      if (path !== from && !path.startsWith(`${from}/`)) continue;
+      const moved2 = to + path.slice(from.length);
+      this.myHolds.delete(path);
+      this.myHolds.set(moved2, fid);
+      drop.push(path);
+      add.push([moved2, fid]);
+    }
+    if (drop.length > 0 && this.peers.size > 0) this.sendHolds(add, drop);
+  }
+  sendHolds(add, drop) {
+    const seq2 = ++this.seq;
+    this.holdsSent++;
+    this.channel.postMessage({ tab: this.tab, holds: { add: [...add], drop: [...drop] }, seq: seq2 });
+    return seq2;
+  }
+  peerHeld(path) {
+    const out = [];
+    for (const [tab, held] of this.peerHolds)
+      if (held.has(path)) out.push({ tab, fid: held.get(path) });
+    return out;
+  }
+  peerHeldPaths() {
+    const out = /* @__PURE__ */ new Set();
+    for (const held of this.peerHolds.values()) for (const path of held.keys()) out.add(path);
+    return [...out].sort();
+  }
+  holdCounts() {
+    let peers = 0;
+    for (const held of this.peerHolds.values()) peers += held.size;
+    return { mine: this.myHolds.size, peers, sent: this.holdsSent };
+  }
   acked(seq2, from) {
     const wait2 = this.waiting.get(seq2);
     if (!wait2) return;
@@ -23597,11 +23689,13 @@ var RemoteWatch = class {
     if (!this.locks) return;
     const held = new Set(((await this.locks.query()).held ?? []).map((lock) => lock.name));
     let left = false;
-    for (const tab of /* @__PURE__ */ new Set([...this.others.keys(), ...this.peers])) {
+    for (const tab of /* @__PURE__ */ new Set([...this.others.keys(), ...this.peers, ...this.peerHolds.keys()])) {
       if (!held.has(this.lockOf(tab))) {
         if (this.peers.delete(tab)) left = true;
         this.others.delete(tab);
+        this.peerHolds.delete(tab);
         this.ackers.delete(tab);
+        this.holders.delete(tab);
       }
     }
     this.rebuild();
@@ -23649,8 +23743,9 @@ var RemoteWatch = class {
   renamedTree(lock) {
     this.channel.postMessage({ renamed: lock });
   }
-  acks(seq2, from) {
+  acks(seq2, from, missed) {
     if (from.size === 0) return Promise.resolve();
+    const left = new Set(from);
     return new Promise((resolve2) => {
       const done4 = () => {
         clearTimeout(timer);
@@ -23658,10 +23753,11 @@ var RemoteWatch = class {
         resolve2();
       };
       const timer = setTimeout(() => {
+        missed?.(left);
         done4();
         void this.prune();
       }, ANNOUNCE_WAIT_MS);
-      this.waiting.set(seq2, { left: new Set(from), done: done4 });
+      this.waiting.set(seq2, { left, done: done4 });
     });
   }
   emit(change) {
@@ -25342,6 +25438,16 @@ var OpfsFs = class {
     return this.remote?.listen(listener) ?? (() => {
     });
   }
+  announceHolds(add, drop, wait2) {
+    return this.remote?.hold(add, drop, wait2) ?? Promise.resolve();
+  }
+  holdCounts() {
+    const remote = this.remote;
+    return remote && { ...remote.holdCounts(), held: remote.peerHeldPaths() };
+  }
+  rehold(from, to) {
+    this.remote?.rehold(from, to);
+  }
   announceWatch(paths) {
     return this.remote?.announce(paths) ?? Promise.resolve();
   }
@@ -30034,7 +30140,12 @@ var Launcher = class {
   identities = { asked: 0, timedOut: 0 };
   nodes;
   unlinked;
-  held = new HeldSet((path) => this.released(path));
+  held = new HeldSet(
+    (path) => this.released(path),
+    (from, to) => {
+      if (this.mounts.locate(to) === void 0) this.rootFs.rehold?.(from, to);
+    }
+  );
   processMounts;
   booting = new AbortController();
   fstab = Promise.resolve([]);
@@ -31252,7 +31363,8 @@ var Launcher = class {
         cwdChecks: this.cwds.checks,
         renameAcks: this.rootFs.renameWaits?.(),
         staleFds: staleFdCount(),
-        fileIds: this.rootFs.fileIdWrites?.() ?? 0
+        fileIds: this.rootFs.fileIdWrites?.() ?? 0,
+        holds: this.rootFs.holdCounts?.()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -31264,6 +31376,7 @@ var Launcher = class {
       statfs: (path) => this.mounts.statfs(path),
       renames: (since2, held) => this.renameLog.since(since2, held),
       fileId: (path) => this.locks.shared?.() === true ? this.rootFileId(path) : void 0,
+      announceHold: (path, fid, created4) => this.locks.shared?.() === true && this.mounts.locate(path) === void 0 ? this.rootFs.announceHolds?.([[path, fid]], [], !created4) : void 0,
       renameSeq: (from, to) => this.renameLog.seqOf(from, to),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),
@@ -31705,6 +31818,8 @@ var Launcher = class {
     const at = normalizePath(path);
     this.unlinked.closed(at);
     this.writers?.unlinked.closed(at);
+    if (![...this.held].some((holds2) => holds2.holding(at)))
+      void this.rootFs.announceHolds?.([], [at], false);
     const open = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open) void this.mounts.commit(at).catch(() => void 0);
   }