@ai-ecoverse/slicc-kernel 1.160.3 → 1.162.0

package/dist/node.js

@@ -3675,7 +3675,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.160.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.162.0" : "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
@@ -4638,6 +4638,9 @@ var LOOKUP_OPS = [
 var within2 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var TOUCHED_MAX = 4096;
 var parentOf2 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var PEER_RM_MS = 1e3;
+var PEER_RENAME_MS = 1e4;
+var PEER_GATE_MS = PEER_RENAME_MS + 5e3;
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
 var PathGate = class {
@@ -4680,7 +4683,9 @@ var UnlinkedKeeper = class {
   links = /* @__PURE__ */ new Map();
   linked = /* @__PURE__ */ new Map();
   dirOwner;
+  peers;
   constructor(fs, holders, rootOf, options = {}) {
+    this.peers = options.peers;
     this.marks = options.marks ?? new PathMarks();
     const { locks, owner } = options;
     this.dirOwner = options.dirOwner;
@@ -4756,22 +4761,29 @@ var UnlinkedKeeper = class {
       lstat: (path) => unreplaced(path, async () => counted3(await fs.lstat(path))),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
-        await replace(target, async (gated, sealed) => {
-          const pinned = await keeper.pin(target, gated, sealed);
-          if (pinned.moved.has(target)) pinned.commit();
-          else await keeper.settle(pinned, () => fs.rm(path, options));
-        });
+        const kept = await keeper.peerKeep(target, false, () => keeper.removable(target, options));
+        if (kept.whole) return;
+        await kept.undoing(
+          () => replace(target, async (gated, sealed) => {
+            const pinned = await keeper.pin(target, gated, sealed);
+            if (pinned.moved.has(target)) pinned.commit();
+            else await keeper.settle(pinned, () => fs.rm(path, options));
+          })
+        );
       },
       async rename(from, to) {
         const target = fs.resolvePath("/", to);
         const source = fs.resolvePath("/", from);
         if (target === source) return fs.rename(from, to);
-        await keeper.marks.around(
-          [source],
-          () => replace(target, async (gated, sealed) => {
-            const pinned = await keeper.pin(target, gated, sealed);
-            await keeper.settle(pinned, () => fs.rename(from, to));
-          })
+        const kept = await keeper.peerKeep(target, true, () => keeper.renamable(source, target));
+        await kept.undoing(
+          () => keeper.marks.around(
+            [source],
+            () => replace(target, async (gated, sealed) => {
+              const pinned = await keeper.pin(target, gated, sealed);
+              await keeper.settle(pinned, () => fs.rename(from, to));
+            })
+          )
         );
       },
       symlink: (target, path, owner) => keeper.marks.around([fs.resolvePath("/", path)], () => fs.symlink(target, path, owner)),
@@ -4916,6 +4928,114 @@ var UnlinkedKeeper = class {
       (err) => err?.code !== "ENOENT" && err?.code !== "ENOTDIR"
     );
   }
+  get id() {
+    return this.instance;
+  }
+  adopt(hidden, refs) {
+    return this.keptFile(hidden, { refs });
+  }
+  async peerKeep(target, over, valid2 = async () => true) {
+    const none = { whole: false, undoing: (op) => op() };
+    const peers = this.peers;
+    if (!peers?.shared() || this.rootOf(target) !== "/") return none;
+    const held = peers.heldWithin(target).filter((holder) => holder.instance !== void 0);
+    if (held.length === 0 || !await valid2()) return none;
+    const tabs = /* @__PURE__ */ new Map();
+    for (const holder of held) tabs.set(holder.tab, [...tabs.get(holder.tab) ?? [], holder]);
+    const asked = [...tabs].map(([tab, holders]) => {
+      const paths = holders.map((holder) => holder.path);
+      return { tab, holders, paths };
+    });
+    const heard = await Promise.all(
+      asked.map(
+        ({ tab, paths }) => peers.ask(tab, { keeping: { paths } }, over ? PEER_RENAME_MS : PEER_RM_MS)
+      )
+    );
+    if (over && heard.includes(false)) {
+      for (const { tab, paths } of asked)
+        void peers.ask(tab, { kept: { items: [], paths } }, PEER_RM_MS);
+      throw fsError("EBUSY", `${target}: open in another tab that did not answer`);
+    }
+    const { whole, moved: moved2 } = await this.setAside(peers, target, asked, heard);
+    return { whole, undoing: (op) => this.undoing(op, moved2) };
+  }
+  async setAside(peers, target, asked, heard) {
+    const mine = this.heldWithin(target);
+    const taken = /* @__PURE__ */ new Set();
+    let whole = false;
+    const told = [];
+    const moved2 = [];
+    for (const [i, { tab, holders, paths }] of asked.entries()) {
+      const items = [];
+      for (const holder of holders) {
+        const free = !mine.has(holder.path) && !taken.has(holder.path);
+        const hidden = free ? await this.asideFor(holder.path, holder.instance) : void 0;
+        if (hidden !== void 0) {
+          taken.add(holder.path);
+          moved2.push({ tab, path: holder.path, hidden, fid: holder.fid });
+          if (holder.path === target) whole = true;
+        }
+        items.push({ path: holder.path, hidden, fid: holder.fid });
+      }
+      const answer2 = peers.ask(tab, { kept: { items, paths } }, PEER_RM_MS);
+      if (heard[i]) told.push(answer2);
+    }
+    await Promise.all(told);
+    return { whole, moved: moved2 };
+  }
+  async undoing(op, moved2) {
+    try {
+      return await op();
+    } catch (err) {
+      for (const { tab, path, hidden, fid } of moved2) {
+        const back = await this.serial(async () => {
+          if (await this.present(path)) return false;
+          return this.fs.rename(hidden, path).then(
+            () => true,
+            () => false
+          );
+        });
+        if (!back) continue;
+        void this.peers?.ask(
+          tab,
+          { kept: { items: [{ path, hidden: void 0, fid, undo: hidden }], paths: [] } },
+          PEER_RM_MS
+        );
+      }
+      throw err;
+    }
+  }
+  async removable(target, options) {
+    const st = await this.fs.lstat(target).catch(() => void 0);
+    return st !== void 0 && (!st.isDirectory || options?.recursive === true);
+  }
+  async renamable(source, target) {
+    const from = await this.fs.lstat(source);
+    const to = await this.fs.lstat(target).catch(() => void 0);
+    if (!to) return true;
+    if (to.isDirectory && !from.isDirectory) throw fsError("EISDIR", target);
+    if (!to.isDirectory && from.isDirectory) throw fsError("ENOTDIR", target);
+    if (to.isDirectory && (await this.fs.readdir(target)).length > 0)
+      throw fsError("ENOTEMPTY", target);
+    return true;
+  }
+  async asideFor(path, instance) {
+    return await this.hideFor(path, instance) ?? this.hideFor(path, instance);
+  }
+  hideFor(path, instance) {
+    return this.serial(async () => {
+      const dir = dirOf("/");
+      const hidden = `${dir}/${instance}.p${crypto.randomUUID().replaceAll("-", "")}`;
+      try {
+        const owner = this.dirOwner;
+        await this.fs.mkdir(dir, { recursive: true, ...owner ? { owner } : {} });
+        await this.fs.rename(path, hidden);
+        return hidden;
+      } catch {
+        return void 0;
+      }
+    });
+  }
   keptFile(hidden, entry) {
     return {
       hidden,
@@ -4970,7 +5090,7 @@ var UnlinkedKeeper = class {
   }
   async tidy(dir) {
     const left = await this.fs.readdir(dir).catch(() => [UNLINKED_DIR]);
-    if (left.length === 0) await this.fs.rm(dir, { recursive: true }).catch(() => void 0);
+    if (left.length === 0) await this.fs.rm(dir).catch(() => void 0);
   }
   sweep(root) {
     const query = this.locks?.query?.bind(this.locks);
@@ -6380,6 +6500,11 @@ async function shownTarget(fs, target) {
   const st = await quiet2(fs.stat(target));
   return st?.isFile && await readsAs2(fs, NOBODY, target) ? st : void 0;
 }
+async function madeFor(owner, virtual) {
+  if (!owner?.existing || await virtual() === void 0) return owner;
+  const { existing: _, ...made2 } = owner;
+  return made2;
+}
 function withCommandDirs(fs, names2, userDir = async () => void 0, owners = false, targetOf2 = async () => void 0) {
   async function nearest(path) {
     const st = await fs.stat(path).catch(() => void 0);
@@ -6477,7 +6602,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     }),
     readFileBuffer: (path) => fs.readFileBuffer(path).catch((err) => content(path, err)),
     commandTarget: async (path) => (await entryTarget(path))?.path,
-    writeFile: (path, content2, owner) => fs.writeFile(path, content2, owner),
+    writeFile: async (path, content2, owner) => fs.writeFile(path, content2, await madeFor(owner, () => entryTarget(path))),
     link: (from, to, follow2) => fs.link(from, to, follow2),
     links: (path) => mayLink(fs, path),
     async exists(path) {
@@ -6642,6 +6767,10 @@ function withEtcFiles(fs, files) {
       }
     } : {},
     readFile: (path) => fs.readFile(path).catch(fallback(path, (b) => new TextDecoder().decode(b))),
+    writeFile: async (path, content, owner) => {
+      if (owner?.existing && files.has(path)) await materialize(path);
+      return fs.writeFile(path, content, owner);
+    },
     ...fs.append ? {
       append: async (path, bytes, options) => {
         if (files.has(path)) await materialize(path);
@@ -8919,12 +9048,15 @@ function linkedTo(mount, path) {
 var within5 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var HeldSet = class extends Set {
   idle;
-  constructor(idle2) {
+  moved;
+  constructor(idle2, moved2) {
     super();
     this.idle = idle2;
+    this.moved = moved2;
   }
   add(holds2) {
     holds2.onIdle = this.idle;
+    holds2.onMoved = this.moved;
     return super.add(holds2);
   }
   doubt(paths, over) {
@@ -8961,6 +9093,7 @@ var HeldPaths = class extends Map {
   doubted = /* @__PURE__ */ new Map();
   doubts = 0;
   onIdle;
+  onMoved;
   keyOf(path) {
     return this.aliases.get(path) ?? path;
   }
@@ -9018,12 +9151,25 @@ var HeldPaths = class extends Map {
     for (const file of this.unlinked.values()) if (file.hidden === hidden) return true;
     return false;
   }
+  boundAt(path, fid) {
+    return this.handlesAt(path).filter(
+      (id2) => !this.keptHandles.has(id2) && this.bound.get(id2)?.fid === fid
+    );
+  }
+  keepBound(ids, path, file) {
+    for (const id2 of ids) this.keptHandles.set(id2, file);
+    this.uses.set(file, ids.length);
+    this.unlinked.set(path, file);
+  }
   keep(path, file) {
     const fresh3 = this.handlesAt(path).filter((id2) => !this.keptHandles.has(id2));
     for (const id2 of fresh3) this.keptHandles.set(id2, file);
     this.uses.set(file, Math.max(fresh3.length, 1));
     this.unlinked.set(path, file);
   }
+  unkeepAt(path, hidden) {
+    for (const file of [...this.uses.keys()]) if (file.hidden === hidden) this.unkeep(path, file);
+  }
   unkeep(path, file) {
     for (const [id2, kept] of this.keptHandles) if (kept === file) this.keptHandles.delete(id2);
     this.uses.delete(file);
@@ -9121,6 +9267,7 @@ var HeldPaths = class extends Map {
     for (const [id2, key] of this.handles) {
       if (within5(key, from)) this.handles.set(id2, to + key.slice(from.length));
     }
+    this.onMoved?.(from, to);
   }
   isRevoked(path) {
     return this.revoked.has(path);
@@ -9591,12 +9738,12 @@ var MountFs = class _MountFs {
     const target = await found.mount.conn.call({ op: "readlink", path: found.rel });
     return this.follow(this.base.resolvePath(parentOf5(real), target), hops + 1, create);
   }
-  async open(mount, rel2, write, owner) {
+  async open(mount, rel2, write, owner, create = write) {
     return await mount.conn.call({
       op: "open",
       path: rel2,
       write,
-      create: write,
+      create,
       truncate: write,
       exclusive: false,
       ...owner
@@ -9693,10 +9840,10 @@ var MountFs = class _MountFs {
         `${real} would be larger than this mount's maxfile (${mount.maxFile})`
       );
     }
-    const made2 = await this.driverOwner(found, real, owner, false);
+    const made2 = owner?.existing ? void 0 : await this.driverOwner(found, real, owner, false);
     for (let attempt = 1; ; attempt++) {
       try {
-        return await this.writeWhole(mount, real, rel2, bytes, made2);
+        return await this.writeWhole(mount, real, rel2, bytes, made2, owner?.existing !== true);
       } catch (err) {
         if (err.code !== "ESTALE" || attempt >= STALE_RETRIES) throw err;
       }
@@ -9714,10 +9861,10 @@ var MountFs = class _MountFs {
       this.table.forget(mount, real);
     }
   }
-  async writeWhole(mount, real, rel2, bytes, owner) {
+  async writeWhole(mount, real, rel2, bytes, owner, create = true) {
     await this.table.commit(real);
     this.table.forget(mount, real);
-    const fh = await this.open(mount, rel2, true, owner);
+    const fh = await this.open(mount, rel2, true, owner, create);
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     try {
       for (let offset = 0; offset < bytes.length; offset += chunk2) {
@@ -10454,6 +10601,11 @@ function ownerFor(entry, mode) {
   if (!cred) return void 0;
   return ownerOf(cred, mode === void 0 ? void 0 : mode & ~(entry.umask?.() ?? 18));
 }
+function writeOwner(entry, req) {
+  const owner = ownerFor(entry, 438);
+  if (req.handle === void 0 || req.mode !== 1) return owner;
+  return { ...owner ?? {}, existing: true };
+}
 function plainDirMode(entry, mode) {
   if (entry.cred || mode === void 0) return void 0;
   const wanted = mode & 4095 & ~(entry.umask?.() ?? 18);
@@ -10524,7 +10676,7 @@ async function run(entry, path, req) {
     case "read":
       return { ok: true, kind: "bytes", bytes: await readSource(entry, path) };
     case "write":
-      await fs.writeFile(path, req.body ?? new Uint8Array(0), ownerFor(entry, 438));
+      await fs.writeFile(path, req.body ?? new Uint8Array(0), writeOwner(entry, req));
       return done;
     case "exists":
       return json2(await fs.exists(path));
@@ -10748,12 +10900,18 @@ async function holdOp(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, fid) ?? null);
+        return json2(await heldOpen(entry, path, real, req, fid));
     }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
 }
+async function heldOpen(entry, path, real, req, fid) {
+  const handle = entry.hold?.(path, true, true, real, void 0, req.ino, fid);
+  if (handle === void 0) return null;
+  await entry.announceHold?.(real ?? path, fid, ((req.mode ?? 0) & HOLD_CREATED) !== 0);
+  return handle;
+}
 async function idOf(entry, path) {
   return await entry.fileId?.(path)?.catch(() => void 0) ?? void 0;
 }
@@ -11771,6 +11929,10 @@ var SYS_TREE = {
 `,
     slicc_file_ids: (listing) => `${listing.fileIds ?? 0}
 `,
+    slicc_peer_holds: ({ holds: holds2 }) => `${holds2?.mine ?? 0} ${holds2?.peers ?? 0} ${holds2?.sent ?? 0}
+`,
+    slicc_peer_held: ({ holds: holds2 }) => (holds2?.held ?? []).map((path) => `${path}
+`).join(""),
     slicc_rename_acks: (listing) => {
       const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
       const median = samples[Math.floor(samples.length / 2)] ?? 0;
@@ -22853,6 +23015,7 @@ function holdingToken(opts, holds2, caller) {
     ...opts.statfs ? { statfs: opts.statfs } : {},
     ...opts.renames ? { renames: opts.renames } : {},
     ...opts.fileId ? { fileId: opts.fileId } : {},
+    ...opts.announceHold ? { announceHold: opts.announceHold } : {},
     ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
     hold: (path, on, open, real, handle, ino, fid) => holds2.hold(path, on, open, real, handle, ino, fid),
     boundIno: holds2.boundIno.bind(holds2),
@@ -23404,6 +23567,14 @@ var RemoteWatch = class {
   mourned = /* @__PURE__ */ new Set();
   others = /* @__PURE__ */ new Map();
   union = /* @__PURE__ */ new Set();
+  myHolds = /* @__PURE__ */ new Map();
+  peerHolds = /* @__PURE__ */ new Map();
+  holdsSent = 0;
+  silent = /* @__PURE__ */ new Set();
+  holders = /* @__PURE__ */ new Set();
+  instances = /* @__PURE__ */ new Map();
+  instance;
+  keeps;
   listeners = /* @__PURE__ */ new Set();
   waiting = /* @__PURE__ */ new Map();
   locks;
@@ -23447,7 +23618,7 @@ var RemoteWatch = class {
       this.settled = true;
       this.recount();
     });
-    this.channel.postMessage({ hello: this.tab, renames: true });
+    this.channel.postMessage({ hello: this.tab, renames: true, keeps: true });
   }
   async join() {
     if (!this.locks) return;
@@ -23507,8 +23678,12 @@ var RemoteWatch = class {
     return `${this.name}:${tab}`;
   }
   receive(data) {
+    const spoke = data.hello ?? data.here ?? data.tab ?? data.from;
+    if (spoke !== void 0) this.silent.delete(spoke);
     const sender = data.hello ?? data.here ?? (data.paths !== void 0 ? data.tab : void 0);
     if (sender !== void 0 && data.renames) this.ackers.add(sender);
+    const keeper = data.hello ?? data.here;
+    if (keeper !== void 0 && data.keeps) this.holders.add(keeper);
     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);
@@ -23519,7 +23694,9 @@ var RemoteWatch = class {
       this.met?.();
     }
     if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
+    this.holdsHeard(data);
     if (data.ack !== void 0 && data.to === this.tab && data.from !== void 0) {
+      if (data.instance !== void 0) this.instances.set(data.from, data.instance);
       this.acked(data.ack, data.from);
     }
     if (data.changed !== void 0) this.emit({ paths: data.changed, trees: [], content: true });
@@ -23545,8 +23722,11 @@ var RemoteWatch = class {
     void this.locks.request(name2, async () => {
       this.mourned.delete(peer);
       this.others.delete(peer);
+      this.peerHolds.delete(peer);
+      this.keeps?.left(peer);
       this.peers.delete(peer);
       this.ackers.delete(peer);
+      this.holders.delete(peer);
       this.flushedAt(peer);
       this.rebuild();
       this.recount();
@@ -23559,8 +23739,9 @@ var RemoteWatch = class {
   greeted(peer) {
     this.arrived(peer);
     const answer2 = () => {
-      this.channel.postMessage({ here: this.tab, to: peer, renames: true });
+      this.channel.postMessage({ here: this.tab, to: peer, renames: true, keeps: true });
       if (this.mine.length > 0) void this.announce(this.mine);
+      if (this.myHolds.size > 0) this.sendHolds([...this.myHolds], []);
     };
     if (!this.quiet) {
       answer2();
@@ -23583,6 +23764,127 @@ var RemoteWatch = class {
     this.rebuild();
     this.channel.postMessage({ ack: seq2, from: this.tab, to: from });
   }
+  holdsHeard(data) {
+    if (data.tab === void 0) return;
+    if (data.holds !== void 0) this.heldBy(data);
+    if (data.to === this.tab && (data.keeping || data.kept)) void this.keepAsked(data);
+  }
+  keepChains = /* @__PURE__ */ new Map();
+  keepAsked(data) {
+    const from = data.tab;
+    const next3 = (this.keepChains.get(from) ?? Promise.resolve()).then(() => this.keepOne(data));
+    this.keepChains.set(from, next3);
+    return next3;
+  }
+  async keepOne({ tab, seq: seq2, keeping, kept }) {
+    const from = tab;
+    const keeps = this.keeps;
+    try {
+      if (keeping) await keeps?.keeping(from, keeping.paths);
+      if (kept)
+        await keeps?.kept(from, kept.items, kept.paths ?? kept.items.map((item) => item.path));
+    } finally {
+      this.channel.postMessage({
+        ack: seq2,
+        from: this.tab,
+        to: from,
+        ...this.instance === void 0 ? {} : { instance: this.instance }
+      });
+    }
+  }
+  heldBy({ tab, holds: holds2, seq: seq2 }) {
+    const from = tab;
+    const { add, drop } = holds2;
+    if (holds2?.instance !== void 0) this.instances.set(from, holds2.instance);
+    const held = this.peerHolds.get(from) ?? /* @__PURE__ */ new Map();
+    for (const path of drop) held.delete(path);
+    for (const [path, fid] of add) held.set(path, fid);
+    if (held.size > 0) this.peerHolds.set(from, held);
+    else this.peerHolds.delete(from);
+    this.channel.postMessage({ ack: seq2, from: this.tab, to: from });
+  }
+  hold(add, drop, wait2) {
+    const fresh3 = add.filter(
+      ([path, fid]) => !this.myHolds.has(path) || this.myHolds.get(path) !== fid
+    );
+    const gone = drop.filter((path) => this.myHolds.has(path));
+    for (const path of gone) this.myHolds.delete(path);
+    for (const [path, fid] of fresh3) this.myHolds.set(path, fid);
+    if (fresh3.length === 0 && gone.length === 0 || this.peers.size === 0)
+      return Promise.resolve();
+    const seq2 = this.sendHolds(fresh3, gone);
+    if (!wait2) return Promise.resolve();
+    const heard = new Set(
+      [...this.peers].filter((peer) => this.holders.has(peer) && !this.silent.has(peer))
+    );
+    return this.acks(seq2, heard, (left) => {
+      for (const peer of left) this.silent.add(peer);
+    });
+  }
+  rehold(from, to) {
+    const add = [];
+    const drop = [];
+    for (const [path, fid] of [...this.myHolds]) {
+      if (path !== from && !path.startsWith(`${from}/`)) continue;
+      const moved2 = to + path.slice(from.length);
+      this.myHolds.delete(path);
+      this.myHolds.set(moved2, fid);
+      drop.push(path);
+      add.push([moved2, fid]);
+    }
+    if (drop.length > 0 && this.peers.size > 0) this.sendHolds(add, drop);
+  }
+  sendHolds(add, drop) {
+    const seq2 = ++this.seq;
+    this.holdsSent++;
+    const instance = this.instance === void 0 ? {} : { instance: this.instance };
+    this.channel.postMessage({
+      tab: this.tab,
+      holds: { add: [...add], drop: [...drop], ...instance },
+      seq: seq2
+    });
+    return seq2;
+  }
+  heldWithin(target) {
+    const out = [];
+    for (const [tab, held] of this.peerHolds) {
+      for (const [path, fid] of held) {
+        if (path !== target && !path.startsWith(`${target}/`)) continue;
+        out.push({ tab, path, fid, instance: this.instances.get(tab) });
+      }
+    }
+    return out;
+  }
+  ask(to, body, cap) {
+    const seq2 = ++this.seq;
+    this.channel.postMessage({ tab: this.tab, to, seq: seq2, ...body });
+    return new Promise((resolve2) => {
+      const done4 = () => {
+        clearTimeout(timer);
+        this.waiting.delete(seq2);
+        resolve2(left.size === 0);
+      };
+      const left = /* @__PURE__ */ new Set([to]);
+      const timer = setTimeout(done4, cap);
+      this.waiting.set(seq2, { left, done: done4 });
+    });
+  }
+  peerHeld(path) {
+    const out = [];
+    for (const [tab, held] of this.peerHolds)
+      if (held.has(path)) out.push({ tab, fid: held.get(path) });
+    return out;
+  }
+  peerHeldPaths() {
+    const out = /* @__PURE__ */ new Set();
+    for (const held of this.peerHolds.values()) for (const path of held.keys()) out.add(path);
+    return [...out].sort();
+  }
+  holdCounts() {
+    let peers = 0;
+    for (const held of this.peerHolds.values()) peers += held.size;
+    return { mine: this.myHolds.size, peers, sent: this.holdsSent };
+  }
   acked(seq2, from) {
     const wait2 = this.waiting.get(seq2);
     if (!wait2) return;
@@ -23597,11 +23899,14 @@ var RemoteWatch = class {
     if (!this.locks) return;
     const held = new Set(((await this.locks.query()).held ?? []).map((lock) => lock.name));
     let left = false;
-    for (const tab of /* @__PURE__ */ new Set([...this.others.keys(), ...this.peers])) {
+    for (const tab of /* @__PURE__ */ new Set([...this.others.keys(), ...this.peers, ...this.peerHolds.keys()])) {
       if (!held.has(this.lockOf(tab))) {
         if (this.peers.delete(tab)) left = true;
         this.others.delete(tab);
+        this.peerHolds.delete(tab);
+        this.keeps?.left(tab);
         this.ackers.delete(tab);
+        this.holders.delete(tab);
       }
     }
     this.rebuild();
@@ -23649,8 +23954,9 @@ var RemoteWatch = class {
   renamedTree(lock) {
     this.channel.postMessage({ renamed: lock });
   }
-  acks(seq2, from) {
+  acks(seq2, from, missed) {
     if (from.size === 0) return Promise.resolve();
+    const left = new Set(from);
     return new Promise((resolve2) => {
       const done4 = () => {
         clearTimeout(timer);
@@ -23658,10 +23964,11 @@ var RemoteWatch = class {
         resolve2();
       };
       const timer = setTimeout(() => {
+        missed?.(left);
         done4();
         void this.prune();
       }, ANNOUNCE_WAIT_MS);
-      this.waiting.set(seq2, { left: new Set(from), done: done4 });
+      this.waiting.set(seq2, { left, done: done4 });
     });
   }
   emit(change) {
@@ -25073,6 +25380,7 @@ function translate(err, path, op = "lookup", mapped = true) {
   return error;
 }
 var META_OPS = ["get", "update", "move", "remove", "links", "under", "all"];
+var FILE_ID_TRIES = 3;
 function sidecar(meta) {
   const pathOf = ([first]) => [first, "/"].flat().find((p) => typeof p === "string");
   const guarded3 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
@@ -25312,18 +25620,48 @@ var OpfsFs = class {
     this.channel?.postMessage(paths);
   }
   async fileId(path) {
+    for (let tries = 0; tries < FILE_ID_TRIES; tries++) {
+      const fid = await this.assignId(path);
+      if (fid !== void 0) return fid;
+    }
+    throw fsError("EAGAIN", `${path}: moved while its file id was assigned`);
+  }
+  bindId(path) {
+    return this.assignId(path);
+  }
+  async assignId(path) {
     const found = await this.locate(path, true);
     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();
+    let moved2 = false;
+    await this.meta.update(found.path, (now) => {
+      const vacatedSince = now?.vacated && (!entry?.vacated || now.ino !== entry.ino);
+      if (vacatedSince || entry !== void 0 && now === void 0) {
+        moved2 = true;
+        return now;
+      }
+      return { ...occupied(now), path: found.path, fid: now?.fid ?? fid };
+    });
+    if (moved2) return void 0;
     this.idWrites++;
-    await this.meta.update(found.path, (now) => ({
-      ...occupied(now),
-      path: found.path,
-      fid: now?.fid ?? fid
-    }));
-    const [stored] = await this.meta.get([found.path]);
-    return stored?.fid ?? fid;
+    const there = await this.locate(path, true).then(
+      (at) => at.path === found.path,
+      () => false
+    );
+    if (there) return (await this.meta.get([found.path]))[0]?.fid ?? fid;
+    const gone = await this.locate(found.path, true).then(
+      () => false,
+      (err) => missing4(err)
+    );
+    if (gone) {
+      await this.meta.update(found.path, (now) => {
+        if (now?.fid !== fid || now.vacated) return now;
+        const { fid: _, ...rest2 } = now;
+        return rest2;
+      });
+    }
+    return void 0;
   }
   heldUnder = () => [];
   heldBy(held) {
@@ -25342,6 +25680,30 @@ var OpfsFs = class {
     return this.remote?.listen(listener) ?? (() => {
     });
   }
+  announceHolds(add, drop, wait2) {
+    return this.remote?.hold(add, drop, wait2) ?? Promise.resolve();
+  }
+  holdCounts() {
+    const remote = this.remote;
+    return remote && { ...remote.holdCounts(), held: remote.peerHeldPaths() };
+  }
+  peerKeeps() {
+    const remote = this.remote;
+    if (!remote) return void 0;
+    return {
+      shared: () => this.shared(),
+      heldWithin: (path) => remote.heldWithin(path),
+      ask: (to, body, cap) => remote.ask(to, body, cap)
+    };
+  }
+  servePeerKeeps(instance, handlers) {
+    if (!this.remote) return;
+    this.remote.instance = instance;
+    this.remote.keeps = handlers;
+  }
+  rehold(from, to) {
+    this.remote?.rehold(from, to);
+  }
   announceWatch(paths) {
     return this.remote?.announce(paths) ?? Promise.resolve();
   }
@@ -26286,7 +26648,7 @@ var OpfsFs = class {
     }
   }
   async writeFile(path, content, owner) {
-    const [file, existed, target] = await this.fileFor(path);
+    const [file, existed, target] = await this.fileFor(path, owner?.existing !== true);
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
     let writable2;
@@ -30034,7 +30396,12 @@ var Launcher = class {
   identities = { asked: 0, timedOut: 0 };
   nodes;
   unlinked;
-  held = new HeldSet((path) => this.released(path));
+  held = new HeldSet(
+    (path) => this.released(path),
+    (from, to) => {
+      if (this.mounts.locate(to) === void 0) this.rootFs.rehold?.(from, to);
+    }
+  );
   processMounts;
   booting = new AbortController();
   fstab = Promise.resolve([]);
@@ -30172,7 +30539,7 @@ var Launcher = class {
         busy: (path) => [...this.openFiles].some((nodes) => nodes.holds(path)),
         owner: options.unlinkOwner,
         marks: this.pathMarks,
-        ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
+        ...this.peerOptions(options.fs)
       }
     );
     this.fs = this.processChain(fs, this.nodes, this.unlinked);
@@ -31006,7 +31373,7 @@ var Launcher = class {
     const assign = this.mounts.locate(target.wasm) === void 0 ? this.rootFs.fileId : void 0;
     return this.base.stat(target.wasm).then(
       async (st) => {
-        const fid = st.fid ?? await assign?.call(this.rootFs, target.wasm);
+        const fid = st.fid ?? await assign?.call(this.rootFs, target.wasm)?.catch(() => void 0);
         if (fid === void 0) return exeIdOf(fileIdentity(st.ino, st.mtime.getTime()));
         return { exeId: `fid:${fid}:${st.mtime.getTime()}` };
       },
@@ -31252,7 +31619,8 @@ var Launcher = class {
         cwdChecks: this.cwds.checks,
         renameAcks: this.rootFs.renameWaits?.(),
         staleFds: staleFdCount(),
-        fileIds: this.rootFs.fileIdWrites?.() ?? 0
+        fileIds: this.rootFs.fileIdWrites?.() ?? 0,
+        holds: this.rootFs.holdCounts?.()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -31264,6 +31632,7 @@ var Launcher = class {
       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,
+      announceHold: (path, fid, created4) => this.locks.shared?.() === true && this.mounts.locate(path) === void 0 ? this.rootFs.announceHolds?.([[path, fid]], [], !created4) : void 0,
       renameSeq: (from, to) => this.renameLog.seqOf(from, to),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),
@@ -31705,6 +32074,8 @@ var Launcher = class {
     const at = normalizePath(path);
     this.unlinked.closed(at);
     this.writers?.unlinked.closed(at);
+    if (![...this.held].some((holds2) => holds2.holding(at)))
+      void this.rootFs.announceHolds?.([], [at], false);
     const open = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open) void this.mounts.commit(at).catch(() => void 0);
   }
@@ -32164,8 +32535,82 @@ var Launcher = class {
     this.writers ??= this.writerStack();
     return this.writers;
   }
+  peerGates = /* @__PURE__ */ new Map();
+  peerOptions(fs) {
+    const peers = fs.peerKeeps?.();
+    queueMicrotask(() => fs.servePeerKeeps?.(this.unlinked.id, this.peerKept()));
+    return {
+      ...peers ? { peers } : {},
+      ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
+    };
+  }
+  peerKept() {
+    const gates = this.peerGates;
+    const gone = /* @__PURE__ */ new Set();
+    const instance = this.unlinked.id;
+    const ours = (hidden) => hidden.startsWith(`/${UNLINKED_DIR}/${instance}.p`) && /^[0-9a-f]+$/.test(hidden.slice(`/${UNLINKED_DIR}/${instance}.p`.length));
+    const open = (tab, paths) => {
+      for (const [key, release] of [...gates]) {
+        const [owner, path] = key.split("\0");
+        if (owner !== tab || paths && !paths.includes(path)) continue;
+        gates.delete(key);
+        release();
+      }
+    };
+    return {
+      keeping: async (tab, paths) => {
+        for (const path of paths) {
+          if (gone.has(tab)) return;
+          const release = await this.unlinked.gate.acquire(path);
+          const key = `${tab}\0${path}`;
+          let done4 = false;
+          const once2 = () => {
+            if (done4) return;
+            done4 = true;
+            clearTimeout(timer);
+            release();
+          };
+          const timer = setTimeout(() => {
+            if (gates.get(key) === once2) gates.delete(key);
+            once2();
+          }, PEER_GATE_MS);
+          if (gone.has(tab)) once2();
+          else gates.set(key, once2);
+        }
+      },
+      kept: async (tab, items, paths) => {
+        for (const { path, hidden, fid, undo } of items) {
+          if (undo !== void 0) this.unadopt(path, undo, fid);
+          else this.adoptKept(path, hidden, fid, ours);
+        }
+        open(tab, paths);
+      },
+      left: (tab) => {
+        gone.add(tab);
+        open(tab);
+      }
+    };
+  }
+  unadopt(path, undo, fid) {
+    for (const holds2 of this.held) holds2.unkeepAt(path, undo);
+    void this.rootFs.announceHolds?.([[path, fid]], [], false);
+  }
+  adoptKept(path, hidden, fid, ours) {
+    if (hidden === void 0 || !ours(hidden)) {
+      this.held.doubt([path]);
+      return;
+    }
+    const bound3 = [...this.held].map(
+      (holds2) => [holds2, [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)]]
+    );
+    const keeping = bound3.filter(([, ids]) => ids.length > 0);
+    const file = this.unlinked.adopt(hidden, Math.max(keeping.length, 1));
+    if (keeping.length === 0) file.release();
+    for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
+    void this.rootFs.announceHolds?.([], [path, hidden], false);
+  }
   rootFileId(path) {
-    return this.mounts.locate(path) === void 0 ? this.rootFs.fileId?.(path) : void 0;
+    return this.mounts.locate(path) === void 0 ? this.rootFs.bindId?.(path) : void 0;
   }
   flushingPeers(fs) {
     const peers = fs.peers?.();
@@ -32211,6 +32656,7 @@ var Launcher = class {
         busy: (path) => [...this.openFiles].some((open) => open.holds(path)),
         owner: this.unlinkOwnerOption,
         marks: this.pathMarks,
+        peers: this.rootFs.peerKeeps?.(),
         ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );