@ai-ecoverse/slicc-kernel 1.152.0 → 1.152.2

package/dist/node.js

@@ -3365,7 +3365,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.152.0" : "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
@@ -4242,6 +4242,7 @@ var PathMarks = class {
   floor = 0;
   touched = /* @__PURE__ */ new Map();
   flying = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Set();
   generation() {
     return this.gen;
   }
@@ -4274,10 +4275,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 = parentOf2(p)) {
       if (this.flying.has(p)) return true;
@@ -4468,6 +4481,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);
   }
@@ -6324,9 +6340,9 @@ function withEtcFiles(fs, files) {
     readFileBuffer: (path) => fs.readFileBuffer(path).catch(fallback(path, (b) => b)),
     ...ranged2 ? {
       pread: (path, offset, length2, version) => ranged2.pread(path, offset, length2, version).catch(fallback(path, (b) => b.slice(offset, offset + length2))),
-      pwrite: async (path, offset, bytes, transfer) => {
+      pwrite: async (path, offset, bytes, transfer, options) => {
         if (files.has(path)) await materialize(path);
-        return ranged2.pwrite(path, offset, bytes, transfer);
+        return ranged2.pwrite(path, offset, bytes, transfer, options);
       },
       truncate: async (path, size) => {
         if (files.has(path)) await materialize(path);
@@ -6435,10 +6451,10 @@ var FreshModules = class {
     };
     const ranged2 = rangedOps(fs);
     if (ranged2) {
-      overrides.pwrite = async (path, at, bytes, transfer) => {
+      overrides.pwrite = async (path, at, bytes, transfer, options) => {
         const touches3 = at < MAGIC.length && this.fresh.has(normalizePath(path));
         const first = at === 0 && bytes.length >= MAGIC.length ? bytes.slice(0, MAGIC.length) : void 0;
-        await ranged2.pwrite(path, at, bytes, transfer);
+        await ranged2.pwrite(path, at, bytes, transfer, options);
         if (touches3) await decide(path, first);
       };
       overrides.truncate = async (path, size) => {
@@ -8119,6 +8135,9 @@ var HeldSet = class extends Set {
       if (over !== void 0) holds2.doubt(over);
     }
   }
+  async bindIds(id2) {
+    for (const holds2 of [...this]) await holds2.bindIds(id2);
+  }
   delete(holds2) {
     const removed = super.delete(holds2);
     for (const path of /* @__PURE__ */ new Set([...holds2.keys(), ...holds2.opens.keys()])) this.idle(path);
@@ -8172,12 +8191,24 @@ var HeldPaths = class extends Map {
   }
   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 };
+    const bound3 = this.bound.get(handle);
+    return doubt === void 0 || bound3 === void 0 ? void 0 : { ...bound3, doubt };
+  }
+  async bindIds(id2) {
+    for (const [handle, bound3] of [...this.bound]) {
+      const key = this.handles.get(handle);
+      if (bound3.fid !== void 0 || key === void 0) continue;
+      const fid = await id2(key)?.catch(() => void 0);
+      if (fid !== void 0 && this.bound.get(handle) === bound3)
+        this.bound.set(handle, { ...bound3, fid });
+    }
   }
   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);
   }
@@ -8214,14 +8245,15 @@ 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, ino) {
+  hold(path, on, open = false, real, handle, ino, fid) {
     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);
+      if (made2 !== void 0 && ino !== void 0)
+        this.bound.set(made2, fid === void 0 ? { ino } : { ino, fid });
       return made2;
     }
     this.holdWrite(path, on);
@@ -8957,7 +8989,7 @@ var MountFs = class _MountFs {
       );
     }
   }
