@ai-ecoverse/slicc-kernel 1.143.4 → 1.143.6

package/dist/node.js

@@ -3632,7 +3632,8 @@ var SLOT = 2;
 var SHARED_TTL_MS = 100;
 var DIRTY = RING + RING_SIZE * SLOT;
 var FOREIGN = DIRTY + 1;
-var CHANGES_BYTES = (FOREIGN + 1) * 4;
+var RENAMES = FOREIGN + 1;
+var CHANGES_BYTES = (RENAMES + 1) * 4;
 function changeHash(path) {
   let h = 2166136261;
   for (let i = 0; i < path.length; i++) {
@@ -3666,6 +3667,11 @@ var FileChanges = class {
   flush() {
     Atomics.add(this.view, GEN, RING_SIZE + 1);
   }
+  renamed() {
+    const seq2 = Atomics.add(this.view, RENAMES, 1) + 1 | 0;
+    Atomics.notify(this.view, RENAMES);
+    return seq2;
+  }
   publish(...paths) {
     for (const path of paths) {
       const g = Atomics.add(this.view, GEN, 1) + 1 | 0;
@@ -3690,6 +3696,13 @@ var ChangeView = class {
   foreign() {
     return this.view.length > FOREIGN && Atomics.load(this.view, FOREIGN) === 1;
   }
+  renames() {
+    return this.view.length > RENAMES ? Atomics.load(this.view, RENAMES) : 0;
+  }
+  awaitRename(seen, ms) {
+    if (this.view.length > RENAMES) Atomics.wait(this.view, RENAMES, seen, ms);
+    return this.renames();
+  }
   changedSince(seen, path) {
     const now = Atomics.load(this.view, GEN);
     const distance = now - seen >>> 0;
@@ -4546,7 +4559,7 @@ var STALE = /* @__PURE__ */ new Set(["NotFoundError", "TypeMismatchError"]);
 var REPLACED_ATTEMPTS = 4;
 var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
-var RENAMES = "/.slicc-renames";
+var RENAMES2 = "/.slicc-renames";
 var RENAME_LOCK = "slicc-rename:";
 var RENAME_ADMIT = "slicc-rename-admit:";
 var escapeRoot = (name2) => name2.replace(/[%:]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
@@ -4741,7 +4754,8 @@ var OpfsFs = class {
       const remote = this.remote;
       meta.listen?.((c) => {
         for (const path of [...c.paths ?? [], ...c.trees ?? []]) this.forget(path);
-        remote?.emit({ paths: c.paths ?? [], trees: c.trees ?? [] });
+        const moved2 = movedOf(c.moved);
+        remote?.emit({ paths: c.paths ?? [], trees: c.trees ?? [], ...moved2 ? { moved: moved2 } : {} });
       });
       remote?.listen((c) => {
         for (const path of [...c.paths, ...c.trees]) this.forget(path);
@@ -5463,31 +5477,38 @@ var OpfsFs = class {
     });
   }
   async pwrite(path, offset, bytes) {
-    const [kept, target] = await this.keptFor(path);
-    if (kept) {
-      try {
-        await this.writeAt(kept, target, path, offset, bytes);
-        return;
-      } catch (err) {
-        if (err.code !== "ENOENT") throw err;
-        this.files.delete(target);
+    const at = normalizePath(path);
+    const movedAway = this.renamesInFlight() ? await this.writeWaits(at) : false;
+    this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
+    try {
+      const [kept, target, existed] = await this.keptFor(path);
+      if (kept) {
+        try {
+          await this.writeAt(kept, target, path, offset, bytes);
+          return;
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+          this.files.delete(target);
+        }
       }
+      const [handle] = await this.fileFor(path, !existed && !movedAway);
+      await this.writeAt(handle, target, path, offset, bytes);
+    } finally {
+      this.writeEnded(at);
     }
-    const [handle] = await this.fileFor(path);
-    await this.writeAt(handle, target, path, offset, bytes);
   }
   async keptFor(path) {
     const at = normalizePath(path);
     const cached = this.files.get(at);
     const fresh2 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
     const [target, existed] = fresh2 ? [at, true] : await this.writeTarget(path);
-    if (!existed) return [void 0, target];
+    if (!existed) return [void 0, target, false];
     this.refuse(target);
     const [entry] = await this.meta.get([target]);
     if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
     const kept = fresh2 ? cached : this.files.get(target);
     const usable2 = kept && performance.now() - (this.found.get(kept) ?? -CHECK_MS) < CHECK_MS;
-    return [usable2 ? kept : void 0, target];
+    return [usable2 ? kept : void 0, target, true];
   }
   async writeAt(handle, target, path, offset, bytes) {
     await this.counting(target);
@@ -5504,7 +5525,67 @@ var OpfsFs = class {
     }
     this.written(target);
   }
+  fileWrites = /* @__PURE__ */ new Map();
+  movingFiles = /* @__PURE__ */ new Map();
+  writesIdle;
+  writeBlocked(at) {
+    const file = this.movingFiles.get(at);
+    if (file !== void 0) return { done: file, away: true };
+    for (const m of this.renamingDirs) {
+      if (within3(at, m.from)) return { done: m.done, away: true };
+      if (within3(at, m.to)) return { done: m.done, away: false };
+    }
+    return void 0;
+  }
+  renamesInFlight() {
+    return this.movingFiles.size > 0 || this.renamingDirs.size > 0;
+  }
+  async writeWaits(at) {
+    let away = false;
+    for (let busy = this.writeBlocked(at); busy !== void 0; busy = this.writeBlocked(at)) {
+      away ||= busy.away;
+      await busy.done;
+    }
+    return away;
+  }
+  writeEnded(at) {
+    const left = (this.fileWrites.get(at) ?? 1) - 1;
+    if (left > 0) this.fileWrites.set(at, left);
+    else this.fileWrites.delete(at);
+    const idle2 = this.writesIdle;
+    if (idle2 === void 0) return;
+    this.writesIdle = void 0;
+    idle2.resolve();
+  }
+  async writesDrained(tree2) {
+    while ([...this.fileWrites.keys()].some((at) => within3(at, tree2))) {
+      this.writesIdle ??= Promise.withResolvers();
+      await this.writesIdle.promise;
+    }
+  }
+  async movingFile(path, op) {
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    while (this.movingFiles.has(path)) await this.movingFiles.get(path);
+    this.movingFiles.set(path, promise);
+    try {
+      await this.writesDrained(path);
+      return await op();
+    } finally {
+      this.movingFiles.delete(path);
+      resolve2();
+    }
+  }
   async truncate(path, size) {
+    const at = normalizePath(path);
+    if (this.renamesInFlight()) await this.writeWaits(at);
+    this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
+    try {
+      await this.truncated(path, size);
+    } finally {
+      this.writeEnded(at);
+    }
+  }
+  async truncated(path, size) {
     const handle = await this.existing(path, true);
     await this.refuseNode(path, (await this.io(handle.getFile())).size === 0);
     const resolve2 = this.ranged || this.remote?.watched();
@@ -5562,8 +5643,9 @@ var OpfsFs = class {
     const wanted = entry?.link === void 0 ? path : resolvePath(parentOf4(path), entry.link);
     return [resolvePath((await this.locate(parentOf4(wanted), true)).path, baseOf(wanted)), false];
   }
-  async fileFor(path) {
+  async fileFor(path, create = true) {
     const [target, existed] = await this.writeTarget(path);
+    if (!existed && !create) throw fsError("ENOENT", path);
     if (existed) {
       const [entry] = await this.meta.get([target]);
       if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
@@ -5572,7 +5654,7 @@ var OpfsFs = class {
     try {
       const handle = await this.inDir(
         dir,
-        (parent) => this.io(parent.getFileHandle(name2, { create: true }))
+        (parent) => this.io(parent.getFileHandle(name2, { create }))
       );
       if (!existed) this.touch(Date.now(), parentOf4(target));
       return [handle, existed, target];
@@ -5878,11 +5960,12 @@ var OpfsFs = class {
       this.changed(source.path, destination);
       this.touch(Date.now(), parentOf4(source.path), parent.path);
     };
-    if (!copying) return place();
+    if (!copying) return sourceStat.isDirectory ? place() : this.movingFile(source.path, place);
     const { promise, resolve: resolve2 } = Promise.withResolvers();
     const entry = { from: source.path, to: destination, done: promise };
     this.renamingDirs.add(entry);
     try {
+      await this.writesDrained(source.path);
       const locks = this.locks;
       if (locks) {
         lock = `${this.renameLocks()}${crypto.randomUUID()}`;
@@ -5985,7 +6068,7 @@ var OpfsFs = class {
     return name2.startsWith(this.renameLocks()) || LEGACY_RENAME_LOCK.test(name2);
   }
   async learnRenames() {
-    for (const { rename } of await this.meta.under(RENAMES)) {
+    for (const { rename } of await this.meta.under(RENAMES2)) {
       if (rename?.lock === void 0 || this.ownLocks.has(rename.lock)) continue;
       this.notePeer(rename.lock, [rename.from, rename.to]);
     }
@@ -6074,7 +6157,7 @@ var OpfsFs = class {
       if (!move.done)
         await locks.request(move.lock, async () => {
           if (move.done) return;
-          const left = (await this.meta.under(RENAMES)).filter((entry) => entry.rename?.lock === move.lock).sort(byIntent);
+          const left = (await this.meta.under(RENAMES2)).filter((entry) => entry.rename?.lock === move.lock).sort(byIntent);
           for (const entry of left) await this.finishRename(entry);
         });
       this.peerMoves.delete(move.lock);
@@ -6153,7 +6236,7 @@ var OpfsFs = class {
   }
   renamingDirs = /* @__PURE__ */ new Set();
   intents = 0;
-  async intend(rename, at = `${RENAMES}/${crypto.randomUUID()}`) {
+  async intend(rename, at = `${RENAMES2}/${crypto.randomUUID()}`) {
     const record2 = { ...rename, at: Date.now() * 1e3 + this.intents++ % 1e3 };
     await this.meta.update(at, () => ({ path: at, rename: record2 }));
     return at;
@@ -6189,7 +6272,7 @@ var OpfsFs = class {
       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(
+    const intents = (await this.meta.under(RENAMES2)).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
@@ -6241,6 +6324,7 @@ var OpfsFs = class {
         );
       }
       await this.meta.update(entry.path, () => void 0);
+      this.remote?.emit({ paths: [], trees: [], moved: { from, to } });
     } finally {
       this.renamingDirs.delete(barrier);
       resolve2();
@@ -6558,6 +6642,10 @@ var OpfsFs = class {
     return removed;
   }
 };
+function movedOf(moved2) {
+  const m = moved2;
+  return typeof m?.from === "string" && typeof m.to === "string" ? { from: m.from, to: m.to } : void 0;
+}
 function nothing() {
   return void 0;
 }
@@ -7982,7 +8070,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.143.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.143.6" : "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
@@ -13039,7 +13127,8 @@ var SYNC_FS_OPS = [
   "truncate",
   "chown",
   "lchown",
-  "access"
+  "access",
+  "renames"
 ];
 var HOLD_READ = 4;
 var HOLD_WRITE = 8;
@@ -13087,6 +13176,30 @@ async function readdirStat(fs, dir, g) {
   const shown = async (name2, stat) => stat && statJson(await callerStat(g, joinName(dir, name2), stat));
   return Promise.all(listed.map(async ([name2, stat]) => [name2, await shown(name2, stat)]));
 }
+async function visibleRenames(entry, req) {
+  const answer2 = entry.renames?.(req.offset ?? 0, heldPaths(req.arg2)) ?? { now: 0, renames: [] };
+  const g = guardOf(entry);
+  if (!g?.dac.enforcing) return answer2;
+  const searchable2 = async (path) => {
+    const dir = path.slice(0, Math.max(1, path.lastIndexOf("/")));
+    const w = await walk(g.fs, g.cred, dir, true, g.links).catch(nothing2);
+    if (w === false || w.denied || w.perm === void 0 || !permits(g.cred, w.perm, X_OK))
+      return false;
+    return g.fs.stat(w.path).then((st) => st.isDirectory, nothing2);
+  };
+  const shown = [];
+  for (const [from, to] of answer2.renames) {
+    if (await searchable2(from) && await searchable2(to)) shown.push([from, to]);
+  }
+  return { now: answer2.now, renames: shown };
+}
+function nothing2() {
+  return false;
+}
+function heldPaths(arg) {
+  const held = JSON.parse(arg ?? "[]");
+  return Array.isArray(held) ? held.filter((path) => typeof path === "string") : [];
+}
 async function usageAt(entry, path) {
   if (!entry.statfs) return void 0;
   const real = await realTarget(entry.fs, path).catch(() => path);
@@ -13204,7 +13317,8 @@ async function run(entry, path, req) {
       const to = fs.resolvePath(cwd, req.arg2 ?? "");
       await fs.rename(path, to);
       entry.renamed?.(path, to);
-      return done;
+      const seq2 = entry.renameSeq?.(path, to);
+      return seq2 === void 0 ? done : json2({ seq: seq2 });
     }
     case "link":
       await fs.link(path, fs.resolvePath(cwd, req.arg2 ?? ""), req.mode === 1);
@@ -13676,6 +13790,7 @@ async function linkFree(fs, path) {
   }
 }
 async function dispatchOne(entry, req) {
+  if (req.op === "renames") return json2(await visibleRenames(entry, req));
   const result = await dispatchPath(entry, req);
   if (result.ok || result.errno !== "ENOENT" || !req.direct || !MISS_OPS.has(req.op) || req.handle !== void 0) {
     return result;
@@ -21717,6 +21832,7 @@ var VfsNodes = class {
   byId = /* @__PURE__ */ new Map();
   keepsOnDisk = false;
   changed;
+  movedAway;
   dirtied;
   fs;
   entries;
@@ -22146,6 +22262,7 @@ function keepingOpen(fs, nodes, changed = () => {
         await nodes.unlinking(b);
         await fs.rename(from, to);
         nodes.renamed(a, b);
+        nodes.movedAway?.(a, b);
       });
     },
     writeFile: async (path, content, owner) => {
@@ -24369,6 +24486,8 @@ function holdingToken(opts, holds2, caller) {
     noLinks: opts.noLinks,
     cwd: opts.cwd,
     ...opts.statfs ? { statfs: opts.statfs } : {},
+    ...opts.renames ? { renames: opts.renames } : {},
+    ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
     hold: (path, on, open, real, handle) => holds2.hold(path, on, open, real, handle),
     keptFor: (handle) => holds2.keptFor(handle),
     unlinked: (path) => holds2.keptAt(path),
@@ -25738,6 +25857,43 @@ function replayingHops(inner, heldMs = HELD_MS) {
   };
 }
 
+// src/kernel/rename-log.ts
+var RENAME_LOG_SIZE = 4096;
+function within9(path, root) {
+  return path === root || path.startsWith(root === "/" ? "/" : `${root}/`);
+}
+var RenameLog = class {
+  changes;
+  entries = [];
+  constructor(changes) {
+    this.changes = changes;
+  }
+  add(from, to) {
+    const seq2 = this.changes.renamed();
+    this.entries.push({ seq: seq2, from, to });
+    if (this.entries.length > RENAME_LOG_SIZE) this.entries.shift();
+    return seq2;
+  }
+  seqOf(from, to) {
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const entry = this.entries[i];
+      if (entry.from === from && entry.to === to) return entry.seq;
+    }
+    return void 0;
+  }
+  since(seen, held) {
+    const now = this.entries.at(-1)?.seq ?? seen;
+    const renames = [];
+    let paths = [...held];
+    for (const { seq: seq2, from, to } of this.entries) {
+      if (seq2 <= seen || !paths.some((path) => within9(path, from))) continue;
+      renames.push([from, to]);
+      paths = paths.map((path) => within9(path, from) ? to + path.slice(from.length) : path);
+    }
+    return { now, renames };
+  }
+};
+
 // src/kernel/net/sealed-scrubs.ts
 function addTo(tree2, host, secrets) {
   const entry = tree2.get(host) ?? { secrets: [], version: 0, scrubber: void 0 };
@@ -28563,6 +28719,7 @@ var Launcher = class {
   hostname;
   watchers = new FsWatchers();
   changes = new FileChanges();
+  renameLog = new RenameLog(this.changes);
   cwds = new CwdTable(async (path) => {
     const { dev, ino } = await this.base.stat(path);
     return `${dev ?? 0}:${ino}`;
@@ -28701,6 +28858,7 @@ var Launcher = class {
     this.openFiles.add(this.nodes);
     options.fs.onPeer?.(() => this.flushOpen());
     options.fs.remoteChanges?.((change) => {
+      if (change.moved) this.moved(change.moved.from, change.moved.to);
       this.changes.flush();
       this.cwds.touched(change.paths, change.trees);
       this.rewritten(change.paths, change.trees);
@@ -29717,6 +29875,8 @@ var Launcher = class {
       unlinkGate: stack.unlinked.gate,
       replacements: stack.unlinked,
       statfs: (path) => this.mounts.statfs(path),
+      renames: (since2, held) => this.renameLog.since(since2, held),
+      renameSeq: (from, to) => this.renameLog.seqOf(from, to),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),
       umount: (target, flags2) => this.processUmount(pid, target, flags2),
@@ -30664,8 +30824,15 @@ var Launcher = class {
     const target = command && (command.shows ?? command.script ?? command.wasm);
     return target === void 0 ? void 0 : { path: target, ...owner ? { owner } : {} };
   }
+  moved(from, to, source) {
+    this.renameLog.add(from, to);
+    if (source) return;
+    for (const nodes of this.openFiles) nodes.renamed(from, to);
+    this.watchers.moved(from, to);
+  }
   processChain(fs, nodes, unlinked) {
     nodes.changed = (path) => this.changes.publish(path);
+    nodes.movedAway = (from, to) => this.moved(from, to, nodes);
     nodes.dirtied = (delta) => this.changes.dirtied(delta);
     return unlinked.wrap(keepingOpen(fs, nodes, (path) => this.changes.publish(path)));
   }