@ai-ecoverse/slicc-kernel 1.178.2 → 1.178.4

package/README.md

@@ -1067,7 +1067,7 @@ With `users: 'enforce'`, the default, or `'report'`, files have owners, and [Per
 - **Homes:** every `kernel.users.add` gives the user's home (only a real directory at `/home/<dir>`, not a symlink or a path through one) and everything in it without an owner of its own to the user, and sets the home's mode: `0700`, `0750` for a `scoop-` user, `2750` with `homeGroup`, and its `~/.local/share/pnpm`'s to `0700` (`0750` for a `scoop-` user). The embedder calls `add` for each user at boot, as it already does, so homes made before owners were on become the user's. That also means a user's own `chmod` or `chgrp` of its home lasts only until the next `add`, and `add` must get the same `homeGroup` every time.
 - **`chown`, `lchown`, `fchown`:** Emscripten programs, and WASI programs through `slicc_fs` (see [File modes and the umask](#file-modes-and-the-umask)), change owners through the kernel, by the Linux rules: root may set any owner and group; a file's owner may set its group to one it belongs to, or leave it as it is; anything else fails with `EPERM`. `-1` keeps an id. A `chown` that sets an owner or group of a file clears its setuid bit, and its setgid bit if the file is group-executable, whoever calls it, root included, as on Linux. With `users: 'off'`, `chown` succeeds and changes nothing, as before.
 - **What programs see:** `stat` shows the owners to Emscripten programs, whatever their libc reports for their own ids, so a program built before H1 sees real owners too, and its owner checks can fail. WASI programs read them with `slicc_fs.fd_owner` and `path_owner`. The commands in `/usr/bin` and `/bin` are root's, and a user's own commands in `~/.local/share/pnpm/bin` belong to the owner of the closest real directory above them, normally the user.
-- **Mounts:** the options `uid=` and `gid=` (decimal ids) give a mount its owner; without them it belongs to whoever mounted it: root for `kernel.mount`, `/etc/fstab` and a client, the process's effective ids for `mount(2)`, which then shows them in its options (a process that isn't root gets its own ids whatever `uid=` and `gid=` it passes, so it can't make a mount look root's). A mount whose driver keeps owners (`tmpfs`) starts with its root owned so, and its files get owners as on the root file system, `chown` included. On `hostfs`, `fsa` and any driver without `owners`, every file shows as the mount's owner and `chown` fails with `EPERM`, root's too, as on a FAT drive. An embedder that mounts a folder for a user (bios's linked and picked folders) passes that user's `uid` and `gid`, or the user's programs see root's files there, and git calls the repository's ownership dubious. Those mounts also take the FAT-style options `umask=`, `fmask=` and `dmask=` (octal, as on Linux `vfat`): when any is set, the kernel synthesises the permission bits that `stat` and DAC see from `0666` for files and `0777` for directories (and symlinks), less the mask (`fmask` for files, `dmask` for directories, and `umask` as the default for both). Without them, files stay `0644` and directories `0755` as before, so only the mount's `uid` may write. `umask=000` (or `fmask=000,dmask=000`) makes every file and directory world-writable under DAC, which is how a personal cone (another uid) can write a folder mounted as the template `cone` user. When a mask is set on a mount without a `chmod` capability (`fsa`), `chmod` is a no-op and is not owner-only, so a create that then sets the mode from another uid still succeeds. Without a mask, and on a mount that keeps real modes through `chmod` (`hostfs`), `chmod` still requires the mount's `uid` (or root). Drivers with `owners` (`tmpfs`) ignore the mask options: their modes stay real, and chmod still requires the owner.
+- **Mounts:** the options `uid=` and `gid=` (decimal ids) give a mount its owner; without them it belongs to whoever mounted it: root for `kernel.mount`, `/etc/fstab` and a client, the process's effective ids for `mount(2)`, which then shows them in its options (a process that isn't root gets its own ids whatever `uid=` and `gid=` it passes, so it can't make a mount look root's). A mount whose driver keeps owners (`tmpfs`) starts with its root owned so, and its files get owners as on the root file system, `chown` included. On `hostfs`, `fsa` and any driver without `owners`, every file shows as the mount's owner and `chown` fails with `EPERM`, root's too, as on a FAT drive. An embedder that mounts a folder for a user (bios's linked and picked folders) passes that user's `uid` and `gid`, or the user's programs see root's files there, and git calls the repository's ownership dubious. Those mounts also take the FAT-style options `umask=`, `fmask=` and `dmask=` (octal, as on Linux `vfat`): when any is set, the kernel synthesises the permission bits that `stat` and DAC see from `0666` for files and `0777` for directories (and symlinks), less the mask (`fmask` for files, `dmask` for directories, and `umask` as the default for both). Without them, files stay `0644` and directories `0755` as before, so only the mount's `uid` may write. `umask=000` (or `fmask=000,dmask=000`) makes every file and directory world-writable under DAC, which is how a personal cone (another uid) can write a folder mounted as the template `cone` user. When a mask is set on a mount without a `chmod` capability (`fsa`), `chmod` is a no-op and is not owner-only, so a create that then sets the mode from another uid still succeeds, and a non-owner who can write the file may set its times to an explicit value (`utimes` / `cp -p` / `tar x`), as on Linux `vfat` with a uid/umask mount; "now" times already needed only write access. Without a mask, and on a mount that keeps real modes through `chmod` (`hostfs`), `chmod` still requires the mount's `uid` (or root), and explicit times stay owner-only. Drivers with `owners` (`tmpfs`) ignore the mask options: their modes stay real, and chmod and explicit times still require the owner.
 
 ### Permissions
 

package/dist/kernel-worker.js

@@ -1339,8 +1339,8 @@ var RemoteWatch = class {
     const { held = [], pending = [] } = await this.locks.query();
     if (![...held, ...pending].some((lock) => lock.name === name2)) {
       this.mourned.delete(peer);
-      const live = this.peers.has(peer) || this.flushes.has(peer);
-      if (tries > 1 && live) {
+      const live2 = this.peers.has(peer) || this.flushes.has(peer);
+      if (tries > 1 && live2) {
         setTimeout(() => void this.mourn(peer, tries - 1), MOURN_RETRY_MS);
       } else this.flushedAt(peer);
       return;
@@ -1830,11 +1830,11 @@ async function positioned(handle, op) {
     }
     return;
   }
-  const writable2 = await handle.createWritable({ keepExistingData: true });
+  const writable3 = await handle.createWritable({ keepExistingData: true });
   try {
     await op({
       write: async (at, bytes) => {
-        await writable2.write({
+        await writable3.write({
           type: "write",
           position: at,
           data: bytes
@@ -1842,15 +1842,15 @@ async function positioned(handle, op) {
         extent.wrote(at + bytes.length);
       },
       truncate: async (n) => {
-        await writable2.truncate(n);
+        await writable3.truncate(n);
         extent.cut(n);
       }
     });
   } catch (err) {
-    await writable2.abort();
+    await writable3.abort();
     throw err;
   }
-  await writable2.close();
+  await writable3.close();
   if (extent.big()) extent.check((await handle.getFile()).size);
 }
 function syncAccessHandles(scope = globalThis) {
@@ -2936,21 +2936,21 @@ var OpfsFs = class {
   }
   async writeSession(path, truncate) {
     const [handle, , target] = await this.fileFor(path);
-    const writable2 = await this.retrying(
+    const writable3 = await this.retrying(
       path,
       () => this.io(handle.createWritable({ keepExistingData: !truncate })),
       true
     );
     return {
-      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }).catch((err) => {
+      write: (at, bytes) => writable3.write({ type: "write", position: at, data: bytes }).catch((err) => {
         throw translate(err, path, "write", false);
       }),
-      truncate: (size) => writable2.truncate(size).catch((err) => {
+      truncate: (size) => writable3.truncate(size).catch((err) => {
         throw translate(err, path, "write", false);
       }),
       close: async () => {
         this.wrote(handle);
-        await writable2.close().catch((err) => {
+        await writable3.close().catch((err) => {
           this.wrote(handle);
           throw translate(err, path, "commit", false);
         });
@@ -3002,19 +3002,19 @@ var OpfsFs = class {
     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;
+    let writable3;
     this.wrote(file);
     try {
-      writable2 = await this.io(file.createWritable());
-      await writable2.write(content);
-      await writable2.close();
+      writable3 = await this.io(file.createWritable());
+      await writable3.write(content);
+      await writable3.close();
       if (typeof content !== "string" && content.length >= CHECKED_BYTES) {
         const extent = new Extent();
         extent.cut(content.length);
         extent.check((await file.getFile()).size);
       }
     } catch (err) {
-      await writable2?.abort().catch(() => void 0);
+      await writable3?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
     } finally {
       this.wrote(file);
@@ -3739,7 +3739,7 @@ var OpfsFs = class {
       created4 = true;
     }
     let target = destination;
-    let writable2;
+    let writable3;
     let handle;
     try {
       const kept = created4 ? this.files.get(destination) : void 0;
@@ -3758,11 +3758,11 @@ var OpfsFs = class {
         if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
       }
       this.wrote(handle);
-      writable2 = await handle.createWritable();
-      await writable2.write(file);
-      await writable2.close();
+      writable3 = await handle.createWritable();
+      await writable3.write(file);
+      await writable3.close();
     } catch (err) {
-      await writable2?.abort().catch(() => void 0);
+      await writable3?.abort().catch(() => void 0);
       if (created4) await this.rm(target, { file: true }).catch(() => void 0);
       throw translate(err, to, "commit", false);
     } finally {
@@ -3851,10 +3851,10 @@ var OpfsFs = class {
     }
     if (handle.kind === "file") {
       const made2 = await this.io(dir.getFileHandle(name2, { create: true }));
-      const writable2 = await this.io(made2.createWritable());
+      const writable3 = await this.io(made2.createWritable());
       const file = await this.io(handle.getFile());
-      await writable2.write(file);
-      await writable2.close();
+      await writable3.write(file);
+      await writable3.close();
       copies?.set(rest2, { before: copies.get(rest2)?.before ?? file.lastModified, made: made2 });
       return;
     }
@@ -5572,13 +5572,6 @@ async function linkable(g, from, to, follow2) {
   }
   await inParent(g, "link", to);
 }
-async function ownerOnly(g, op, path, follow2) {
-  const walked = await need(g, op, path, 0, { follow: follow2 });
-  const perm = walked.perm;
-  if (!perm || g.cred.euid === 0 || perm.uid === g.cred.euid) return walked;
-  if (await present(g.fs, walked.path, false)) deny(g, op, path, "EPERM");
-  return walked;
-}
 async function chmodMode(g, path, mode) {
   const walked = await need(g, "chmod", path, 0, { follow: true });
   const perm = walked.perm;
@@ -5600,17 +5593,26 @@ function heldChmodMode(g, path, st, mode) {
 function heldRetimable(g, path, st, now) {
   const perm = permOf(st);
   if (g.cred.euid === 0 || perm.uid === g.cred.euid) return;
-  if (!now) deny(g, "futimens", path, "EPERM");
-  else if (!permits(g.cred, perm, W_OK, false)) deny(g, "futimens", path);
+  if (now || st.fat) {
+    if (!permits(g.cred, perm, W_OK, false)) deny(g, "futimens", path);
+    return;
+  }
+  deny(g, "futimens", path, "EPERM");
 }
 async function retimable(g, op, path, now = false) {
   const follow2 = op !== "lutimes";
-  if (!now) return void await ownerOnly(g, op, path, follow2);
   const walked = await need(g, op, path, 0, { follow: follow2 });
   const perm = walked.perm;
   if (!perm || g.cred.euid === 0 || perm.uid === g.cred.euid) return;
-  if (permits(g.cred, perm, W_OK, false)) return;
-  if (await present(g.fs, walked.path, false)) deny(g, op, path);
+  const look = follow2 ? g.fs.stat : g.fs.lstat;
+  const st = await look.call(g.fs, walked.path).catch(() => void 0);
+  if (now || st?.fat) {
+    if (!permits(g.cred, perm, W_OK, false) && await present(g.fs, walked.path, false)) {
+      deny(g, op, path);
+    }
+    return;
+  }
+  if (await present(g.fs, walked.path, false)) deny(g, op, path, "EPERM");
 }
 async function fileWritable(g, op, path) {
   await need(g, op, path, W_OK, { directory: false });
@@ -8777,7 +8779,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.178.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.178.4" : "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
@@ -17089,11 +17091,11 @@ function systemFile(name2, listing, now, memory) {
       listing.processes.reduce((sum2, p) => sum2 + p.memory, 0)
     );
   }
-  const live = listing.processes.filter((p) => p.state !== "Z");
+  const live2 = listing.processes.filter((p) => p.state !== "Z");
   if (name2 === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
     const [one, five, fifteen] = (listing.load ?? [0, 0, 0]).map((n) => n.toFixed(2));
-    return `${one} ${five} ${fifteen} 1/${live.length} ${last}
+    return `${one} ${five} ${fifteen} 1/${live2.length} ${last}
 `;
   }
   const sum = (key) => listing.cpu?.[key] ?? listing.processes.reduce((n, p) => n + (p[key] ?? 0), 0);
@@ -19582,30 +19584,49 @@ function timestampKey(owner, type) {
   }
   return parent ? JSON.stringify(["ppid", parent.pid, parent.started]) : void 0;
 }
+function boundKey(bound3) {
+  return JSON.stringify(
+    Object.keys(bound3).sort().map((path) => [path, bound3[path]])
+  );
+}
+function writable2(bound3) {
+  return bound3 !== void 0 && Object.keys(bound3).length > 0;
+}
+function live(stamp, policy, now) {
+  return stamp.at <= now && (policy.minutes < 0 || now - stamp.at < policy.minutes * MINUTE_MS2);
+}
 var Timestamps = class {
   users = /* @__PURE__ */ new Map();
   now;
   constructor(now) {
     this.now = now;
   }
-  current(owner, policy) {
+  current(owner, policy, bound3) {
     if (policy.minutes === 0) return false;
     const key = timestampKey(owner, policy.type);
-    const at = key === void 0 ? void 0 : this.users.get(owner.uid)?.get(key);
-    if (at === void 0) return false;
+    const stamp = key === void 0 ? void 0 : this.users.get(owner.uid)?.get(key);
+    if (stamp === void 0) return false;
     const now = this.now();
-    return at <= now && (policy.minutes < 0 || now - at < policy.minutes * MINUTE_MS2);
+    if (!live(stamp, policy, now)) {
+      this.drop(owner.uid, key);
+      return false;
+    }
+    if (!writable2(bound3)) return true;
+    return stamp.covered.has(boundKey(bound3));
   }
-  stamp(owner, policy) {
+  stamp(owner, policy, bound3) {
     const key = policy.minutes === 0 ? void 0 : timestampKey(owner, policy.type);
     if (key === void 0) return false;
     const now = this.now();
     const records = this.users.get(owner.uid) ?? /* @__PURE__ */ new Map();
     this.users.set(owner.uid, records);
+    const prior = records.get(key);
+    const covered = prior !== void 0 && live(prior, policy, now) ? prior.covered : /* @__PURE__ */ new Set();
+    if (writable2(bound3)) covered.add(boundKey(bound3));
     records.delete(key);
-    records.set(key, now);
-    for (const [old, at] of records) {
-      const stale = policy.minutes > 0 && (at > now || now - at >= policy.minutes * MINUTE_MS2);
+    records.set(key, { at: now, covered });
+    for (const [old, stamp] of records) {
+      const stale = policy.minutes > 0 && !live(stamp, policy, now);
       if (stale || records.size > TIMESTAMPS_MAX) records.delete(old);
     }
     return true;
@@ -19619,6 +19640,11 @@ var Timestamps = class {
   remove(uid) {
     this.users.delete(uid);
   }
+  drop(uid, key) {
+    const records = this.users.get(uid);
+    records?.delete(key);
+    if (records?.size === 0) this.users.delete(uid);
+  }
 };
 
 // src/sudoers.ts
@@ -20248,12 +20274,12 @@ function usable(parsed2) {
 function policyOf(settings) {
   return { type: settings.timestampType, minutes: settings.timestampTimeout };
 }
-function described(rule, writable2) {
+function described(rule, writable3) {
   const cmnd = rule.cmnd === "*" ? "ALL" : commandText(rule.cmnd);
   const cwd = rule.cwd === void 0 ? "" : `CWD=${quoteWord(rule.cwd)} `;
   const stdin = rule.stdin === void 0 ? "" : "STDIN=none ";
   const sums = Object.entries(rule.sha256 ?? {}).map(([path, hex4]) => `SHA256=${quoteWord(path)}:${hex4} `).join("");
-  const flag = writable2 ? "  # user-writable command" : "";
+  const flag = writable3 ? "  # user-writable command" : "";
   return `    (${rule.target}) ${cwd}${stdin}${sums}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}${flag}`;
 }
 var Sudo = class {
@@ -20546,8 +20572,8 @@ var Sudo = class {
         `sudo: ${self.name} is not allowed to run ${quoted} as ${target.name}`
       );
     }
-    if (!parsed2.reset && this.timestamps.current(s.owner, s.policy)) {
-      this.timestamps.stamp(s.owner, s.policy);
+    if (!parsed2.reset && this.timestamps.current(s.owner, s.policy, bound3)) {
+      this.timestamps.stamp(s.owner, s.policy, bound3);
       this.logged(s, cwd, argv);
       return grant();
     }
@@ -20562,7 +20588,7 @@ var Sudo = class {
       if (!now) return failed2("ENOENT", `sudo: ${word}: command not found`);
       const shown2 = recordable(cwd, [...parsed2.command, ...Object.keys(bound3)]);
       const result = answer2.answer === "once" ? grant() : await this.always(self, target, { cwd, argv, bound: bound3 }, now, shown2, grant);
-      if (!("error" in result)) this.stamped(s, answer2);
+      if (!("error" in result)) this.stamped(s, answer2, bound3);
       return result;
     });
   }
@@ -20596,8 +20622,8 @@ var Sudo = class {
       this.pending.delete(uid);
     }
   }
-  stamped(s, answer2) {
-    if (answer2.person && !s.parsed.reset) this.timestamps.stamp(s.owner, s.policy);
+  stamped(s, answer2, bound3 = {}) {
+    if (answer2.person && !s.parsed.reset) this.timestamps.stamp(s.owner, s.policy, bound3);
   }
   logged(s, cwd, argv) {
     const { caller, self, target, owner, policy } = s;
@@ -26954,18 +26980,18 @@ var VfsNodes = class {
     if (id2 !== void 0) this.know(node, id2);
     return node;
   }
-  open(path, pin, writable2 = false, id2, ino) {
+  open(path, pin, writable3 = false, id2, ino) {
     const found = this.named(path, id2);
     const same3 = !found || ino === void 0 || found.ino === void 0 || found.ino === ino;
     if (found && !same3) this.orphan(found);
     const node = (same3 ? found : void 0) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
     node.ino ??= ino;
     node.opens++;
-    if (writable2) node.writers++;
+    if (writable3) node.writers++;
     if (node.opens === 1) this.opened?.(node);
     return node;
   }
-  adopt(path, contents2, dirty, writable2 = false, id2) {
+  adopt(path, contents2, dirty, writable3 = false, id2) {
     let node = this.named(path, id2);
     if (!node) {
       node = this.create(path, id2, new VfsNode(this.fs, path, contents2, false, dirty));
@@ -26973,7 +26999,7 @@ var VfsNodes = class {
       node.replace(contents2);
     }
     node.opens++;
-    if (writable2) node.writers++;
+    if (writable3) node.writers++;
     if (node.opens === 1) this.opened?.(node);
     return node;
   }
@@ -26986,11 +27012,11 @@ var VfsNodes = class {
       if (node.writers > 0 && within9(path, prefix)) return true;
     return false;
   }
-  closed(node, writable2 = false) {
+  closed(node, writable3 = false) {
     node.opens--;
-    if (writable2) node.writers--;
+    if (writable3) node.writers--;
     if (node.opens > 0) {
-      if (writable2 && node.writers === 0) this.onClosed?.(node.path);
+      if (writable3 && node.writers === 0) this.onClosed?.(node.path);
       return;
     }
     this.forget(node);
@@ -27309,8 +27335,8 @@ function keepingOpen(fs, nodes, changed = () => {
 function vfsFile(fs, opts, nodes) {
   const access2 = opts.flags & O_ACCMODE;
   const readable2 = access2 !== O_WRONLY;
-  const writable2 = access2 === O_WRONLY || access2 === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id, opts.ino);
+  const writable3 = access2 === O_WRONLY || access2 === O_RDWR;
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable3, opts.id) : nodes.open(opts.path, opts.pin, writable3, opts.id, opts.ino);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -27337,7 +27363,7 @@ function vfsFile(fs, opts, nodes) {
       offset += out.length;
       return out;
     }) : void 0,
-    write: writable2 ? (bytes) => serial(async () => {
+    write: writable3 ? (bytes) => serial(async () => {
       if (opts.flags & O_APPEND) offset = await node.append(bytes);
       else offset += await node.pwrite(bytes, offset);
       return bytes.length;
@@ -27356,11 +27382,11 @@ function vfsFile(fs, opts, nodes) {
       return node.pread(max, at);
     }),
     pwrite: (bytes, at) => serial(() => {
-      if (!writable2) throw new KernelError("EBADF");
+      if (!writable3) throw new KernelError("EBADF");
       return node.pwrite(bytes, at);
     }),
     resize: (size) => serial(() => {
-      if (!writable2) throw new KernelError("EBADF");
+      if (!writable3) throw new KernelError("EBADF");
       return node.truncate(size);
     }),
     stat: () => serial(async () => ({
@@ -27376,7 +27402,7 @@ function vfsFile(fs, opts, nodes) {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node, writable2);
+        nodes?.closed(node, writable3);
       }
     })
   });
@@ -29105,8 +29131,8 @@ var WasmProcess = class {
   };
   withDl(state) {
     if (this.dlLog.length === 0) return state;
-    const { next: next3, handle, free, live } = this.closures;
-    const dl = { log: [...this.dlLog], next: next3, handle, free: [...free], live: [...live] };
+    const { next: next3, handle, free, live: live2 } = this.closures;
+    const dl = { log: [...this.dlLog], next: next3, handle, free: [...free], live: [...live2] };
     return { ...state, dl };
   }
   seedDl(dl) {
@@ -32330,7 +32356,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     if (remote.client.token === remote.token && !remote.client.gone) return remote;
     throw fsError2("ESTALE", "the folder was granted again, so this open file is gone");
   };
-  const live = (fh) => {
+  const live2 = (fh) => {
     const remote = handles.get(fh);
     if (!remote) throw fsError2("EBADF", `handle ${fh}`);
     return fresh3(remote);
@@ -32349,7 +32375,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     }, againMs);
     timer.unref?.();
   });
-  async function writable2(client, path, flags2) {
+  async function writable3(client, path, flags2) {
     const { ifMatch: _, ...asked } = flags2;
     const opening2 = () => client.call("open", { path: rel(path), ...asked });
     try {
@@ -32380,7 +32406,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     async open(path, flags2) {
       const client = current();
       const token = client.token;
-      const { opened: opened2, restore } = await writable2(client, path, flags2);
+      const { opened: opened2, restore } = await writable3(client, path, flags2);
       if (flags2.ifMatch !== void 0 && opened2.attr?.etag !== flags2.ifMatch) {
         await client.call("release", { fh: opened2.fh }, true);
         throw fsError2("ESTALE", `${path} changed on the host while it was being read`);
@@ -32395,7 +32421,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       return nextFh;
     },
     async read(fh, offset, size) {
-      const remote = live(fh);
+      const remote = live2(fh);
       return remote.client.read(
         remote.fh,
         offset,
@@ -32404,7 +32430,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       );
     },
     async write(fh, offset, bytes) {
-      const remote = live(fh);
+      const remote = live2(fh);
       const most = remote.client.maxIo;
       for (let at = 0; at < bytes.length; at += most) {
         await remote.client.write(remote.fh, offset + at, bytes.subarray(at, at + most));