-  async pwrite(path, offset, bytes, transfer = false, redirects = 0) {
+  async pwrite(path, offset, bytes, transfer = false, options, redirects = 0) {
     const real = await this.follow(path, 0, true);
     const found = this.at(real);
     const { pwrite } = this.base;
@@ -8965,8 +8997,8 @@ var MountFs = class _MountFs {
       return this.based(
         [real],
         redirects,
-        () => pwrite.call(this.base, real, offset, bytes),
-        ([to], n) => this.pwrite(to, offset, bytes, transfer, n)
+        () => pwrite.call(this.base, real, offset, bytes, false, options),
+        ([to], n) => this.pwrite(to, offset, bytes, transfer, options, n)
       );
     }
     if (!found)
@@ -8990,7 +9022,7 @@ var MountFs = class _MountFs {
       op: "open",
       path: rel2,
       write: true,
-      create: true,
+      create: options?.create !== false,
       truncate: false,
       exclusive: false
     });
@@ -9758,7 +9790,7 @@ async function run(entry, path, req) {
     case "truncate":
       return ranged(fs, path, req);
     case "append":
-      return json2(await appended(fs, path, req.body ?? new Uint8Array(0)));
+      return json2(await appended(fs, path, req.body ?? new Uint8Array(0), req.handle));
     default:
       return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
   }
@@ -9902,13 +9934,17 @@ async function holdOp(entry, path, req) {
       await entry.source?.open(path, real);
       await stillThere(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) ?? null);
+        return json2(entry.hold?.(path, on, open, real, void 0, req.ino, fid) ?? null);
     }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
 }
