@ai-ecoverse/slicc-kernel 1.117.3 → 1.117.5

package/dist/node.js

@@ -3994,22 +3994,54 @@ var RemoteWatch = class {
   mine = [];
   seq = 0;
   pruned = 0;
+  joined;
+  met;
+  quiet;
   constructor(name2, options = {}) {
     this.name = name2;
     this.locks = options.locks === void 0 ? lockManager() : options.locks ?? void 0;
     this.channel = new BroadcastChannel(name2);
     this.channel.onmessage = ({ data }) => this.receive(data);
     this.channel.unref?.();
-    void this.locks?.request(this.lockOf(this.tab), () => new Promise(() => {
-    }));
+    const granted2 = new Promise((resolve2) => {
+      void this.locks?.request(this.lockOf(this.tab), () => {
+        resolve2();
+        return new Promise(() => {
+        });
+      });
+      if (!this.locks) resolve2();
+    });
+    this.joined = granted2.then(() => this.join());
     this.channel.postMessage({ hello: this.tab });
   }
+  async join() {
+    if (!this.locks) return;
+    const prefix = `${this.name}:`;
+    const mine = this.lockOf(this.tab);
+    const held = ((await this.locks.query()).held ?? []).map((lock) => lock.name ?? "");
+    if (!held.some((name2) => name2.startsWith(prefix) && name2 !== mine) || this.peers.size > 0)
+      return;
+    await new Promise((resolve2) => {
+      const timer = setTimeout(resolve2, ANNOUNCE_WAIT_MS);
+      this.met = () => {
+        clearTimeout(timer);
+        resolve2();
+      };
+    });
+  }
+  async peered() {
+    await this.joined;
+    return this.peers.size > 0;
+  }
   lockOf(tab) {
     return `${this.name}:${tab}`;
   }
   receive(data) {
     if (data.hello !== void 0) this.greeted(data.hello);
-    if (data.here !== void 0 && data.to === this.tab) this.peers.add(data.here);
+    if (data.here !== void 0 && data.to === this.tab) {
+      this.peers.add(data.here);
+      this.met?.();
+    }
     if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
     if (data.ack !== void 0 && data.to === this.tab && data.from !== void 0) {
       this.acked(data.ack, data.from);
@@ -4018,8 +4050,12 @@ var RemoteWatch = class {
   }
   greeted(peer) {
     this.peers.add(peer);
-    this.channel.postMessage({ here: this.tab, to: peer });
-    if (this.mine.length > 0) void this.announce(this.mine);
+    const answer = () => {
+      this.channel.postMessage({ here: this.tab, to: peer });
+      if (this.mine.length > 0) void this.announce(this.mine);
+    };
+    if (this.quiet) void this.quiet().then(answer, answer);
+    else answer();
   }
   announced({ tab, paths, seq: seq2 }) {
     const from = tab;
@@ -4119,6 +4155,7 @@ var READ_ATTEMPTS = 3;
 var MAX_LINKS5 = 40;
 var CHECK_MS = 1e3;
 var ABSENT_MS = 2;
+var GLANCE_MS = 2;
 var ABSENT_NAMES = 4096;
 var FILE_HANDLES = 4096;
 var STALE = /* @__PURE__ */ new Set(["NotFoundError", "TypeMismatchError"]);
@@ -4255,7 +4292,7 @@ var OpfsFs = class {
   changes = 0;
   replacing = Promise.resolve();
   replacements = 0;
-  snapshots = /* @__PURE__ */ new WeakMap();
+  glances = /* @__PURE__ */ new WeakMap();
   found = /* @__PURE__ */ new WeakMap();
   checked = /* @__PURE__ */ new WeakMap();
   channel;
@@ -4274,6 +4311,7 @@ var OpfsFs = class {
     this.lockPrefix = `slicc-excl:${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();
     if (this.channel) {
       const remote = this.remote;
       meta.listen?.(
@@ -4417,8 +4455,24 @@ var OpfsFs = class {
       throw fsError("EROFS", path);
     }
   }
+  unlocked = 0;
+  idle = [];
+  async alone(op) {
+    this.unlocked++;
+    try {
+      return await op();
+    } finally {
+      this.unlocked--;
+      if (this.unlocked === 0) for (const done4 of this.idle.splice(0)) done4();
+    }
+  }
+  quiet() {
+    if (this.unlocked === 0) return Promise.resolve();
+    return new Promise((resolve2) => this.idle.push(resolve2));
+  }
   async locked(physicalPath, op) {
     if (!this.locks) return op();
+    if (this.remote && !await this.remote.peered()) return this.alone(op);
     const key = `${this.lockPrefix}${physicalPath}`;
     let result;
     await this.locks.request(key, async () => {
@@ -4509,7 +4563,7 @@ var OpfsFs = class {
     if (handle.kind !== "file") return handle;
     if (looked) {
       this.found.set(handle, performance.now());
-      this.snapshots.delete(handle);
+      this.glances.delete(handle);
     }
     this.files.delete(path);
     if (this.files.size >= FILE_HANDLES)
@@ -4543,14 +4597,15 @@ var OpfsFs = class {
     const fresh2 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
     if (cached && !fresh2) this.files.delete(path);
     if (cached && fresh2) {
+      if (this.glanced(cached)) return this.remember(path, cached);
       try {
-        this.snapshots.set(cached, await cached.getFile());
+        await this.glance(cached);
         return this.remember(path, cached);
       } catch (err) {
         if (!STALE.has(err?.name))
           throw translate(err, path, "read");
         this.files.delete(path);
-        this.snapshots.delete(cached);
+        this.glances.delete(cached);
       }
     }
     const kept = this.dirs.get(path);
@@ -4743,11 +4798,25 @@ var OpfsFs = class {
         if (this.dirTimes.get(path) === ms) this.dirTimes.delete(path);
     }
   }
+  glanced(handle) {
+    const seen = this.glances.get(handle);
+    const fresh2 = seen && seen.changes === this.changes && performance.now() - seen.at < GLANCE_MS;
+    return fresh2 ? seen.file : void 0;
+  }
+  async glance(handle) {
+    const at = performance.now();
+    const before = this.changes;
+    const file = await handle.getFile();
+    if (before === this.changes) this.glances.set(handle, { at, file, changes: before });
+    else this.glances.delete(handle);
+    return file;
+  }
+  wrote(handle) {
+    this.changes++;
+    this.glances.delete(handle);
+  }
   async snapshot(handle) {
-    const taken = this.snapshots.get(handle);
-    if (!taken) return handle.getFile();
-    this.snapshots.delete(handle);
-    return taken;
+    return this.glanced(handle) ?? this.glance(handle);
   }
   async statOf(path, handle, meta, touched) {
     const directory = handle.kind === "directory";
@@ -4882,9 +4951,11 @@ var OpfsFs = class {
   async pwrite(path, offset, bytes) {
     const [handle, , target] = await this.fileFor(path);
     await this.counting(target);
+    this.wrote(handle);
     try {
       await this.retrying(path, () => positioned(handle, (io) => io.write(offset, bytes)), true);
     } finally {
+      this.wrote(handle);
       await this.recounting(handle, target);
     }
     this.written(target);
@@ -4895,9 +4966,11 @@ var OpfsFs = class {
     const resolve2 = this.ranged || this.remote?.watched();
     const target = resolve2 || this.counted.length > 0 ? (await this.locate(path, true)).path : path;
     await this.counting(target);
+    this.wrote(handle);
     try {
       await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
     } finally {
+      this.wrote(handle);
       await this.recounting(handle, target);
     }
     this.written(target);
@@ -4917,9 +4990,12 @@ var OpfsFs = class {
         throw translate(err, path, "write", false);
       }),
       close: async () => {
+        this.wrote(handle);
         await writable2.close().catch((err) => {
+          this.wrote(handle);
           throw translate(err, path, "commit", false);
         });
+        this.wrote(handle);
         this.committed(target);
       }
     };
@@ -4966,6 +5042,7 @@ var OpfsFs = class {
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
     let writable2;
+    this.wrote(file);
     try {
       writable2 = await file.createWritable();
       await writable2.write(content);
@@ -4973,6 +5050,8 @@ var OpfsFs = class {
     } catch (err) {
       await writable2?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
+    } finally {
+      this.wrote(file);
     }
     this.committed(target);
   }
@@ -5226,7 +5305,7 @@ var OpfsFs = class {
   }
   async modified(path) {
     const handle = await this.handle(path);
-    return handle.kind === "file" ? (await handle.getFile()).lastModified : 0;
+    return handle.kind === "file" ? (await this.snapshot(handle)).lastModified : 0;
   }
   async explicitTimes(path) {
     const timed2 = [];
@@ -6656,7 +6735,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.117.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.117.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
@@ -8885,6 +8964,7 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
     readlink: (path) => fs.readlink(path),
     ...fs.realpath ? { realpath: fs.realpath.bind(fs) } : {},
     ...fs.chown ? { chown: fs.chown.bind(fs) } : {},
+    ...fs.createExclusive ? { createExclusive: fs.createExclusive.bind(fs) } : {},
     ...fs.ancestry ? { ancestry: fs.ancestry.bind(fs) } : {},
     ...fs.hasOwner ? { hasOwner: fs.hasOwner.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
@@ -9184,6 +9264,7 @@ var FsWatchers = class {
     };
     const overrides = {
       writeFile: content(fs.writeFile.bind(fs)),
+      ...fs.createExclusive ? { createExclusive: content(fs.createExclusive.bind(fs)) } : {},
       mkdir: async (path, options) => {
         const created3 = [];
         if (options?.recursive) {
@@ -10880,6 +10961,23 @@ var MountFs = class _MountFs {
       throw err;
     }
   }
+  async createExclusive(path, owner, redirects = 0) {
+    const exclusive = this.base.createExclusive?.bind(this.base);
+    if (!this.at(path) && exclusive) {
+      return this.based(
+        [path],
+        redirects,
+        () => exclusive(path, owner),
+        ([to], n) => this.createExclusive(to, owner, n)
+      );
+    }
+    const there = await this.lstat(path).then(
+      () => true,
+      () => false
+    );
+    if (there) throw errnoError("EEXIST", path);
+    await this.writeFile(path, new Uint8Array(0), owner);
+  }
   async lstat(path, redirects = 0) {
     const found = this.at(path);
     if (!found) {
@@ -16958,7 +17056,10 @@ var VfsNodes = class {
     return this.onEntry(path, async () => {
       const node = this.byPath.get(path);
       const held = node ? await node.serial(async () => node.holds()) : false;
-      if (held || await present2(this.fs, path)) throw fsError("EEXIST", path);
+      if (held) throw fsError("EEXIST", path);
+      const exclusive = this.fs.createExclusive;
+      if (exclusive) return exclusive.call(this.fs, path, owner);
+      if (await present2(this.fs, path)) throw fsError("EEXIST", path);
       await this.fs.writeFile(path, new Uint8Array(0), owner);
     });
   }