@ai-ecoverse/slicc-kernel 1.161.0 → 1.162.1

package/dist/node.js

@@ -1,6 +1,6 @@
 // src/node.ts
 import { createHash } from "node:crypto";
-import { lstatSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { lstatSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { MessageChannel as MessageChannel2, Worker } from "node:worker_threads";
@@ -2212,7 +2212,9 @@ var KernelSocket = class _KernelSocket {
           throw new KernelError("ECONNRESET", "read ECONNRESET");
         return bytes.length > 0 ? bytes : null;
       },
-      write: (bytes) => raw2.tx.write(bytes),
+      write: (bytes) => raw2.tx.write(bytes).catch((err) => {
+        throw this.refused ? new KernelError("ECONNRESET", "read ECONNRESET") : err;
+      }),
       closeWrite: () => raw2.tx.closeWrite(),
       close: () => {
         raw2.rx.closeRead();
@@ -3675,7 +3677,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.161.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.162.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
@@ -4638,6 +4640,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 +4685,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 +4763,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 +4930,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 +5092,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 +6502,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 +6604,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 +6769,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);
@@ -9022,12 +9153,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);
@@ -9596,12 +9740,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
@@ -9698,10 +9842,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;
       }
@@ -9719,10 +9863,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) {
@@ -10459,6 +10603,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);
@@ -10529,7 +10678,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));
@@ -23425,6 +23574,9 @@ var RemoteWatch = class {
   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;
@@ -23544,8 +23696,9 @@ var RemoteWatch = class {
       this.met?.();
     }
     if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
-    if (data.tab !== void 0 && data.holds !== void 0) this.heldBy(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 });
@@ -23572,6 +23725,7 @@ var RemoteWatch = class {
       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);
@@ -23612,9 +23766,38 @@ 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);
@@ -23656,9 +23839,38 @@ var RemoteWatch = class {
   sendHolds(add, drop) {
     const seq2 = ++this.seq;
     this.holdsSent++;
-    this.channel.postMessage({ tab: this.tab, holds: { add: [...add], drop: [...drop] }, seq: seq2 });
+    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)
@@ -23694,6 +23906,7 @@ var RemoteWatch = class {
         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);
       }
@@ -25169,6 +25382,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) => {
@@ -25408,18 +25622,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) {
@@ -25445,6 +25689,20 @@ var OpfsFs = class {
     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);
   }
@@ -26392,7 +26650,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;
@@ -30283,7 +30541,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);
@@ -31117,7 +31375,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()}` };
       },
@@ -32279,8 +32537,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?.();
@@ -32326,6 +32658,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 } } : {}
       }
     );
@@ -35024,25 +35357,38 @@ function ownCacheDir(make = privateCacheDir) {
   }
 }
 var swept = false;
-function privateCacheDir(base = tmpdir(), alive = pidAlive) {
+function privateCacheDir(base = tmpdir(), alive = pidAlive, uid = process.getuid?.()) {
+  const parent = cacheParent(base, uid);
   if (!swept) {
     swept = true;
-    sweepCacheDirs(base, alive);
+    sweepCacheDirs(parent, alive, uid);
+  }
+  return mkdtempSync(join(parent, `${process.pid}-`));
+}
+function cacheParent(base, uid) {
+  const parent = join(base, uid === void 0 ? "slicc-kernel-cc" : `${CACHE_PREFIX}u${uid}`);
+  try {
+    mkdirSync(parent, { mode: 448 });
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  const st = lstatSync(parent);
+  if (!st.isDirectory() || uid !== void 0 && (st.uid !== uid || (st.mode & 63) !== 0)) {
+    throw new Error(`slicc-kernel: ${parent} is not a private directory of this user`);
   }
-  return mkdtempSync(join(base, `${CACHE_PREFIX}${process.pid}-`));
+  return parent;
 }
-function sweepCacheDirs(base, alive = pidAlive, uid = process.getuid?.()) {
+function sweepCacheDirs(parent, alive = pidAlive, uid = process.getuid?.()) {
   let names2;
   try {
-    names2 = readdirSync(base);
+    names2 = readdirSync(parent);
   } catch {
     return;
   }
   for (const name2 of names2) {
-    if (!name2.startsWith(CACHE_PREFIX)) continue;
-    const pid = Number(name2.slice(CACHE_PREFIX.length).split("-")[0]);
+    const pid = Number(name2.split("-")[0]);
     if (!Number.isInteger(pid) || pid <= 0 || alive(pid)) continue;
-    removeOurs(join(base, name2), uid);
+    removeOurs(join(parent, name2), uid);
   }
 }
 function removeOurs(path, uid) {