@ai-ecoverse/slicc-kernel 1.133.3 → 1.133.5

package/dist/node.js

@@ -4161,6 +4161,7 @@ var RemoteWatch = class {
   settled = false;
   quiet;
   crowd;
+  gone;
   told;
   counted = 0;
   recount() {
@@ -4250,6 +4251,7 @@ var RemoteWatch = class {
       this.peers.delete(peer);
       this.rebuild();
       this.recount();
+      this.gone?.();
       for (const wait2 of this.waiting.values()) {
         if (wait2.left.delete(peer) && wait2.left.size === 0) wait2.done();
       }
@@ -4285,14 +4287,16 @@ var RemoteWatch = class {
   async prune() {
     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])) {
       if (!held.has(this.lockOf(tab))) {
+        if (this.peers.delete(tab)) left = true;
         this.others.delete(tab);
-        this.peers.delete(tab);
       }
     }
     this.rebuild();
     this.recount();
+    if (left) this.gone?.();
   }
   watched() {
     return this.union.size > 0;
@@ -4382,6 +4386,7 @@ var REPLACED_ATTEMPTS = 4;
 var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var RENAMES = "/.slicc-renames";
+var RENAME_LOCK = "slicc-rename:";
 function movable(handle) {
   return typeof handle.move === "function";
 }
@@ -4544,8 +4549,11 @@ var OpfsFs = class {
     this.lockPrefix = `slicc-excl:${channel ?? ""}:`;
     this.rootName = channel;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
-    this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`);
-    if (this.remote) this.remote.quiet = () => this.quiet().then(() => this.settle?.());
+    this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`, { locks: this.locks ?? null });
+    if (this.remote) {
+      this.remote.quiet = () => this.quiet().then(() => this.settle?.());
+      this.remote.gone = () => void this.orphans();
+    }
     if (this.channel) {
       const remote = this.remote;
       meta.listen?.((c) => {
@@ -5556,6 +5564,9 @@ var OpfsFs = class {
       }
     }
     await this.meta.remove([found.path]);
+    if (found.handle?.kind === "directory") {
+      await this.meta.update(found.path, (entry) => entry ?? vacatedAt(found.path));
+    }
     this.touch(Date.now(), parentOf4(found.path));
   }
   links() {
@@ -5618,14 +5629,17 @@ var OpfsFs = class {
     const dir = parent.handle;
     const name2 = baseOf(destination);
     const swap = targetStat?.isDirectory === true;
+    let lock;
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
     const copying = sourceStat.isDirectory && !movable(source.handle);
     const staged = resolvePath(parent.path, staging);
     const place = async () => {
       this.forget(destination);
       const timed2 = await this.explicitTimes(source.path);
-      const first = copying ? await this.intend({ from: source.path, to: staged }) : void 0;
-      const second = copying && swap ? await this.intend({ from: staged, to: destination, replace: true }) : void 0;
+      const root = { ino: inodeOf(source.path), ...moving };
+      const owned4 = lock ? { lock } : {};
+      const first = copying ? await this.intend({ from: source.path, to: staged, root, ...owned4 }) : void 0;
+      const second = copying && swap ? await this.intend({ from: staged, to: destination, replace: true, root, ...owned4 }) : void 0;
       const moved2 = await this.replacingTarget(
         targetStat !== null,
         () => this.place(source.handle, dir, staging)
@@ -5634,7 +5648,7 @@ var OpfsFs = class {
         throw err;
       });
       if (swap) await this.rm(destination, { recursive: true });
-      if (second) await this.intend({ from: staged, to: destination }, second);
+      if (second) await this.intend({ from: staged, to: destination, root, ...owned4 }, second);
       await this.meta.move(source.path, destination, carry, left);
       this.movePending(source.path, destination);
       if (!moved2) {
@@ -5659,7 +5673,11 @@ var OpfsFs = class {
     const entry = { from: source.path, to: destination, done: promise };
     this.renamingDirs.add(entry);
     try {
-      await place();
+      const locks = this.locks;
+      if (locks) {
+        lock = `${RENAME_LOCK}${crypto.randomUUID()}`;
+        await locks.request(lock, place);
+      } else await place();
     } finally {
       this.renamingDirs.delete(entry);
       resolve2();
@@ -5691,12 +5709,40 @@ var OpfsFs = class {
     } catch {
     }
   }
-  async finishRenames() {
-    const intents = (await this.meta.under(RENAMES)).filter((entry) => entry.rename !== void 0).sort(
+  replaying = Promise.resolve();
+  orphans() {
+    this.replaying = this.replaying.then(() => this.finishRenames(true)).catch(() => 0);
+    return this.replaying;
+  }
+  async finishRenames(orphaned = false) {
+    const locks = this.locks;
+    const held = /* @__PURE__ */ new Set();
+    if (orphaned && locks) {
+      const { held: h = [], pending = [] } = await locks.query();
+      for (const lock of [...h, ...pending]) held.add(lock.name);
+    }
+    const intents = (await this.meta.under(RENAMES)).filter(
+      (entry) => entry.rename !== void 0 && (!orphaned || locks !== void 0 && entry.rename.lock !== void 0 && !held.has(entry.rename.lock))
+    ).sort(
       (a, b) => a.rename.at - b.rename.at
     );
     for (const entry of intents) {
-      const { from, to, replace } = entry.rename;
+      const lock = entry.rename.lock;
+      if (!orphaned || !locks || !lock) await this.finishRename(entry);
+      else await locks.request(lock, () => this.finishRename(entry));
+    }
+    return intents.length;
+  }
+  async finishRename(entry) {
+    const [current] = await this.meta.under(entry.path);
+    if (current?.rename === void 0) return;
+    const { from, to, replace, root } = current.rename;
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    const barrier = { from, to, done: promise };
+    this.renamingDirs.add(barrier);
+    this.forget(from);
+    this.forget(to);
+    try {
       const left = await this.real(from);
       if (left && replace && await this.real(to)) await this.rm(to, { recursive: true });
       if (left) {
@@ -5713,11 +5759,23 @@ var OpfsFs = class {
         this.forget(to);
       }
       if ((await this.meta.under(from)).length > 0) {
-        await this.meta.move(from, to, (moved2) => ({ ...occupied(moved2), path: to }));
+        await this.meta.move(
+          from,
+          to,
+          (moved2) => ({
+            ...occupied(moved2),
+            ...root,
+            ino: occupied(moved2).ino ?? root?.ino ?? inodeOf(from),
+            path: to
+          }),
+          void 0
+        );
       }
       await this.meta.update(entry.path, () => void 0);
+    } finally {
+      this.renamingDirs.delete(barrier);
+      resolve2();
     }
-    return intents.length;
   }
   async settledRename(path) {
     if (this.renamingDirs.size === 0 && this.copying.size === 0 || typeof path !== "string")
@@ -6001,7 +6059,10 @@ var OpfsFs = class {
     };
   }
   async reconcile() {
-    if (this.remote && await this.remote.peered()) return 0;
+    if (this.remote && await this.remote.peered()) {
+      await this.orphans();
+      return 0;
+    }
     await this.finishRenames();
     let removed = 0;
     const entries = await this.meta.all();
@@ -7403,7 +7464,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.133.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.133.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
@@ -10737,6 +10798,88 @@ var FifoTable = class {
   }
 };
 
+// src/kernel/held-cwd.ts
+var CWD_SLOTS = 1024;
+var UNTRACKED = CWD_SLOTS - 1;
+var under4 = (path, changed) => changed === "/" || path === changed || path.startsWith(`${changed}/`);
+var CwdTable = class {
+  sab = new SharedArrayBuffer(CWD_SLOTS * 4);
+  view = new Int32Array(this.sab);
+  held = /* @__PURE__ */ new Map();
+  free = [];
+  next = 0;
+  checks = 0;
+  inodeOf;
+  constructor(inodeOf2) {
+    this.inodeOf = inodeOf2;
+  }
+  async hold(path, from) {
+    const shared = from === void 0 ? void 0 : this.held.get(from);
+    if (shared && shared.path === path) return this.share(from);
+    const ino = await this.inodeOf(path).catch(() => void 0);
+    const slot2 = this.free.pop() ?? (this.next < UNTRACKED ? this.next++ : UNTRACKED);
+    if (slot2 === UNTRACKED) return slot2;
+    this.held.set(slot2, {
+      path,
+      ino,
+      refs: 1,
+      dead: false,
+      verified: Atomics.load(this.view, slot2)
+    });
+    return slot2;
+  }
+  share(slot2) {
+    const held = slot2 === void 0 ? void 0 : this.held.get(slot2);
+    if (!held) return UNTRACKED;
+    held.refs++;
+    return slot2;
+  }
+  release(slot2) {
+    const held = slot2 === void 0 ? void 0 : this.held.get(slot2);
+    if (!held || --held.refs > 0) return;
+    this.held.delete(slot2);
+    Atomics.add(this.view, slot2, 1);
+    this.free.push(slot2);
+  }
+  stateOf(slot2) {
+    const held = this.held.get(slot2);
+    return { seen: held?.verified ?? Atomics.load(this.view, slot2), dead: held?.dead === true };
+  }
+  touched(paths, trees = []) {
+    if (this.held.size === 0) return;
+    for (const [slot2, held] of this.held) {
+      if (held.dead) continue;
+      if (paths.some((p) => under4(held.path, p)) || trees.some((t) => under4(held.path, t))) {
+        Atomics.add(this.view, slot2, 1);
+      }
+    }
+  }
+  async check(slot2) {
+    this.checks++;
+    const gen = Atomics.load(this.view, slot2);
+    const held = this.held.get(slot2);
+    if (!held) return { gen, alive: true };
+    if (!held.dead) {
+      const ino = await this.inodeOf(held.path).catch(() => null);
+      held.dead = ino === null || held.ino !== void 0 && ino !== held.ino;
+      held.verified = gen;
+    }
+    return { gen, alive: !held.dead };
+  }
+};
+function heldInit(o) {
+  if (!o.cwds || o.cwdSlot === void 0) return {};
+  const state = o.cwdState ?? { seen: 0, dead: false };
+  return { held: { sab: o.cwds, slot: o.cwdSlot, ...state } };
+}
+function heldHooks(o) {
+  if (!o.cwdCheck || !o.cwdChdir) return {};
+  return { cwdCheck: o.cwdCheck, cwdChdir: o.cwdChdir };
+}
+function inheritedCwd(chdir, parent) {
+  return chdir ? void 0 : parent;
+}
+
 // src/fs/copy.ts
 async function present2(fs, path) {
   return fs.lstat(path).then(
@@ -20936,6 +21079,8 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-list",
   "proc-alarm",
   "proc-umask",
+  "cwd-check",
+  "cwd-chdir",
   "proc-cred",
   "proc-setcred",
   "dl-log",
@@ -22261,6 +22406,14 @@ var WasmProcess = class {
         return { ok: true, kind: "void" };
       case "proc-umask":
         return { ok: true, kind: "json", json: this.setUmask(req.mask) };
+      case "cwd-check":
+        return {
+          ok: true,
+          kind: "json",
+          json: await this.options.cwdCheck?.() ?? { gen: 0, alive: true }
+        };
+      case "cwd-chdir":
+        return { ok: true, kind: "json", json: await this.options.cwdChdir?.(req.path) ?? {} };
       case "proc-cred":
         return { ok: true, kind: "json", json: copyCred(this.cred) };
       case "proc-setcred":
@@ -22810,6 +22963,7 @@ function processInit(opts, sab, umask, cred, lane) {
     umask,
     cred,
     ...opts.changes ? { changes: opts.changes } : {},
+    ...heldInit(opts),
     ...opts.owners ? { owners: true } : {},
     ...opts.links !== void 0 ? { links: true } : {},
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
@@ -22883,6 +23037,7 @@ function processOptions(opts, header4, hooks, created4) {
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     ...opts.settling ? { settling: opts.settling } : {},
+    ...heldHooks(opts),
     spawner: opts.spawner,
     forker: opts.forker,
     ...opts.fork?.dl ? { dl: opts.fork.dl } : {},
@@ -22933,6 +23088,7 @@ function threadInit(opts, program, sab, cred, thread, main) {
     owners: opts.owners === true,
     ...opts.links !== void 0 ? { links: true } : {},
     ...opts.changes ? { changes: opts.changes } : {},
+    ...heldInit(opts),
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
     thread,
     signals: main
@@ -26632,6 +26788,11 @@ var Launcher = class {
   hostname;
   watchers = new FsWatchers();
   changes = new FileChanges();
+  cwds = new CwdTable(async (path) => {
+    const { dev, ino } = await this.base.stat(path);
+    return `${dev ?? 0}:${ino}`;
+  });
+  cwdSlots = /* @__PURE__ */ new Map();
   pnpmHome;
   pnpmChain;
   pnpmMade;
@@ -26688,7 +26849,10 @@ var Launcher = class {
     this.sealed.tickets.normalise = (path) => physicalPathAsync(this.base, path);
     this.sealed.userOf = async (uid) => (await this.users.lookup(uid))?.name;
     if (this.owners) options.fs.trackOwners?.();
-    this.watchers.tap((paths) => this.changes.publish(...paths));
+    this.watchers.tap((paths) => {
+      this.changes.publish(...paths);
+      this.cwds.touched(paths);
+    });
     this.watchers.onReshape(() => {
       for (const nodes of this.openFiles) nodes.reshaped();
     });
@@ -26758,6 +26922,7 @@ var Launcher = class {
     options.fs.onPeer?.(() => this.flushOpen());
     options.fs.remoteChanges?.((change) => {
       this.changes.flush();
+      this.cwds.touched(change.paths, change.trees);
       this.rewritten(change.paths, change.trees);
     });
     const holders = [this.held, this.openFiles];
@@ -27540,11 +27705,12 @@ var Launcher = class {
     }
     const done4 = this.heldUrl(program);
     try {
+      const cwdSlot = await this.cwds.hold(cwd, req.cwdFrom);
       const handle = await this.admitted(
         program.abi !== "js",
         req.fds,
-        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env })
-      );
+        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env, cwdSlot })
+      ).finally(() => this.cwds.release(cwdSlot));
       void handle.exited.finally(done4);
       return handle;
     } catch (err) {
@@ -27631,6 +27797,8 @@ var Launcher = class {
       throw new SpawnError("ESRCH");
     }
     const pid = req.pid ?? this.nextPid++;
+    const cwdSlot = this.cwds.share(req.cwdSlot);
+    this.cwdSlots.set(pid, cwdSlot);
     const scrubs = this.treeScrubs(req);
     const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
@@ -27665,6 +27833,7 @@ var Launcher = class {
       ...this.dac ? { dac: this.dac } : {},
       program: req.program,
       changes: this.changes.sab,
+      ...this.heldFor(pid, cwdSlot),
       argv0: req.argv0,
       args: req.args,
       env: req.env,
@@ -27739,6 +27908,8 @@ var Launcher = class {
       (state) => state === "stopped" ? this.stopped.add(pid) : this.stopped.delete(pid)
     );
     void handle.exited.then(() => {
+      this.cwds.release(this.cwdSlots.get(pid));
+      this.cwdSlots.delete(pid);
       this.freshModules.forget(pid);
       const spent = handle.times?.();
       if (spent) this.spent.set(pid, spent);
@@ -27970,6 +28141,7 @@ var Launcher = class {
       const handle = await this.launch(planned, {
         ...deciding ? { decided: deciding.promise } : {},
         cwd: req.cwd,
+        cwdFrom: inheritedCwd(req.chdir, this.cwdSlots.get(ppid)),
         ...redeemed,
         fds,
         report,
@@ -28031,6 +28203,24 @@ var Launcher = class {
       for (const resolve2 of waiting) resolve2(true);
     }, 0);
   }
+  heldFor(pid, slot2) {
+    return {
+      cwds: this.cwds.sab,
+      cwdSlot: slot2,
+      cwdState: this.cwds.stateOf(slot2),
+      cwdCheck: async () => {
+        const current = this.cwdSlots.get(pid);
+        return { ...await this.cwds.check(current), slot: current };
+      },
+      cwdChdir: (path) => this.chdirHeld(pid, path)
+    };
+  }
+  async chdirHeld(pid, path) {
+    this.cwds.release(this.cwdSlots.get(pid));
+    const slot2 = await this.cwds.hold(path);
+    this.cwdSlots.set(pid, slot2);
+    return { slot: slot2, ...this.cwds.stateOf(slot2) };
+  }
   forker(ppid, parent) {
     const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
     return async (state, given) => {
@@ -28038,6 +28228,7 @@ var Launcher = class {
         ...image,
         quietOom,
         cwd: state.cwd ?? parent.cwd,
+        cwdSlot: this.cwdSlots.get(ppid),
         fds,
         ppid,
         fork: state,