@ai-ecoverse/slicc-kernel 1.120.0 → 1.120.1

package/dist/kernel-worker.js

@@ -1199,7 +1199,7 @@ var OpfsFs = class {
     this.rootName = 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.remote) this.remote.quiet = () => this.quiet().then(() => this.settle?.());
     if (this.channel) {
       const remote = this.remote;
       meta.listen?.(
@@ -1354,6 +1354,15 @@ var OpfsFs = class {
       if (this.unlocked === 0) for (const done4 of this.idle.splice(0)) done4();
     }
   }
+  settle;
+  onPeer(settle3) {
+    this.settle = settle3;
+  }
+  peers() {
+    const remote = this.remote;
+    if (!remote) return void 0;
+    return { joined: () => remote.peered(), crowded: () => remote.crowded() };
+  }
   quiet() {
     if (this.unlocked === 0) return Promise.resolve();
     return new Promise((resolve2) => this.idle.push(resolve2));
@@ -6376,7 +6385,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.120.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.120.1" : "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
@@ -13643,10 +13652,14 @@ async function flock(req, ctx) {
   if (!locks || !flockOf) throw new KernelError("ENOLCK");
   if (!FLOCK_KINDS.has(req.kind)) throw new KernelError("EINVAL");
   const { key, owner } = await flockOf(req.fd);
+  const granted2 = req.kind !== "unlock";
+  const shared = locks.shared?.() === true;
+  if (shared && !granted2) await ctx.settle?.(req.fd, false);
   if (req.kind !== "unlock" && req.wait)
     await locks.flocks.wait(key, owner, req.kind, ctx.blocking);
   else if (!await locks.flocks.set(key, owner, req.kind)) throw new KernelError("EAGAIN");
-  return done2;
+  if (shared && granted2) await ctx.settle?.(req.fd, true);
+  return shared ? json3(true) : done2;
 }
 async function recordLock2(req, ctx) {
   const { locks, fileKey } = ctx;
@@ -13657,6 +13670,7 @@ async function recordLock2(req, ctx) {
     ...req.fd !== void 0 ? { fd: req.fd } : {}
   };
   if (req.op === "lk-close") {
+    if (req.fd !== void 0 && locks.shared?.()) await ctx.settle?.(req.fd, false);
     locks.dropFile(await fileKey(target, "close"), owner);
     return done2;
   }
@@ -13668,13 +13682,16 @@ async function recordLock2(req, ctx) {
     const len = held.end === Number.POSITIVE_INFINITY ? 0 : held.end - held.start;
     return json3({ kind: held.kind, pid: held.owner, start: held.start, len });
   }
-  if (req.kind !== "unlock" && req.wait) {
+  const granted2 = req.kind !== "unlock";
+  const shared = locks.shared?.() === true;
+  const fd = shared ? req.fd : void 0;
+  if (!granted2 && fd !== void 0) await ctx.settle?.(fd, false);
+  if (req.kind !== "unlock" && req.wait)
     await locks.wait(key, owner, req.kind, range2, ctx.blocking);
-    return done2;
-  }
-  if (!await locks.set(key, owner, req.kind, range2.start, range2.end))
+  else if (!await locks.set(key, owner, req.kind, range2.start, range2.end))
     throw new KernelError("EAGAIN");
-  return done2;
+  if (granted2 && fd !== void 0) await ctx.settle?.(fd, true);
+  return shared ? json3(true) : done2;
 }
 
 // src/kernel/net/loopback-transport.ts
@@ -16984,6 +17001,11 @@ var VfsNode = class {
   holds() {
     return this.dirty;
   }
+  reread() {
+    if (this.dirty || this.orphaned || this.pin || this.revoked) return;
+    this.data = void 0;
+    this.ranged = void 0;
+  }
   replace(contents2) {
     this.ranged = void 0;
     this.data = new Uint8Array(contents2);
@@ -17611,6 +17633,7 @@ function vfsFile(fs, opts, nodes) {
     })),
     known: () => node.known(),
     flush: () => serial(() => node.flush()),
+    reread: () => serial(async () => node.reread()),
     close: () => node.serial(async () => {
       try {
         takeOpenError();
@@ -18093,6 +18116,7 @@ var WasmProcess = class {
           owner: () => this.lockOwner(),
           fileKey: (target, kind, setting) => this.lockKey(target, kind, setting),
           flockOf: (fd) => this.flockOf(fd),
+          settle: (fd, granted2) => this.settle(fd, granted2),
           locks: this.options.locks,
           ops: this.asyncOps,
           blocking: () => this.blockingSignal(cancelled),
@@ -18176,6 +18200,11 @@ var WasmProcess = class {
     else if (this.pathKeys.size < 4096) this.pathKeys.set(path, key);
     return key;
   }
+  async settle(fd, granted2) {
+    const file = this.fds.has(fd) ? this.fds.get(fd).file : void 0;
+    if (granted2) await file?.reread?.();
+    else await file?.flush?.();
+  }
   async flockOf(fd) {
     const open = this.fds.get(fd);
     const { locks } = this.options;
@@ -19861,13 +19890,20 @@ var LockService = class {
     };
     void this.locks.request(this.aliveOf(this.kernel), () => new Promise(() => {
     }));
-    this.role = this.elect();
+    const peers = options.peers;
+    this.role = peers ? Promise.all([this.elect(), peers.joined()]).then(() => void 0) : this.elect();
+    this.peers = options.peers;
     this.flocks = {
       set: (key, owner, kind) => this.flockSet(key, owner, kind),
       wait: (key, owner, kind, blocking) => this.flockWait(key, owner, kind, blocking),
       drop: (owner) => this.flockDrop(owner)
     };
   }
+  peers;
+  shared() {
+    if (!this.leader || this.ownerOf.size > 0 || this.tokens.size > 0) return true;
+    return this.peers?.crowded() === true;
+  }
   aliveOf(kernel) {
     return `slicc-locks-alive:${LOCKS_PROTOCOL}:${this.root}:${kernel}`;
   }
@@ -20128,11 +20164,11 @@ var LockService = class {
     this.table.closed(pid, fd);
   }
 };
-function kernelLocks(root) {
+function kernelLocks(root, peers) {
   const locks = globalThis.navigator?.locks;
   if (root === void 0 || !locks || typeof BroadcastChannel !== "function")
     return new LockTable();
-  return new LockService({ root, locks });
+  return new LockService({ root, locks, ...peers ? { peers } : {} });
 }
 var ASK_OPS = /* @__PURE__ */ new Set([
   "set",
@@ -23520,7 +23556,7 @@ var Launcher = class {
   constructor(options) {
     this.usersMode = usersMode(options.users);
     this.rootFs = options.fs;
-    this.locks = kernelLocks(options.fs.rootName);
+    this.locks = kernelLocks(options.fs.rootName, options.fs.peers?.());
     this.dac = this.usersMode === "off" ? void 0 : new Dac(this.usersMode, options.onDenial);
     if (this.dac) this.dac.tagOf = (pid) => this.tagOf(pid);
     this.clipboard = new ClipboardBroker(
@@ -23601,6 +23637,7 @@ var Launcher = class {
     this.nodes = new VfsNodes(fs, (path) => this.released(path));
     this.nodes.keepsOnDisk = true;
     this.openFiles.add(this.nodes);
+    options.fs.onPeer?.(() => this.flushOpen());
     const holders = [this.held, this.openFiles];
     this.unlinked = new UnlinkedKeeper(
       fs,
@@ -25261,6 +25298,9 @@ var Launcher = class {
     this.writers ??= this.writerStack();
     return this.writers;
   }
+  async flushOpen() {
+    for (const nodes of this.openFiles) await nodes.flush("/").catch(() => void 0);
+  }
   writerStack() {
     const mounted = this.mounts.wrap(this.unguardedRoot);
     const fs = this.commandFs(this.rooted(mounted));