+async function idOf(entry, path) {
+  return await entry.fileId?.(path)?.catch(() => void 0) ?? void 0;
+}
 async function ownEntry(entry, path, real) {
   const own = await entry.fs.realpath?.(path, false).catch((err) => {
     if (err.code !== "ENOENT") throw err;
@@ -10003,14 +10039,14 @@ async function createExclusive(fs, path, owner) {
   await fs.writeFile(path, new Uint8Array(0), owner);
 }
 var appending = /* @__PURE__ */ new Map();
-async function appended(fs, path, body) {
+async function appended(fs, path, body, handle) {
   const key = await fs.realpath?.(path, true).catch(() => void 0) ?? path;
   const before = appending.get(key) ?? Promise.resolve();
   const run2 = before.then(async () => {
     if (fs.append) return fs.append(path, body);
     const size = (await fs.stat(path)).size;
     const ops = rangedOps(fs);
-    if (ops) await ops.pwrite(path, size, body, true);
+    if (ops) await ops.pwrite(path, size, body, true, noCreate(handle));
     else {
       const whole = new Uint8Array(size + body.length);
       whole.set(await fs.readFileBuffer(path));
@@ -10026,6 +10062,9 @@ async function appended(fs, path, body) {
   });
   return run2;
 }
+function noCreate(handle) {
+  return handle === void 0 ? void 0 : { create: false };
+}
 async function ranged(fs, path, req) {
   const ops = rangedOps(fs);
   if (!ops) throw syncError("ENOSYS", path);
@@ -10036,7 +10075,8 @@ async function ranged(fs, path, req) {
       kind: "bytes",
       bytes: await ops.pread(path, offset, req.length ?? 0, req.version)
     };
-  if (req.op === "pwrite") await ops.pwrite(path, offset, req.body ?? new Uint8Array(0), true);
+  if (req.op === "pwrite")
+    await ops.pwrite(path, offset, req.body ?? new Uint8Array(0), true, noCreate(req.handle));
   else await ops.truncate(path, req.length ?? 0);
   return done;
 }
@@ -10052,12 +10092,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;
@@ -10066,7 +10114,10 @@ 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) {
+  if (now === void 0 && bound3.fid !== void 0 && !await entry.fs.lstat(path).catch(() => void 0))
+    throw syncError("ENOENT", path);
+  const same2 = bound3.fid === void 0 ? now?.ino === bound3.ino : now?.fid === bound3.fid || await idOf(entry, path) === bound3.fid;
+  if (same2) {
     entry.trust?.(handle, bound3.doubt);
     return;
   }
@@ -10247,8 +10298,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);
@@ -10880,6 +10930,8 @@ var SYS_TREE = {
     slicc_rename_ack_busy: (listing) => `${listing.renameAcks?.busy ?? 0}
 `,
     slicc_stale_fds: (listing) => `${listing.staleFds ?? 0}
+`,
+    slicc_file_ids: (listing) => `${listing.fileIds ?? 0}
 `,
     slicc_rename_acks: (listing) => {
       const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
@@ -19387,10 +19439,10 @@ function heldIo(fs, nodes, changed) {
         const held = await node(path);
         return held ? held.byName(() => held.pread(n, at)) : ranged2.pread(path, at, n, version);
       },
-      pwrite: (path, at, bytes, transfer) => write(
+      pwrite: (path, at, bytes, transfer, options) => write(
         path,
         async (held) => void await held.pwrite(bytes, at),
-        () => ranged2.pwrite(path, at, bytes, transfer)
+        () => ranged2.pwrite(path, at, bytes, transfer, options)
       ),
       truncate: (path, size) => write(
         path,
@@ -21675,11 +21727,13 @@ function holdingToken(opts, holds2, caller) {
     cwd: opts.cwd,
     ...opts.statfs ? { statfs: opts.statfs } : {},
     ...opts.renames ? { renames: opts.renames } : {},
+    ...opts.fileId ? { fileId: opts.fileId } : {},
     ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
-    hold: (path, on, open, real, handle, ino) => holds2.hold(path, on, open, real, handle, ino),
+    hold: (path, on, open, real, handle, ino, fid) => holds2.hold(path, on, open, real, handle, ino, fid),
     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),
@@ -24095,9 +24149,10 @@ var OpfsFs = class {
   }
   async fileId(path) {
     const found = await this.locate(path, true);
-    const [entry] = await this.meta.get([found.path]);
+    const [entry] = await (this.meta.fresh ?? this.meta.get).call(this.meta, [found.path]);
     if (entry?.fid !== void 0) return entry.fid;
     const fid = crypto.randomUUID();
+    this.idWrites++;
     await this.meta.update(found.path, (now) => ({
       ...occupied(now),
       path: found.path,
@@ -24368,6 +24423,10 @@ var OpfsFs = class {
   opfsCalls() {
     return this.calls;
   }
+  idWrites = 0;
+  fileIdWrites() {
+    return this.idWrites;
+  }
   opfsOps() {
     return this.calls + this.others;
   }
@@ -24827,7 +24886,7 @@ var OpfsFs = class {
       return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
     });
   }
-  async pwrite(path, offset, bytes) {
+  async pwrite(path, offset, bytes, _transfer, options) {
     const at = normalizePath(path);
     const movedAway = this.renamesInFlight() ? await this.writeWaits(at) : false;
     this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
@@ -24842,7 +24901,10 @@ var OpfsFs = class {
           this.files.delete(target);
         }
       }
-      const [handle] = await this.fileFor(path, !existed && !movedAway);
+      const [handle] = await this.fileFor(
+        path,
+        !existed && !movedAway && options?.create !== false
+      );
       await this.writeAt(handle, target, path, offset, bytes);
     } finally {
       this.writeEnded(at);
@@ -29974,7 +30036,8 @@ var Launcher = class {
         opfsOps: this.rootFs.opfsOps?.() ?? 0,
         cwdChecks: this.cwds.checks,
         renameAcks: this.rootFs.renameWaits?.(),
-        staleFds: staleFdCount()
+        staleFds: staleFdCount(),
+        fileIds: this.rootFs.fileIdWrites?.() ?? 0
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -29985,6 +30048,7 @@ var Launcher = class {
       replacements: stack.unlinked,
       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,
       renameSeq: (from, to) => this.renameLog.seqOf(from, to),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),
@@ -30864,12 +30928,16 @@ var Launcher = class {
     this.writers ??= this.writerStack();
     return this.writers;
   }
+  rootFileId(path) {
+    return this.mounts.locate(path) === void 0 ? this.rootFs.fileId?.(path) : void 0;
+  }
   flushingPeers(fs) {
     const peers = fs.peers?.();
     if (!peers) return void 0;
     peers.watch((crowded) => {
       this.changes.flush();
       this.changes.foreign(crowded);
+      if (crowded) void this.held?.bindIds((path) => this.rootFileId(path));
     });
     return {
       ...peers,
@@ -30955,9 +31023,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) {