@ai-ecoverse/slicc-kernel 1.152.1 → 1.152.2

package/dist/kernel-worker.js

@@ -7926,7 +7926,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.152.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.152.2" : "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
@@ -8803,6 +8803,7 @@ var PathMarks = class {
   floor = 0;
   touched = /* @__PURE__ */ new Map();
   flying = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Set();
   generation() {
     return this.gen;
   }
@@ -8835,10 +8836,22 @@ var PathMarks = class {
         const n = (this.flying.get(p) ?? 1) - 1;
         if (n > 0) this.flying.set(p, n);
         else this.flying.delete(p);
+        for (const wake of [...this.waiting]) wake();
         this.touch(p);
       }
     }
   }
+  async landed(path) {
+    if (!this.inFlight(path)) return;
+    await new Promise((resolve2) => {
+      const wake = () => {
+        if (this.inFlight(path)) return;
+        this.waiting.delete(wake);
+        resolve2();
+      };
+      this.waiting.add(wake);
+    });
+  }
   inFlight(path) {
     for (let p = path; this.flying.size > 0; p = parentOf5(p)) {
       if (this.flying.has(p)) return true;
@@ -9016,6 +9029,9 @@ var UnlinkedKeeper = class {
   changedSince(path, gen) {
     return this.marks.changedSince(path, gen);
   }
+  landed(path) {
+    return this.marks.landed(path);
+  }
   inFlight(path) {
     return this.marks.inFlight(path);
   }
@@ -12170,6 +12186,9 @@ var HeldPaths = class extends Map {
   trust(handle, doubt) {
     if (this.doubted.get(handle) === doubt) this.doubted.delete(handle);
   }
+  pathOf(handle) {
+    return this.handles.get(handle);
+  }
   keptFor(handle) {
     return this.keptHandles.get(handle);
   }
@@ -14053,12 +14072,20 @@ async function linkedElsewhere(fs, path, from) {
   const source = from === void 0 ? void 0 : await fs.lstat(from).catch(() => void 0);
   return !(source && source.ino === st.ino && source.dev === st.dev);
 }
+async function gatedByHandle(entry, opEntry, path, req, opReq) {
+  const heldAt2 = () => req.handle === void 0 ? void 0 : opEntry.heldAt?.(req.handle);
+  if (req.handle !== void 0) await opEntry.replacements?.landed?.(heldAt2() ?? path);
+  const at = heldAt2() ?? path;
+  const serve = async () => run(opEntry, await keptOr(opEntry, at, req.handle), opReq);
+  return entry.gate ? entry.gate(at, serve) : serve();
+}
 async function keptOr(entry, path, handle) {
   if (handle !== void 0) {
     const hidden = entry.keptFor?.(handle)?.hidden;
     if (hidden !== void 0) return hidden;
-    await bound(entry, path, handle);
-    return path;
+    const at = entry.heldAt?.(handle) ?? path;
+    await bound(entry, at, handle);
+    return at;
   }
   const kept = entry.unlinked?.(path);
   return kept && !await entry.fs.exists(path) ? kept.hidden : path;
@@ -14251,8 +14278,7 @@ async function dispatchPath(entry, req) {
     if (entry.revoked?.(resolvedPath))
       return { ok: false, errno: "EIO", message: `${resolvedPath} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
-      const serve = async () => run(opEntry, await keptOr(opEntry, resolvedPath, req.handle), opReq);
-      return await (entry.gate ? entry.gate(resolvedPath, serve) : serve());
+      return await gatedByHandle(entry, opEntry, resolvedPath, req, opReq);
     }
     if (!entry.own || !OWN_OPS.has(req.op)) return await run(opEntry, resolvedPath, opReq);
     const target = resolvedArg2 ?? (TWO_PATHS.has(req.op) ? fs.resolvePath(cwd, req.arg2 ?? "") : resolvedPath);
@@ -25847,6 +25873,7 @@ function holdingToken(opts, holds2, caller) {
     boundIno: holds2.boundIno.bind(holds2),
     trust: holds2.trust.bind(holds2),
     keptFor: (handle) => holds2.keptFor(handle),
+    heldAt: (handle) => holds2.pathOf(handle),
     unlinked: (path) => holds2.keptAt(path),
     gate: (path, op) => opts.unlinkGate && holds2.holding(path) ? opts.unlinkGate.run(holds2.keyOf(path), op) : op(),
     own: (path, op) => holds2.own(path, op),
@@ -31982,9 +32009,9 @@ var Launcher = class {
   }
   moved(from, to, source) {
     this.renameLog.add(from, to);
+    for (const holds2 of this.held) holds2.renamed(from, to);
     if (source) return;
     for (const nodes of this.openFiles) nodes.renamed(from, to);
-    for (const holds2 of this.held) holds2.renamed(from, to);
     this.watchers.moved(from, to);
   }
   processChain(fs, nodes, unlinked) {