@ai-ecoverse/slicc-kernel 1.141.3 → 1.142.1

package/dist/kernel-worker.js

@@ -165,6 +165,9 @@ var IndexedDbMeta = class {
     };
     this.channel.unref?.();
   }
+  forgetTrees(trees) {
+    this.drop({ trees: [...trees] });
+  }
   drop({ paths = [], trees = [] }) {
     this.generation++;
     for (const path of paths) this.cache.delete(path);
@@ -353,6 +356,90 @@ async function openMeta(name2, factory) {
   return new IndexedDbMeta(await openMetaDb(name2, factory));
 }
 
+// src/fs/changes.ts
+var GEN = 0;
+var RING = 1;
+var RING_SIZE = 4096;
+var SLOT = 2;
+var SHARED_TTL_MS = 100;
+var DIRTY = RING + RING_SIZE * SLOT;
+var FOREIGN = DIRTY + 1;
+var CHANGES_BYTES = (FOREIGN + 1) * 4;
+function changeHash(path) {
+  let h = 2166136261;
+  for (let i = 0; i < path.length; i++) {
+    h ^= path.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h === 0 ? 1 : h;
+}
+function normal(path) {
+  const parts2 = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts2.pop();
+    else parts2.push(part);
+  }
+  return `/${parts2.join("/")}`;
+}
+var FileChanges = class {
+  sab;
+  view;
+  constructor(sab = new SharedArrayBuffer(CHANGES_BYTES)) {
+    this.sab = sab;
+    this.view = new Int32Array(sab);
+  }
+  dirtied(delta) {
+    Atomics.add(this.view, DIRTY, delta);
+  }
+  foreign(on) {
+    Atomics.store(this.view, FOREIGN, on ? 1 : 0);
+  }
+  flush() {
+    Atomics.add(this.view, GEN, RING_SIZE + 1);
+  }
+  publish(...paths) {
+    for (const path of paths) {
+      const g = Atomics.add(this.view, GEN, 1) + 1 | 0;
+      const at = RING + (g & RING_SIZE - 1) * SLOT;
+      Atomics.store(this.view, at, 0);
+      Atomics.store(this.view, at + 1, changeHash(normal(path)));
+      Atomics.store(this.view, at, g);
+    }
+  }
+};
+var ChangeView = class {
+  view;
+  constructor(sab) {
+    this.view = new Int32Array(sab);
+  }
+  now() {
+    return Atomics.load(this.view, GEN);
+  }
+  clean() {
+    return this.view.length > DIRTY && Atomics.load(this.view, DIRTY) === 0;
+  }
+  foreign() {
+    return this.view.length > FOREIGN && Atomics.load(this.view, FOREIGN) === 1;
+  }
+  changedSince(seen, path) {
+    const now = Atomics.load(this.view, GEN);
+    const distance = now - seen >>> 0;
+    if (distance === 0) return { now, changed: false };
+    if (distance > RING_SIZE) return { now, changed: true };
+    const hash = changeHash(normal(path));
+    for (let i = 1; i <= distance; i++) {
+      const g = seen + i | 0;
+      const at = RING + (g & RING_SIZE - 1) * SLOT;
+      if (Atomics.load(this.view, at) !== g) return { now, changed: true };
+      const hit = Atomics.load(this.view, at + 1) === hash;
+      if (Atomics.load(this.view, at) !== g) return { now, changed: true };
+      if (hit) return { now, changed: true };
+    }
+    return { now, changed: false };
+  }
+};
+
 // src/fs/notice.ts
 function dirsChannel(metadata) {
   return `slicc-kernel-dirs:${metadata}`;
@@ -881,6 +968,8 @@ var ANNOUNCE_WAIT_MS = 500;
 var PRUNE_EVERY_MS = 3e4;
 var MOURN_TRIES = 5;
 var MOURN_RETRY_MS = 100;
+var RENAME_ACK_MAX_MS = 1e4;
+var ANNOUNCE_POLL_MS = 20;
 function lockManager() {
   return globalThis.navigator?.locks;
 }
@@ -904,6 +993,9 @@ var RemoteWatch = class {
   quiet;
   crowd;
   gone;
+  renaming;
+  renamed;
+  ackers = /* @__PURE__ */ new Set();
   told;
   counted = 0;
   recount() {
@@ -931,7 +1023,7 @@ var RemoteWatch = class {
       this.settled = true;
       this.recount();
     });
-    this.channel.postMessage({ hello: this.tab });
+    this.channel.postMessage({ hello: this.tab, renames: true });
   }
   async join() {
     if (!this.locks) return;
@@ -952,6 +1044,20 @@ var RemoteWatch = class {
     await this.joined;
     return this.peers.size > 0;
   }
+  async joinedAll(cap) {
+    if (!this.locks) return true;
+    const prefix = `${this.name}:`;
+    const began = performance.now();
+    for (; ; ) {
+      const held = ((await this.locks.query()).held ?? []).map((lock) => lock.name ?? "");
+      const silent = held.some(
+        (name2) => name2.startsWith(prefix) && name2 !== this.lockOf(this.tab) && !this.peers.has(name2.slice(prefix.length))
+      );
+      if (!silent) return true;
+      if (performance.now() - began >= cap) return false;
+      await new Promise((resolve2) => setTimeout(resolve2, ANNOUNCE_POLL_MS));
+    }
+  }
   crowded() {
     return !this.settled || this.peers.size > 0;
   }
@@ -959,7 +1065,11 @@ var RemoteWatch = class {
     return `${this.name}:${tab}`;
   }
   receive(data) {
+    const sender = data.hello ?? data.here;
+    if (sender !== void 0 && data.renames) this.ackers.add(sender);
     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.here !== void 0 && data.to === this.tab) {
       this.arrived(data.here);
       this.met?.();
@@ -991,6 +1101,7 @@ var RemoteWatch = class {
       this.mourned.delete(peer);
       this.others.delete(peer);
       this.peers.delete(peer);
+      this.ackers.delete(peer);
       this.rebuild();
       this.recount();
       this.gone?.();
@@ -1002,12 +1113,18 @@ var RemoteWatch = class {
   greeted(peer) {
     this.arrived(peer);
     const answer2 = () => {
-      this.channel.postMessage({ here: this.tab, to: peer });
+      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();
   }
+  heard({ tab, renaming, seq: seq2 }) {
+    const ack = () => this.channel.postMessage({ ack: seq2, from: this.tab, to: tab });
+    const heard = this.renaming?.(renaming);
+    if (heard !== void 0) void heard.then(ack, ack);
+    else ack();
+  }
   announced({ tab, paths, seq: seq2 }) {
     const from = tab;
     this.arrived(from);
@@ -1034,6 +1151,7 @@ var RemoteWatch = class {
       if (!held.has(this.lockOf(tab))) {
         if (this.peers.delete(tab)) left = true;
         this.others.delete(tab);
+        this.ackers.delete(tab);
       }
     }
     this.rebuild();
@@ -1055,7 +1173,34 @@ var RemoteWatch = class {
     this.mine = [...paths];
     const seq2 = ++this.seq;
     this.channel.postMessage({ tab: this.tab, paths: this.mine, seq: seq2 });
-    if (this.peers.size === 0) return Promise.resolve();
+    return this.acks(seq2, this.peers);
+  }
+  renamingTree(rename, cap = RENAME_ACK_MAX_MS) {
+    const seq2 = ++this.seq;
+    this.channel.postMessage({ tab: this.tab, renaming: rename, seq: seq2 });
+    const left = new Set(this.ackers);
+    if (left.size === 0) return Promise.resolve([]);
+    const began = performance.now();
+    return new Promise((resolve2) => {
+      const done5 = () => {
+        clearInterval(timer);
+        this.waiting.delete(seq2);
+        resolve2([...left]);
+      };
+      const timer = setInterval(() => {
+        void this.prune().then(() => {
+          for (const peer of left) if (!this.ackers.has(peer)) left.delete(peer);
+          if (left.size === 0 || performance.now() - began >= cap) done5();
+        });
+      }, ANNOUNCE_WAIT_MS);
+      this.waiting.set(seq2, { left, done: done5 });
+    });
+  }
+  renamedTree(lock) {
+    this.channel.postMessage({ renamed: lock });
+  }
+  acks(seq2, from) {
+    if (from.size === 0) return Promise.resolve();
     return new Promise((resolve2) => {
       const done5 = () => {
         clearTimeout(timer);
@@ -1066,7 +1211,7 @@ var RemoteWatch = class {
         done5();
         void this.prune();
       }, ANNOUNCE_WAIT_MS);
-      this.waiting.set(seq2, { left: new Set(this.peers), done: done5 });
+      this.waiting.set(seq2, { left: new Set(from), done: done5 });
     });
   }
   emit(change) {
@@ -1129,6 +1274,12 @@ var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var RENAMES = "/.slicc-renames";
 var RENAME_LOCK = "slicc-rename:";
+var RENAME_ADMIT = "slicc-rename-admit:";
+var PAIRED = /* @__PURE__ */ new Set(["rename", "link", "copyFile"]);
+var LISTINGS = /* @__PURE__ */ new Set(["readdir", "readdirStat"]);
+var RETRY = /* @__PURE__ */ Symbol("retry");
+var ACK_SAMPLES = 4096;
+var INTENT_POLL_MS = 5;
 function movable(handle) {
   return typeof handle.move === "function";
 }
@@ -1173,6 +1324,7 @@ function sidecar(meta) {
     for (const { path, change } of changes) await ops.update(path, change);
   };
   if (meta.absent) ops.absent = meta.absent.bind(meta);
+  if (meta.forgetTrees) ops.forgetTrees = meta.forgetTrees.bind(meta);
   const { removeFile } = meta;
   if (removeFile)
     ops.removeFile = (path) => removeFile.call(meta, path).catch((err) => {
@@ -1298,7 +1450,17 @@ var OpfsFs = class {
     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.gone = () => void this.orphans();
+      this.remote.gone = () => {
+        void this.orphans();
+        for (const move of [...this.peerMoves.values()]) void this.peerMoved(move);
+      };
+      this.remote.renaming = (rename) => this.heardRename(rename);
+      this.remote.renamed = (lock) => {
+        const move = this.peerMoves.get(lock);
+        if (!move) return;
+        move.done = true;
+        void this.peerMoved(move);
+      };
     }
     if (this.channel) {
       const remote = this.remote;
@@ -2342,16 +2504,27 @@ var OpfsFs = class {
     throw fsError("EPERM", `${from}: this file system has no hard links`);
   }
   async rename(from, to) {
+    const call = this.renameCall;
+    this.renameCall = void 0;
     if (from === to) return;
+    for (; ; ) {
+      try {
+        return await this.renameOnce(from, to, call);
+      } catch (err) {
+        if (err !== RETRY) throw err;
+      }
+    }
+  }
+  async renameOnce(from, to, call) {
     const source = await this.locate(from, false);
     this.refuse(source.path, true);
     this.forget(source.path);
     const parent = await this.locate(parentOf3(to), true);
     const destination = resolvePath(parent.path, baseOf(to));
     this.refuse(destination, true);
-    await this.entering(destination, () => this.moveTo(source, parent, destination, to));
+    await this.entering(destination, () => this.moveTo(source, parent, destination, to, call));
   }
-  async moveTo(source, parent, destination, to) {
+  async moveTo(source, parent, destination, to, call) {
     const sourceStat = await this.describe(source);
     if (sourceStat.isDirectory && within2(destination, source.path)) throw fsError("EINVAL", to);
     const target = await this.exactly(() => this.locate(destination, false)).catch((err) => {
@@ -2386,6 +2559,7 @@ var OpfsFs = class {
     const name2 = baseOf(destination);
     const swap = targetStat?.isDirectory === true;
     let lock;
+    const hooks = {};
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
     const copying = sourceStat.isDirectory && !movable(source.handle);
     const staged = resolvePath(parent.path, staging);
@@ -2394,8 +2568,15 @@ var OpfsFs = class {
       const copies = /* @__PURE__ */ new Map();
       const root = { ino: inodeOf(source.path), ...moving };
       const owned4 = lock ? { lock } : {};
+      hooks.notify?.();
       const first = copying ? await this.intend({ from: source.path, to: staged, root, ...owned4 }) : void 0;
       const second = copying && swap ? await this.intend({ from: staged, to: destination, replace: true, root, ...owned4 }) : void 0;
+      await hooks.started?.().catch(async (err) => {
+        for (const intent of [first, second]) {
+          if (intent) await this.meta.update(intent, () => void 0);
+        }
+        throw err;
+      });
       const moved2 = await this.replacingTarget(
         targetStat !== null,
         () => this.place(source.handle, dir, staging, copies)
@@ -2430,13 +2611,262 @@ var OpfsFs = class {
       const locks = this.locks;
       if (locks) {
         lock = `${RENAME_LOCK}${crypto.randomUUID()}`;
-        await locks.request(lock, place);
+        this.ownLocks.add(lock);
+        call?.release();
+        await this.admitted(locks, lock, source.path, destination, place, hooks);
       } else await place();
     } finally {
+      if (lock) this.ownLocks.delete(lock);
       this.renamingDirs.delete(entry);
       resolve2();
     }
   }
+  async admitted(locks, lock, from, to, place, hooks) {
+    const remote = this.remote;
+    if (remote && !this.shared() && !await remote.joinedAll(RENAME_ACK_MAX_MS)) {
+      this.ackBusy++;
+      console.warn(
+        `slicc-kernel: renaming ${from} to ${to} gave up (EBUSY): a tab sharing the root did not finish joining in ${RENAME_ACK_MAX_MS} ms (#1140)`
+      );
+      throw fsError("EBUSY", from);
+    }
+    if (!remote || !this.shared()) {
+      await locks.request(lock, place);
+      return;
+    }
+    let clash;
+    let run2;
+    await locks.request(`${RENAME_ADMIT}${this.rootName ?? ""}`, async () => {
+      if (await this.renamingElsewhere()) await this.learnRenames();
+      clash = this.clashing(from, to);
+      if (clash) return;
+      const { promise, resolve: resolve2 } = Promise.withResolvers();
+      let told;
+      hooks.notify = () => {
+        told = remote.renamingTree({ from, to, lock });
+      };
+      hooks.started = async () => {
+        resolve2();
+        this.renameAcks++;
+        const at = performance.now();
+        const stuck = await told;
+        this.ackMs.push(performance.now() - at);
+        if (this.ackMs.length > ACK_SAMPLES) this.ackMs.shift();
+        if (stuck.length === 0) return;
+        this.ackBusy++;
+        console.warn(
+          `slicc-kernel: renaming ${from} to ${to} gave up (EBUSY): peer tab ${stuck.join(", ")} is alive but did not answer in ${RENAME_ACK_MAX_MS} ms (#1140)`
+        );
+        throw fsError("EBUSY", from);
+      };
+      run2 = locks.request(lock, async () => {
+        await place();
+        remote.renamedTree(lock);
+      });
+      await Promise.race([promise, run2.then(nothing, nothing)]);
+    });
+    if (clash) {
+      this.peerWaited++;
+      await this.peerMoved(clash);
+      throw RETRY;
+    }
+    await run2;
+  }
+  renameAcks = 0;
+  ackBusy = 0;
+  ackMs = [];
+  ownLocks = /* @__PURE__ */ new Set();
+  peerMoves = /* @__PURE__ */ new Map();
+  peerWaits = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Set();
+  renameCall;
+  looking;
+  lookedAt = Number.NEGATIVE_INFINITY;
+  peerWaited = 0;
+  queries = 0;
+  renameWaits() {
+    return {
+      acks: this.renameAcks,
+      busy: this.ackBusy,
+      waits: this.peerWaited,
+      queries: this.queries,
+      ackMs: this.ackMs
+    };
+  }
+  notePeer(lock, tree2) {
+    let known = this.peerMoves.get(lock);
+    if (!known) {
+      known = { lock, trees: [] };
+      this.peerMoves.set(lock, known);
+    }
+    if (!known.trees.some(([a, b]) => a === tree2[0] && b === tree2[1])) known.trees.push(tree2);
+    return known;
+  }
+  async learnRenames() {
+    for (const { rename } of await this.meta.under(RENAMES)) {
+      if (rename?.lock === void 0 || this.ownLocks.has(rename.lock)) continue;
+      this.notePeer(rename.lock, [rename.from, rename.to]);
+    }
+  }
+  async renamingElsewhere() {
+    const { held = [] } = await this.locks.query();
+    return held.some(({ name: name2 }) => name2?.startsWith(RENAME_LOCK) && !this.ownLocks.has(name2));
+  }
+  lookForRenames() {
+    const locks = this.locks;
+    const age = performance.now() - this.lookedAt;
+    if (!locks || age < SHARED_TTL_MS / 2) return Promise.resolve();
+    this.looking ??= (async () => {
+      for (; ; ) {
+        const asked = performance.now();
+        this.queries++;
+        const { held = [] } = await locks.query();
+        const unknown = () => held.some(
+          ({ name: name2 }) => name2?.startsWith(RENAME_LOCK) && !this.ownLocks.has(name2) && !this.peerMoves.has(name2)
+        );
+        if (unknown()) await this.learnRenames();
+        if (!unknown()) {
+          this.lookedAt = asked;
+          return;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, INTENT_POLL_MS));
+      }
+    })().finally(() => {
+      this.looking = void 0;
+    });
+    if (age >= SHARED_TTL_MS) return this.looking;
+    this.looking.catch(nothing);
+    return Promise.resolve();
+  }
+  async heardRename({ from, to, lock }) {
+    if (this.ownLocks.has(lock)) return;
+    this.notePeer(lock, [from, to]);
+    this.lookedAt = performance.now();
+    const trees = [[from, to]];
+    const running = [...this.inflight];
+    const reached = await Promise.all(
+      running.map(async (op) => {
+        if (op.paths.some((at) => touches(at, trees))) return true;
+        for (const at of op.paths) {
+          const forms = await this.resolvedForms(at);
+          if (forms.some((form) => touches(form, trees))) return true;
+        }
+        return false;
+      })
+    );
+    const busy = running.filter((op, i) => reached[i] && this.inflight.has(op));
+    if (this.aloneCalls > 0) {
+      this.aloneDrain ??= Promise.withResolvers();
+      busy.push({ paths: [], waiting: this.aloneDrain, release: nothing });
+    }
+    await Promise.all(
+      busy.map((op) => {
+        op.waiting ??= Promise.withResolvers();
+        return op.waiting.promise;
+      })
+    );
+  }
+  peerAt(at, listing) {
+    for (const move of this.peerMoves.values()) {
+      if (this.ownLocks.has(move.lock)) continue;
+      if (touches(at, move.trees, listing)) return move;
+    }
+    return void 0;
+  }
+  clashing(from, to) {
+    for (const move of this.peerMoves.values()) {
+      for (const tree2 of move.trees) {
+        for (const mine of [from, to]) {
+          if (tree2.some((theirs) => within2(mine, theirs) || within2(theirs, mine))) return move;
+        }
+      }
+    }
+    return void 0;
+  }
+  peerMoved(move) {
+    const locks = this.locks;
+    let wait2 = this.peerWaits.get(move.lock);
+    if (wait2 !== void 0) return wait2;
+    wait2 = (async () => {
+      if (!move.done)
+        await locks.request(move.lock, async () => {
+          if (move.done) return;
+          const left = (await this.meta.under(RENAMES)).filter((entry) => entry.rename?.lock === move.lock).sort(byIntent);
+          for (const entry of left) await this.finishRename(entry);
+        });
+      this.peerMoves.delete(move.lock);
+      for (const [from, to] of move.trees) {
+        this.forget(from);
+        this.forget(to);
+        this.meta.forgetTrees?.([from, to]);
+      }
+    })().finally(() => this.peerWaits.delete(move.lock));
+    this.peerWaits.set(move.lock, wait2);
+    return wait2;
+  }
+  async peerSettled(at, listing) {
+    await this.lookForRenames();
+    for (let reals; ; ) {
+      const forms = [at, ...reals ?? []];
+      const move = forms.map((form) => this.peerAt(form, listing)).find(Boolean);
+      if (move) {
+        this.peerWaited++;
+        await this.peerMoved(move);
+        continue;
+      }
+      if (reals !== void 0 || at === "/" || this.peerMoves.size === 0) return forms;
+      reals = await this.resolvedForms(at);
+      if (reals.length === 0) return forms;
+    }
+  }
+  aloneCalls = 0;
+  aloneDrain;
+  async alonePlain(inner, args) {
+    this.aloneCalls++;
+    try {
+      return await inner.apply(this, args);
+    } finally {
+      this.aloneCalls--;
+      if (this.aloneCalls === 0 && this.aloneDrain) {
+        this.aloneDrain.resolve();
+        this.aloneDrain = void 0;
+      }
+    }
+  }
+  async resolvedForms(at) {
+    if (at === "/") return [];
+    const parent = await PLAIN.realpath.call(this, parentOf3(at), true).catch(() => parentOf3(at));
+    const named = resolvePath(parent, baseOf(at));
+    const target = await PLAIN.realpath.call(this, at, true).catch(() => named);
+    return [.../* @__PURE__ */ new Set([named, target])].filter((form) => form !== at);
+  }
+  amongPeers() {
+    return this.remote !== void 0 && this.locks !== void 0 && this.shared();
+  }
+  async peerOp(name2, args, inner) {
+    const paths = (name2 === "symlink" ? args.slice(1, 2) : PAIRED.has(name2) ? args.slice(0, 2) : args.slice(0, 1)).filter((path) => typeof path === "string").map(normalizePath);
+    const listing = LISTINGS.has(name2);
+    const checked = [...paths];
+    while (this.amongPeers()) {
+      checked.length = 0;
+      for (const at of paths) checked.push(...await this.peerSettled(at, listing));
+      if (!checked.some((at) => this.peerAt(at, listing))) break;
+    }
+    const busy = { paths: checked, release: () => void 0 };
+    const done5 = () => {
+      this.inflight.delete(busy);
+      busy.waiting?.resolve();
+    };
+    busy.release = done5;
+    this.inflight.add(busy);
+    if (name2 === "rename") this.renameCall = busy;
+    if (name2 !== "writeSession") return await inner.apply(this, args).finally(done5);
+    const session = await inner.apply(this, args).catch((err) => {
+      done5();
+      throw err;
+    });
+    return { ...session, close: () => session.close().finally(done5) };
+  }
   renamingDirs = /* @__PURE__ */ new Set();
   intents = 0;
   async intend(rename, at = `${RENAMES}/${crypto.randomUUID()}`) {
@@ -2482,7 +2912,7 @@ var OpfsFs = class {
     );
     for (const entry of intents) {
       const lock = entry.rename.lock;
-      if (!orphaned || !locks || !lock) await this.finishRename(entry);
+      if (!locks || !lock) await this.finishRename(entry);
       else await locks.request(lock, () => this.finishRename(entry));
     }
     return intents.length;
@@ -2498,7 +2928,8 @@ var OpfsFs = class {
     this.forget(to);
     try {
       const left = await this.real(from);
-      if (left && replace && await this.real(to)) await this.rm(to, { recursive: true });
+      if (left && replace && await this.real(to))
+        await PLAIN.rm.call(this, to, { recursive: true });
       if (left) {
         const source = await this.locate(from, false);
         const target = await this.locate(parentOf3(to), true);
@@ -2512,7 +2943,7 @@ var OpfsFs = class {
         this.forget(from);
         this.forget(to);
       }
-      if ((await this.meta.under(from)).length > 0) {
+      if ((await this.meta.under(from)).some((entry2) => !entry2.vacated)) {
         await this.meta.move(
           from,
           to,
@@ -2843,6 +3274,21 @@ var OpfsFs = class {
     return removed;
   }
 };
+function nothing() {
+  return void 0;
+}
+function touches(at, trees, listing = true) {
+  return trees.some(
+    ([from, to]) => within2(at, from) || within2(at, to) || listing && (at === parentOf3(from) || at === parentOf3(to))
+  );
+}
+function byIntent(a, b) {
+  return a.rename.at - b.rename.at;
+}
+var PLAIN = {
+  rm: OpfsFs.prototype.rm,
+  realpath: OpfsFs.prototype.realpath
+};
 var READS = [
   "stat",
   "lstat",
@@ -2873,6 +3319,14 @@ var WRITES = [
   "lutimes",
   "chown"
 ];
+{
+  const proto = OpfsFs.prototype;
+  const inner = proto.createExclusive;
+  proto.createExclusive = function(...args) {
+    if (this.amongPeers()) return this.peerOp("createExclusive", args, inner);
+    return this.alonePlain(inner, args);
+  };
+}
 for (const [names2, op] of [
   [READS, "read"],
   [WRITES, "write"]
@@ -2883,7 +3337,9 @@ for (const [names2, op] of [
     proto[name2] = async function(...args) {
       try {
         if (op === "read") await this.settledRename(args[0]);
-        return await inner.apply(this, args);
+        if (this.amongPeers() || name2 === "writeSession")
+          return await this.peerOp(name2, args, inner);
+        return await this.alonePlain(inner, args);
       } catch (err) {
         throw translate(err, String(args[0]), op, false);
       }
@@ -7128,7 +7584,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.141.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.142.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
@@ -9505,89 +9961,6 @@ var FileWatches = class {
   }
 };
 
-// src/fs/changes.ts
-var GEN = 0;
-var RING = 1;
-var RING_SIZE = 4096;
-var SLOT = 2;
-var DIRTY = RING + RING_SIZE * SLOT;
-var FOREIGN = DIRTY + 1;
-var CHANGES_BYTES = (FOREIGN + 1) * 4;
-function changeHash(path) {
-  let h = 2166136261;
-  for (let i = 0; i < path.length; i++) {
-    h ^= path.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return h === 0 ? 1 : h;
-}
-function normal(path) {
-  const parts2 = [];
-  for (const part of path.split("/")) {
-    if (part === "" || part === ".") continue;
-    if (part === "..") parts2.pop();
-    else parts2.push(part);
-  }
-  return `/${parts2.join("/")}`;
-}
-var FileChanges = class {
-  sab;
-  view;
-  constructor(sab = new SharedArrayBuffer(CHANGES_BYTES)) {
-    this.sab = sab;
-    this.view = new Int32Array(sab);
-  }
-  dirtied(delta) {
-    Atomics.add(this.view, DIRTY, delta);
-  }
-  foreign(on) {
-    Atomics.store(this.view, FOREIGN, on ? 1 : 0);
-  }
-  flush() {
-    Atomics.add(this.view, GEN, RING_SIZE + 1);
-  }
-  publish(...paths) {
-    for (const path of paths) {
-      const g = Atomics.add(this.view, GEN, 1) + 1 | 0;
-      const at = RING + (g & RING_SIZE - 1) * SLOT;
-      Atomics.store(this.view, at, 0);
-      Atomics.store(this.view, at + 1, changeHash(normal(path)));
-      Atomics.store(this.view, at, g);
-    }
-  }
-};
-var ChangeView = class {
-  view;
-  constructor(sab) {
-    this.view = new Int32Array(sab);
-  }
-  now() {
-    return Atomics.load(this.view, GEN);
-  }
-  clean() {
-    return this.view.length > DIRTY && Atomics.load(this.view, DIRTY) === 0;
-  }
-  foreign() {
-    return this.view.length > FOREIGN && Atomics.load(this.view, FOREIGN) === 1;
-  }
-  changedSince(seen, path) {
-    const now = Atomics.load(this.view, GEN);
-    const distance = now - seen >>> 0;
-    if (distance === 0) return { now, changed: false };
-    if (distance > RING_SIZE) return { now, changed: true };
-    const hash = changeHash(normal(path));
-    for (let i = 1; i <= distance; i++) {
-      const g = seen + i | 0;
-      const at = RING + (g & RING_SIZE - 1) * SLOT;
-      if (Atomics.load(this.view, at) !== g) return { now, changed: true };
-      const hit = Atomics.load(this.view, at + 1) === hash;
-      if (Atomics.load(this.view, at) !== g) return { now, changed: true };
-      if (hit) return { now, changed: true };
-    }
-    return { now, changed: false };
-  }
-};
-
 // src/fs/commands.ts
 var S_IFDIR2 = 16384;
 var S_IFREG2 = 32768;
@@ -10016,10 +10389,10 @@ var FreshModules = class {
     const ranged2 = rangedOps(fs);
     if (ranged2) {
       overrides.pwrite = async (path, at, bytes, transfer) => {
-        const touches2 = at < MAGIC.length && this.fresh.has(normalizePath(path));
+        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);
-        if (touches2) await decide(path, first);
+        if (touches3) await decide(path, first);
       };
       overrides.truncate = async (path, size) => {
         await ranged2.truncate(path, size);
@@ -10096,7 +10469,7 @@ var baseOf3 = (path) => path.slice(path.lastIndexOf("/") + 1);
 var WATCH_BATCH_LIMIT = 1e3;
 var under3 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
 var parentOf7 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
-function touches(watcher, changed) {
+function touches2(watcher, changed) {
   return watcher.paths.some(
     (watched) => changed === watched || under3(watched, changed) || (watcher.recursive ? under3(changed, watched) : parentOf7(changed) === watched)
   );
@@ -10224,7 +10597,7 @@ var FsWatchers = class {
     for (const watcher of this.watchers) {
       for (const path of paths) {
         const changed = normalizePath(path);
-        if (touches(watcher, changed)) watcher.pending.add(changed);
+        if (touches2(watcher, changed)) watcher.pending.add(changed);
       }
       if (watcher.pending.size === 0 || watcher.scheduled) continue;
       watcher.scheduled = true;
@@ -13889,7 +14262,18 @@ var SYS_TREE = {
     slicc_opfs_ops: (listing) => `${listing.opfsOps ?? 0}
 `,
     slicc_cwd_checks: (listing) => `${listing.cwdChecks ?? 0}
-`
+`,
+    slicc_rename_ack_busy: (listing) => `${listing.renameAcks?.busy ?? 0}
+`,
+    slicc_rename_acks: (listing) => {
+      const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
+      const median = samples[Math.floor(samples.length / 2)] ?? 0;
+      const most = samples.at(-1) ?? 0;
+      const waits = listing.renameAcks?.waits ?? 0;
+      const queries = listing.renameAcks?.queries ?? 0;
+      return `${listing.renameAcks?.acks ?? 0} ${median.toFixed(1)} ${most.toFixed(1)} ${waits} ${queries}
+`;
+    }
   }
 };
 function isSysFile(at) {
@@ -19721,7 +20105,7 @@ function sniffPg(start2) {
   const length2 = int32(bytes, 0);
   return length2 >= 8 && length2 <= PG_MESSAGE_MAX && int32(bytes, 4) === PROTOCOL_3 ? "yes" : "no";
 }
-var PLAIN = "SCRAM-SHA-256";
+var PLAIN2 = "SCRAM-SHA-256";
 var PLUS = "SCRAM-SHA-256-PLUS";
 var END_POINT = "p=tls-server-end-point,,";
 var SASL = 10;
@@ -19843,7 +20227,7 @@ function pgLength(bytes, started) {
   const length2 = int32(bytes, started ? 1 : 0);
   return started ? 1 + length2 : length2;
 }
-var MECHANISMS = /* @__PURE__ */ new Set([PLAIN, PLUS]);
+var MECHANISMS = /* @__PURE__ */ new Set([PLAIN2, PLUS]);
 async function cleartext(message3, asks) {
   const body = latin2(message3.subarray(5));
   if (!body.endsWith("\0") || body.indexOf("\0") !== body.length - 1)
@@ -19876,7 +20260,7 @@ function serverHeader(header4, server) {
 function rewritten(first, header4) {
   const parsed2 = clientFirstOf(first.data);
   if (!parsed2 || parsed2.header === header4) return first;
-  return { mechanism: header4 === END_POINT ? PLUS : PLAIN, data: `${header4}${parsed2.bare}` };
+  return { mechanism: header4 === END_POINT ? PLUS : PLAIN2, data: `${header4}${parsed2.bare}` };
 }
 var PgClient = class {
   clientFirst;
@@ -27494,7 +27878,7 @@ var RULE = new RegExp(
   String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()\s]+)\)\s+)?(?:Cwd\s+(${WORD})\s+)?Cmnd(?:\s+(.*))?$`
 );
 var TERM = /^[A-Za-z0-9._+-]+$/;
-var PLAIN2 = /^[A-Za-z0-9_@%+=:,./-]+$/;
+var PLAIN3 = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
 function failed2(errno3, error) {
   return { error, errno: errno3 };
@@ -27521,7 +27905,7 @@ function splitWords(text) {
   return words2;
 }
 function quoteWord(word) {
-  return PLAIN2.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
+  return PLAIN3.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
 }
 function validWho(who) {
   if (who === "ALL") return true;
@@ -29334,7 +29718,8 @@ var Launcher = class {
         fsCalls: servedFsCalls(),
         opfsCalls: this.rootFs.opfsCalls?.() ?? 0,
         opfsOps: this.rootFs.opfsOps?.() ?? 0,
-        cwdChecks: this.cwds.checks
+        cwdChecks: this.cwds.checks,
+        renameAcks: this.rootFs.renameWaits?.()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),