@ai-ecoverse/slicc-kernel 1.146.3 → 1.146.5

package/dist/node.js

@@ -3305,7 +3305,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.146.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.146.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
@@ -6386,16 +6386,16 @@ var FreshModules = class {
         if (size < MAGIC.length && this.fresh.has(normalizePath(path))) await decide(path);
       };
     }
-    const bound2 = /* @__PURE__ */ new WeakMap();
+    const bound3 = /* @__PURE__ */ new WeakMap();
     return new Proxy(fs, {
       get(target, key, receiver) {
         if (Object.hasOwn(overrides, key)) return overrides[key];
         const value2 = Reflect.get(target, key, receiver);
         if (typeof value2 !== "function") return value2;
-        let method = bound2.get(value2);
+        let method = bound3.get(value2);
         if (method === void 0) {
           method = value2.bind(target);
-          bound2.set(value2, method);
+          bound3.set(value2, method);
         }
         return method;
       }
@@ -8038,6 +8038,12 @@ var HeldSet = class extends Set {
     holds2.onIdle = this.idle;
     return super.add(holds2);
   }
+  doubt(paths, over) {
+    for (const holds2 of this) {
+      for (const path of paths) holds2.doubt(path, true);
+      if (over !== void 0) holds2.doubt(over);
+    }
+  }
   delete(holds2) {
     const removed = super.delete(holds2);
     for (const path of /* @__PURE__ */ new Set([...holds2.keys(), ...holds2.opens.keys()])) this.idle(path);
@@ -8059,6 +8065,9 @@ var HeldPaths = class extends Map {
   uses = /* @__PURE__ */ new Map();
   lastHandle = 0;
   owning;
+  bound = /* @__PURE__ */ new Map();
+  doubted = /* @__PURE__ */ new Map();
+  doubts = 0;
   onIdle;
   keyOf(path) {
     return this.aliases.get(path) ?? path;
@@ -8079,6 +8088,21 @@ var HeldPaths = class extends Map {
   handlesAt(path) {
     return [...this.handles].filter(([, key]) => key === path).map(([id2]) => id2);
   }
+  doubt(over, exact = false) {
+    if (this.bound.size === 0) return;
+    for (const [handle, key] of this.handles) {
+      if (!this.bound.has(handle) || this.keptHandles.has(handle)) continue;
+      if (exact ? key === over : within5(key, over)) this.doubted.set(handle, ++this.doubts);
+    }
+  }
+  boundIno(handle) {
+    const doubt = this.doubted.get(handle);
+    const ino = this.bound.get(handle);
+    return doubt === void 0 || ino === void 0 ? void 0 : { ino, doubt };
+  }
+  trust(handle, doubt) {
+    if (this.doubted.get(handle) === doubt) this.doubted.delete(handle);
+  }
   keptFor(handle) {
     return this.keptHandles.get(handle);
   }
@@ -8115,8 +8139,16 @@ var HeldPaths = class extends Map {
     for (const file of [...this.uses.keys()]) this.letGo(file, true);
     this.keptHandles.clear();
   }
-  hold(path, on, open = false, real, handle) {
-    if (open) return this.holdOpen(path, on, real, handle);
+  hold(path, on, open = false, real, handle, ino) {
+    if (open) {
+      const made2 = this.holdOpen(path, on, real, handle);
+      if (handle !== void 0) {
+        this.bound.delete(handle);
+        this.doubted.delete(handle);
+      }
+      if (made2 !== void 0 && ino !== void 0) this.bound.set(made2, ino);
+      return made2;
+    }
     this.holdWrite(path, on);
     return void 0;
   }
@@ -9795,7 +9827,7 @@ async function holdOp(entry, path, req) {
       await stillThere(entry, path, req);
       if (req.nofollow && !await ownEntry(entry, path, real ?? path)) continue;
       if (!r || !r.missed(path) && !r.changedSince(path, gen) && !r.inFlight?.(path))
-        return json2(entry.hold?.(path, on, open, real) ?? null);
+        return json2(entry.hold?.(path, on, open, real, void 0, req.ino) ?? null);
     }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
@@ -9945,10 +9977,26 @@ async function linkedElsewhere(fs, path, from) {
   return !(source && source.ino === st.ino && source.dev === st.dev);
 }
 async function keptOr(entry, path, handle) {
-  if (handle !== void 0) return entry.keptFor?.(handle)?.hidden ?? path;
+  if (handle !== void 0) {
+    const hidden = entry.keptFor?.(handle)?.hidden;
+    if (hidden !== void 0) return hidden;
+    await bound(entry, path, handle);
+    return path;
+  }
   const kept = entry.unlinked?.(path);
   return kept && !await entry.fs.exists(path) ? kept.hidden : path;
 }
+async function bound(entry, path, handle) {
+  const bound3 = entry.boundIno?.(handle);
+  if (bound3 === void 0) return;
+  const now = await entry.fs.stat(path).catch(() => void 0);
+  if (now?.ino === bound3.ino) {
+    entry.trust?.(handle, bound3.doubt);
+    return;
+  }
+  staleFds++;
+  throw syncError("ESTALE", path);
+}
 async function keptStat(entry, req) {
   const hidden = entry.keptFor?.(req.handle ?? -1)?.hidden;
   if (hidden === void 0)
@@ -9975,6 +10023,10 @@ var served = 0;
 function servedFsCalls() {
   return served;
 }
+var staleFds = 0;
+function staleFdCount() {
+  return staleFds;
+}
 async function dispatchSyncFs(req) {
   served++;
   const entry = resolveSyncFsToken(req.token);
@@ -10750,6 +10802,8 @@ var SYS_TREE = {
     slicc_cwd_checks: (listing) => `${listing.cwdChecks ?? 0}
 `,
     slicc_rename_ack_busy: (listing) => `${listing.renameAcks?.busy ?? 0}
+`,
+    slicc_stale_fds: (listing) => `${listing.staleFds ?? 0}
 `,
     slicc_rename_acks: (listing) => {
       const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
@@ -15262,7 +15316,7 @@ async function writeAll2(file, bytes) {
   const write = file.write;
   for (let at = 0; at < bytes.length; ) at += await write.call(file, bytes.subarray(at));
 }
-function bound(file, key) {
+function bound2(file, key) {
   const method = file[key];
   return typeof method === "function" ? { [key]: method.bind(file) } : {};
 }
@@ -15354,9 +15408,9 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
     later(stream2.idle());
   };
   return new OpenFile({
-    ...bound(file, "read"),
-    ...bound(file, "peek"),
-    ...bound(file, "stat"),
+    ...bound2(file, "read"),
+    ...bound2(file, "peek"),
+    ...bound2(file, "stat"),
     poll: () => {
       const state = pollFile(file);
       return quiet3() ? state : { ...state, writable: false };
@@ -21075,7 +21129,9 @@ function holdingToken(opts, holds2, caller) {
     ...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),
+    hold: (path, on, open, real, handle, ino) => holds2.hold(path, on, open, real, handle, ino),
+    boundIno: holds2.boundIno.bind(holds2),
+    trust: holds2.trust.bind(holds2),
     keptFor: (handle) => holds2.keptFor(handle),
     unlinked: (path) => holds2.keptAt(path),
     gate: (path, op) => opts.unlinkGate && holds2.holding(path) ? opts.unlinkGate.run(holds2.keyOf(path), op) : op(),
@@ -23303,6 +23359,28 @@ function prefixes(path) {
 function within9(path, root) {
   return path === root || path.startsWith(`${root}/`);
 }
+var unstored = () => Object.assign(new Error("the file system kept fewer bytes than were written"), {
+  code: "ENOSPC"
+});
+var CHECKED_BYTES = 16 * 1024 * 1024;
+var Extent = class {
+  floor = 0;
+  exact;
+  wrote(end) {
+    this.floor = Math.max(this.floor, end);
+    if (this.exact !== void 0) this.exact = Math.max(this.exact, end);
+  }
+  cut(size) {
+    this.exact = size;
+    this.floor = Math.min(this.floor, size);
+  }
+  big() {
+    return Math.max(this.floor, this.exact ?? 0) >= CHECKED_BYTES;
+  }
+  check(size) {
+    if (size < this.floor || this.exact !== void 0 && size < this.exact) throw unstored();
+  }
+};
 var LOCKED = /* @__PURE__ */ new Set(["NotReadableError", "NoModificationAllowedError", "InvalidStateError"]);
 var SYNC_BACKOFF_MS = [5, 10, 20, 40, 80];
 async function openSync(handle) {
@@ -23328,14 +23406,22 @@ function writeAll5(access2, at, bytes) {
   }
 }
 async function positioned(handle, op) {
+  const extent = new Extent();
   const access2 = await openSync(handle);
   if (access2) {
     try {
       op({
-        write: (at, bytes) => writeAll5(access2, at, bytes),
-        truncate: (n) => access2.truncate(n)
+        write: (at, bytes) => {
+          writeAll5(access2, at, bytes);
+          extent.wrote(at + bytes.length);
+        },
+        truncate: (n) => {
+          access2.truncate(n);
+          extent.cut(n);
+        }
       });
       access2.flush();
+      if (access2.getSize) extent.check(access2.getSize());
     } finally {
       access2.close();
     }
@@ -23344,14 +23430,25 @@ async function positioned(handle, op) {
   const writable2 = await handle.createWritable({ keepExistingData: true });
   try {
     await op({
-      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }),
-      truncate: (n) => writable2.truncate(n)
+      write: async (at, bytes) => {
+        await writable2.write({
+          type: "write",
+          position: at,
+          data: bytes
+        });
+        extent.wrote(at + bytes.length);
+      },
+      truncate: async (n) => {
+        await writable2.truncate(n);
+        extent.cut(n);
+      }
     });
   } catch (err) {
     await writable2.abort();
     throw err;
   }
   await writable2.close();
+  if (extent.big()) extent.check((await handle.getFile()).size);
 }
 function isHandle(child) {
   return "kind" in child;
@@ -24326,6 +24423,11 @@ var OpfsFs = class {
       writable2 = await this.io(file.createWritable());
       await writable2.write(content);
       await writable2.close();
+      if (typeof content !== "string" && content.length >= CHECKED_BYTES) {
+        const extent = new Extent();
+        extent.cut(content.length);
+        extent.check((await file.getFile()).size);
+      }
     } catch (err) {
       await writable2?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
@@ -28145,6 +28247,7 @@ var Launcher = class {
     this.openFiles.add(this.nodes);
     options.fs.onPeer?.(() => this.flushOpen());
     options.fs.remoteChanges?.((change) => {
+      this.held.doubt(change.paths, change.moved?.to);
       if (change.moved) this.moved(change.moved.from, change.moved.to);
       this.changes.flush();
       this.cwds.touched(change.paths, change.trees);
@@ -29157,7 +29260,8 @@ var Launcher = class {
         opfsCalls: this.rootFs.opfsCalls?.() ?? 0,
         opfsOps: this.rootFs.opfsOps?.() ?? 0,
         cwdChecks: this.cwds.checks,
-        renameAcks: this.rootFs.renameWaits?.()
+        renameAcks: this.rootFs.renameWaits?.(),
+        staleFds: staleFdCount()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -30135,6 +30239,7 @@ var Launcher = class {
     this.renameLog.add(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) {