@ai-ecoverse/slicc-kernel 1.159.1 → 1.159.3

package/dist/kernel-worker.js

@@ -943,9 +943,9 @@ var ProtectedFs = class {
         }
       } : {},
       ...fs.append ? {
-        async append(path, bytes) {
+        async append(path, bytes, options) {
           await check(path, true);
-          return fs.append.call(fs, path, bytes);
+          return fs.append.call(fs, path, bytes, options);
         }
       } : {},
       ...fs.truncate ? {
@@ -1008,6 +1008,7 @@ var RemoteWatch = class {
   pruned = 0;
   joined;
   met;
+  flushes = /* @__PURE__ */ new Map();
   settled = false;
   quiet;
   crowd;
@@ -1058,9 +1059,24 @@ var RemoteWatch = class {
         resolve2();
       };
     });
+    await Promise.all([...this.flushes.values()].map((flush) => flush.promise));
+  }
+  flushingAt(peer) {
+    if (this.locks && !this.flushes.has(peer)) {
+      this.flushes.set(peer, Promise.withResolvers());
+      void this.mourn(peer);
+    }
+    this.met?.();
+  }
+  flushedAt(peer) {
+    this.flushes.get(peer)?.resolve();
+    this.flushes.delete(peer);
   }
   async peered() {
     await this.joined;
+    while (this.flushes.size > 0) {
+      await Promise.all([...this.flushes.values()].map((flush) => flush.promise));
+    }
     return this.peers.size > 0;
   }
   async joinedAll(cap) {
@@ -1092,7 +1108,9 @@ var RemoteWatch = class {
     if (data.hello !== void 0) this.greeted(data.hello);
     if (data.renaming !== void 0 && data.tab !== void 0) this.heard(data);
     if (data.renamed !== void 0) this.renamed?.(data.renamed);
+    if (data.flushing !== void 0 && data.to === this.tab) this.flushingAt(data.flushing);
     if (data.here !== void 0 && data.to === this.tab) {
+      this.flushedAt(data.here);
       this.arrived(data.here);
       this.met?.();
     }
@@ -1114,9 +1132,10 @@ var RemoteWatch = class {
     const { held = [], pending = [] } = await this.locks.query();
     if (![...held, ...pending].some((lock) => lock.name === name2)) {
       this.mourned.delete(peer);
-      if (tries > 1 && this.peers.has(peer)) {
+      const live = this.peers.has(peer) || this.flushes.has(peer);
+      if (tries > 1 && live) {
         setTimeout(() => void this.mourn(peer, tries - 1), MOURN_RETRY_MS);
-      }
+      } else this.flushedAt(peer);
       return;
     }
     void this.locks.request(name2, async () => {
@@ -1124,6 +1143,7 @@ var RemoteWatch = class {
       this.others.delete(peer);
       this.peers.delete(peer);
       this.ackers.delete(peer);
+      this.flushedAt(peer);
       this.rebuild();
       this.recount();
       this.gone?.();
@@ -1138,8 +1158,12 @@ var RemoteWatch = class {
       this.channel.postMessage({ here: this.tab, to: peer, renames: true });
       if (this.mine.length > 0) void this.announce(this.mine);
     };
-    if (this.quiet) void this.quiet().then(answer2, answer2);
-    else answer2();
+    if (!this.quiet) {
+      answer2();
+      return;
+    }
+    this.channel.postMessage({ flushing: this.tab, to: peer });
+    void this.quiet().then(answer2, answer2);
   }
   heard({ tab, renaming, seq: seq2 }) {
     const ack = () => this.channel.postMessage({ ack: seq2, from: this.tab, to: tab });
@@ -1533,7 +1557,10 @@ var OpfsFs = class {
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
     this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`, { locks: this.locks ?? null });
     if (this.remote) {
-      this.remote.quiet = () => this.quiet().then(() => this.settle?.());
+      this.remote.quiet = () => {
+        const pending = [...this.inFlight];
+        return this.quiet().then(() => Promise.all(pending)).then(() => this.settle?.());
+      };
       this.remote.gone = () => {
         void this.orphans();
         for (const move of [...this.peerMoves.values()]) void this.peerMoved(move);
@@ -2317,7 +2344,7 @@ var OpfsFs = class {
   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);
+    const ended = this.writeStarted(at);
     try {
       const [kept, target, existed] = await this.keptFor(path);
       if (kept) {
@@ -2335,7 +2362,7 @@ var OpfsFs = class {
       );
       await this.writeAt(handle, target, path, offset, bytes);
     } finally {
-      this.writeEnded(at);
+      ended();
     }
   }
   async keptFor(path) {
@@ -2389,6 +2416,17 @@ var OpfsFs = class {
     }
     return away;
   }
+  inFlight = /* @__PURE__ */ new Set();
+  writeStarted(at) {
+    this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    this.inFlight.add(promise);
+    return () => {
+      this.inFlight.delete(promise);
+      resolve2();
+      this.writeEnded(at);
+    };
+  }
   writeEnded(at) {
     const left = (this.fileWrites.get(at) ?? 1) - 1;
     if (left > 0) this.fileWrites.set(at, left);
@@ -2419,20 +2457,22 @@ var OpfsFs = class {
   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);
+    const ended = this.writeStarted(at);
     try {
       await this.ending(path, () => this.truncated(path, size));
     } finally {
-      this.writeEnded(at);
+      ended();
     }
   }
-  async append(path, bytes) {
-    if (!this.locks || !this.remote || !this.shared()) {
+  async append(path, bytes, options) {
+    const crowded = this.locks !== void 0 && this.remote !== void 0 && this.shared();
+    if (!crowded && options?.alone !== true) {
       throw fsError("ENOTSUP", `${path}: appended by position while no other tab shares the root`);
     }
+    if (crowded) await this.remote?.peered();
     const at = normalizePath(path);
     if (this.renamesInFlight()) await this.writeWaits(at);
-    this.fileWrites.set(at, (this.fileWrites.get(at) ?? 0) + 1);
+    const ended = this.writeStarted(at);
     try {
       const found = await this.locate(path, true);
       if (found.handle?.kind !== "file") throw fsError(found.handle ? "EISDIR" : "ENOENT", path);
@@ -2446,7 +2486,7 @@ var OpfsFs = class {
         return end + bytes.length;
       });
     } finally {
-      this.writeEnded(at);
+      ended();
     }
   }
   async ending(path, op) {
@@ -6203,41 +6243,42 @@ var KernelSocket = class _KernelSocket {
   }
   async read(max, signal) {
     const { rx } = this.connection();
-    if (this.refused) throw this.refused;
+    this.drained(rx);
     if (this.readShut || max <= 0) return new Uint8Array(0);
     const bytes = await pipeCall(() => rx.read(max, signal));
-    if (this.refused) throw this.refused;
+    if (bytes.length === 0) this.drained(rx);
     if (bytes.length === 0 && this.reset) throw this.reset;
     return bytes;
   }
   async peek(max, signal) {
     const { rx } = this.connection();
-    if (this.refused) throw this.refused;
+    this.drained(rx);
     if (this.readShut || max <= 0) return new Uint8Array(0);
     const bytes = await pipeCall(() => rx.peek(max, signal));
-    if (this.refused) throw this.refused;
+    if (bytes.length === 0) this.drained(rx);
     if (bytes.length === 0 && this.reset) throw this.reset;
     return bytes;
   }
+  drained(rx) {
+    if (this.refused && rx.buffered === 0) throw this.refused;
+  }
   rightsLink() {
     const link2 = this.connection();
     if (this.domain !== "unix" || this.switch || this.served) throw new KernelError("EOPNOTSUPP");
-    if (this.refused) throw this.refused;
     return link2;
   }
   sendRights(bytes, mark, nonblock, signal) {
     const { tx } = this.rightsLink();
+    if (this.refused) throw this.refused;
     if (this.writeShut) throw new KernelError("EPIPE");
     return pipeCall(() => tx.writeMarked(bytes, (at) => mark(at, tx.inFlight), nonblock, signal));
   }
   async receiveRights(max, nonblock, signal) {
     const { rx } = this.rightsLink();
+    this.drained(rx);
     if (this.readShut || max <= 0) return { bytes: EMPTY, marks: [] };
     const got = await pipeCall(() => rx.receive(max, nonblock, signal));
-    if (this.refused) {
-      for (const mark of got.marks) mark.drop();
-      throw this.refused;
-    }
+    if (got.bytes.length === 0) this.drained(rx);
     return got;
   }
   get secured() {
@@ -8193,7 +8234,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.159.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.159.3" : "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
@@ -10983,9 +11024,9 @@ function withEtcFiles(fs, files) {
     } : {},
     readFile: (path) => fs.readFile(path).catch(fallback(path, (b) => new TextDecoder().decode(b))),
     ...fs.append ? {
-      append: async (path, bytes) => {
+      append: async (path, bytes, options) => {
         if (files.has(path)) await materialize(path);
-        return fs.append.call(fs, path, bytes);
+        return fs.append.call(fs, path, bytes, options);
       }
     } : {},
     readFileBuffer: (path) => fs.readFileBuffer(path).catch(fallback(path, (b) => b)),
@@ -11102,9 +11143,9 @@ var FreshModules = class {
     };
     const { append } = fs;
     if (append) {
-      overrides.append = async (path, bytes) => {
+      overrides.append = async (path, bytes, options) => {
         const fresh3 = this.fresh.has(normalizePath(path));
-        const end = await append.call(fs, path, bytes);
+        const end = await append.call(fs, path, bytes, options);
         if (fresh3 && end - bytes.length < MAGIC.length) await decide(path);
         return end;
       };
@@ -11504,11 +11545,11 @@ var FsWatchers = class {
     };
     const { append } = fs;
     if (append) {
-      overrides.append = async (path, bytes) => {
+      overrides.append = async (path, bytes, options) => {
         let end = 0;
         await content(
           async (_path) => {
-            end = await append.call(fs, path, bytes);
+            end = await append.call(fs, path, bytes, options);
           },
           () => ["change"]
         )(path);
@@ -13706,15 +13747,15 @@ var MountFs = class _MountFs {
       );
     }
   }
-  async append(path, bytes, redirects = 0) {
+  async append(path, bytes, options, redirects = 0) {
     const real = await this.follow(path, 0, true);
     const { append } = this.base;
     if (!this.at(real) && append) {
       return this.based(
         [real],
         redirects,
-        () => append.call(this.base, real, bytes),
-        ([to], n) => this.append(to, bytes, n)
+        () => append.call(this.base, real, bytes, options),
+        ([to], n) => this.append(to, bytes, options, n)
       );
     }
     throw errnoError("ENOTSUP", `${real}: appended by position on a mount`);
@@ -24503,7 +24544,7 @@ function heldIo(fs, nodes, changed) {
       path,
       (held) => held.append(bytes),
       async () => {
-        const end = await fs.append?.(path, bytes).catch((err) => {
+        const end = await fs.append?.(path, bytes, { alone: true }).catch((err) => {
           if (!positional(err)) throw err;
           return void 0;
         });