@ai-ecoverse/slicc-kernel 1.160.2 → 1.161.0

package/dist/node.js

@@ -1,6 +1,8 @@
 // src/node.ts
 import { createHash } from "node:crypto";
-import { isAbsolute } from "node:path";
+import { lstatSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join } from "node:path";
 import { MessageChannel as MessageChannel2, Worker } from "node:worker_threads";
 
 // src/bytes.ts
@@ -3673,7 +3675,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.160.2" : "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
@@ -8917,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) {
@@ -8959,6 +8964,7 @@ var HeldPaths = class extends Map {
   doubted = /* @__PURE__ */ new Map();
   doubts = 0;
   onIdle;
+  onMoved;
   keyOf(path) {
     return this.aliases.get(path) ?? path;
   }
@@ -9119,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);
@@ -10746,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;
 }
@@ -11769,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;
@@ -22851,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),
@@ -23402,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;
@@ -23445,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;
@@ -23505,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);
@@ -23517,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);
     }
@@ -23543,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();
@@ -23557,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();
@@ -23581,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;
@@ -23595,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();
@@ -23647,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);
@@ -23656,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) {
@@ -25340,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();
   }
@@ -30032,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([]);
@@ -31250,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),
@@ -31262,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),
@@ -31703,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);
   }
@@ -34877,12 +34994,72 @@ function workerEnv() {
   const { NODE_COMPILE_CACHE: _inherited, ...env } = process.env;
   return env;
 }
+var CACHE_PREFIX = "slicc-kernel-cc-";
 function cacheDirOf(dir) {
-  if (dir === void 0) return void 0;
+  if (dir === false) return void 0;
+  if (dir === void 0) return ownCacheDir();
   if (typeof dir !== "string" || !isAbsolute(dir)) {
-    throw new TypeError("createNodeKernel: compileCache must be an absolute directory path");
+    throw new TypeError(
+      "createNodeKernel: compileCache must be an absolute directory path or false"
+    );
+  }
+  return { dir, own: false };
+}
+function cacheData(cache) {
+  if (!cache) return void 0;
+  return { compileCache: cache.dir, ...cache.own ? { ownedCache: true } : {} };
+}
+function dropCache(cache) {
+  if (!cache?.own) return;
+  try {
+    rmSync(cache.dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function ownCacheDir(make = privateCacheDir) {
+  try {
+    return { dir: make(), own: true };
+  } catch {
+    return void 0;
+  }
+}
+var swept = false;
+function privateCacheDir(base = tmpdir(), alive = pidAlive) {
+  if (!swept) {
+    swept = true;
+    sweepCacheDirs(base, alive);
+  }
+  return mkdtempSync(join(base, `${CACHE_PREFIX}${process.pid}-`));
+}
+function sweepCacheDirs(base, alive = pidAlive, uid = process.getuid?.()) {
+  let names2;
+  try {
+    names2 = readdirSync(base);
+  } catch {
+    return;
+  }
+  for (const name2 of names2) {
+    if (!name2.startsWith(CACHE_PREFIX)) continue;
+    const pid = Number(name2.slice(CACHE_PREFIX.length).split("-")[0]);
+    if (!Number.isInteger(pid) || pid <= 0 || alive(pid)) continue;
+    removeOurs(join(base, name2), uid);
+  }
+}
+function removeOurs(path, uid) {
+  try {
+    const st = lstatSync(path);
+    if (!st.isDirectory() || uid !== void 0 && st.uid !== uid) return;
+    rmSync(path, { recursive: true, force: true });
+  } catch {
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
   }
-  return dir;
 }
 var nodeSessions = 0;
 function nodeClient(launcher, clients, { user, tag, requests }) {
@@ -34918,8 +35095,8 @@ async function createNodeKernel(options = {}) {
   const clients = /* @__PURE__ */ new Set();
   let terminated = false;
   const file = options.worker ?? new URL("./node-process-worker.js", import.meta.url);
-  const compileCache = cacheDirOf(options.compileCache);
-  const workerData = compileCache ? { compileCache } : void 0;
+  const cache = cacheDirOf(options.compileCache);
+  const workerData = cacheData(cache);
   const warm = warmPoolOf(options, file, workerData, live);
   const transport = options.network?.transport;
   const launcher = new Launcher({
@@ -35057,6 +35234,7 @@ async function createNodeKernel(options = {}) {
       for (const kill of [...live]) kill();
       launcher.cdp.close();
       launcher.unmountAll();
+      dropCache(cache);
     }
   };
 }
@@ -35070,9 +35248,12 @@ export {
   fetchTransport,
   memoryRoot,
   nodeTransport,
+  ownCacheDir,
+  privateCacheDir,
   serveHostfsPort,
   sourceModule,
   sparesOf,
+  sweepCacheDirs,
   warmPool
 };
 //# sourceMappingURL=node.js.map