@ai-ecoverse/slicc-kernel 1.127.0 → 1.128.0

package/dist/node.js

@@ -4062,6 +4062,12 @@ var ProtectedFs = class {
           st && marked(`${dir}/${name2}`, st)
         ]);
       },
+      ...fs.copyFile ? {
+        async copyFile(...args) {
+          await check(args[1], false);
+          return fs.copyFile?.(...args);
+        }
+      } : {},
       ...fs.createExclusive ? {
         async createExclusive(...args) {
           await check(args[0], true);
@@ -4593,7 +4599,7 @@ var OpfsFs = class {
   }
   async recounting(handle, target) {
     if (this.counted.length === 0) return;
-    const where = await this.root.resolve(handle).catch(() => null);
+    const where = await this.io(this.root.resolve(handle)).catch(() => null);
     await this.counting(where ? `/${where.join("/")}` : target);
   }
   resolvePath(base, path) {
@@ -4795,9 +4801,17 @@ var OpfsFs = class {
   }
   exact = 0;
   calls = 0;
+  others = 0;
   opfsCalls() {
     return this.calls;
   }
+  opfsOps() {
+    return this.calls + this.others;
+  }
+  io(request) {
+    this.others++;
+    return request;
+  }
   fresh() {
     this.changes++;
     this.absent.clear();
@@ -4821,7 +4835,13 @@ var OpfsFs = class {
     this.absent.set(path, performance.now());
   }
   remember(path, handle, looked = false) {
-    if (handle.kind !== "file") return handle;
+    if (handle.kind !== "file") {
+      if (looked) {
+        this.dirs.set(path, handle);
+        this.checked.set(handle, performance.now());
+      }
+      return handle;
+    }
     if (looked) {
       this.found.set(handle, performance.now());
       this.glances.delete(handle);
@@ -5202,7 +5222,7 @@ var OpfsFs = class {
   async readFileBuffer(path) {
     const bytes = await this.reading(
       path,
-      async (handle) => new Uint8Array(await (await handle.getFile()).arrayBuffer())
+      async (handle) => new Uint8Array(await (await this.io(handle.getFile())).arrayBuffer())
     );
     await this.refuseNode(path, bytes.length === 0);
     return bytes;
@@ -5210,7 +5230,7 @@ var OpfsFs = class {
   async readVersioned(path, cached = false) {
     return this.reading(path, async (handle) => {
       const stamp = await this.stamp(path, cached);
-      const file = await handle.getFile();
+      const file = await this.io(handle.getFile());
       const bytes = new Uint8Array(await file.arrayBuffer());
       await this.refuseNode(path, bytes.length === 0);
       return { bytes, version: `${file.lastModified}:${file.size}:${stamp}` };
@@ -5219,23 +5239,53 @@ var OpfsFs = class {
   async version(path, cached = false) {
     return this.reading(path, async (handle) => {
       const stamp = await this.stamp(path, cached);
-      const file = await handle.getFile();
+      const file = await this.io(handle.getFile());
       return `${file.lastModified}:${file.size}:${stamp}`;
     });
   }
   async pread(path, offset, length2) {
     return this.reading(path, async (handle) => {
-      const file = await handle.getFile();
+      const file = await this.io(handle.getFile());
       await this.refuseNode(path, file.size === 0);
       return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
     });
   }
   async pwrite(path, offset, bytes) {
-    const [handle, , target] = await this.fileFor(path);
+    const [kept, target] = await this.keptFor(path);
+    if (kept) {
+      try {
+        await this.writeAt(kept, target, path, offset, bytes);
+        return;
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+        this.files.delete(target);
+      }
+    }
+    const [handle] = await this.fileFor(path);
+    await this.writeAt(handle, target, path, offset, bytes);
+  }
+  async keptFor(path) {
+    const at = normalizePath(path);
+    const cached = this.files.get(at);
+    const fresh2 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
+    const [target, existed] = fresh2 ? [at, true] : await this.writeTarget(path);
+    if (!existed) return [void 0, target];
+    this.refuse(target);
+    const [entry] = await this.meta.get([target]);
+    if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
+    const kept = fresh2 ? cached : this.files.get(target);
+    const usable2 = kept && performance.now() - (this.found.get(kept) ?? -CHECK_MS) < CHECK_MS;
+    return [usable2 ? kept : void 0, target];
+  }
+  async writeAt(handle, target, path, offset, bytes) {
     await this.counting(target);
     this.wrote(handle);
     try {
-      await this.retrying(path, () => positioned(handle, (io) => io.write(offset, bytes)), true);
+      await this.retrying(
+        path,
+        () => this.io(positioned(handle, (io) => io.write(offset, bytes))),
+        true
+      );
     } finally {
       this.wrote(handle);
       await this.recounting(handle, target);
@@ -5244,13 +5294,13 @@ var OpfsFs = class {
   }
   async truncate(path, size) {
     const handle = await this.existing(path, true);
-    await this.refuseNode(path, (await handle.getFile()).size === 0);
+    await this.refuseNode(path, (await this.io(handle.getFile())).size === 0);
     const resolve2 = this.ranged || this.remote?.watched();
     const target = resolve2 || this.counted.length > 0 ? (await this.locate(path, true)).path : path;
     await this.counting(target);
     this.wrote(handle);
     try {
-      await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
+      await this.retrying(path, () => this.io(positioned(handle, (io) => io.truncate(size))), true);
     } finally {
       this.wrote(handle);
       await this.recounting(handle, target);
@@ -5261,7 +5311,7 @@ var OpfsFs = class {
     const [handle, , target] = await this.fileFor(path);
     const writable2 = await this.retrying(
       path,
-      () => handle.createWritable({ keepExistingData: !truncate }),
+      () => this.io(handle.createWritable({ keepExistingData: !truncate })),
       true
     );
     return {
@@ -5310,7 +5360,7 @@ var OpfsFs = class {
     try {
       const handle = await this.inDir(
         dir,
-        (parent) => parent.getFileHandle(name2, { create: true })
+        (parent) => this.io(parent.getFileHandle(name2, { create: true }))
       );
       if (!existed) this.touch(Date.now(), parentOf4(target));
       return [handle, existed, target];
@@ -5326,7 +5376,7 @@ var OpfsFs = class {
     let writable2;
     this.wrote(file);
     try {
-      writable2 = await file.createWritable();
+      writable2 = await this.io(file.createWritable());
       await writable2.write(content);
       await writable2.close();
     } catch (err) {
@@ -5342,6 +5392,7 @@ var OpfsFs = class {
     const handle = found.handle;
     if (handle.kind !== "directory") throw fsError("ENOTDIR", path);
     const children3 = /* @__PURE__ */ new Map();
+    this.others++;
     for await (const child of handle.values()) children3.set(child.name, child);
     for (const link2 of await this.meta.links(found.path)) {
       const name2 = baseOf(link2.path);
@@ -5395,7 +5446,7 @@ var OpfsFs = class {
     const parent = await this.locate(parentOf4(path), true);
     if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
     this.refuse(resolvePath(parent.path, baseOf(path)));
-    await parent.handle.getDirectoryHandle(baseOf(path), { create: true });
+    await this.io(parent.handle.getDirectoryHandle(baseOf(path), { create: true }));
     const now = Date.now();
     const made2 = `${parent.path === "/" ? "" : parent.path}/${baseOf(path)}`;
     await this.stampNew(made2, owner, true);
@@ -5416,7 +5467,7 @@ var OpfsFs = class {
       if (found !== void 0 && !found.vacated) await this.meta.remove([path]);
       this.forget(physical);
       this.refuse(physical);
-      await dir.getDirectoryHandle(name2, { create: true });
+      await this.io(dir.getDirectoryHandle(name2, { create: true }));
       const now = Date.now();
       const made2 = `${parent.path === "/" ? "" : parent.path}/${name2}`;
       await this.stampNew(made2, owner, true);
@@ -5438,9 +5489,10 @@ var OpfsFs = class {
       if (found !== void 0 && !found.vacated) await this.meta.remove([path]);
       this.forget(physical);
       this.refuse(physical);
-      await dir.getFileHandle(name2, { create: true });
+      const handle = await this.io(dir.getFileHandle(name2, { create: true }));
       const now = Date.now();
       const made2 = `${parent.path === "/" ? "" : parent.path}/${name2}`;
+      this.remember(made2, handle, true);
       await this.stampNew(made2, owner, false);
       this.touch(now, parent.path, made2);
     });
@@ -5472,7 +5524,7 @@ var OpfsFs = class {
       try {
         await this.inDir(
           dir,
-          (parent) => parent.removeEntry(name2, { recursive: options.recursive === true })
+          (parent) => this.io(parent.removeEntry(name2, { recursive: options.recursive === true }))
         );
       } catch (err) {
         throw translate(err, path);
@@ -5657,10 +5709,11 @@ var OpfsFs = class {
     return intents.length;
   }
   async settledRename(path) {
-    if (this.renamingDirs.size === 0 || typeof path !== "string") return;
+    if (this.renamingDirs.size === 0 && this.copying.size === 0 || typeof path !== "string")
+      return;
     const at = normalizePath(path);
     for (let real; ; ) {
-      const busy = this.renameAt(at) ?? (real === void 0 ? void 0 : this.renameAt(real));
+      const busy = this.busyAt(at) ?? (real === void 0 ? void 0 : this.busyAt(real));
       if (busy) {
         await busy.done;
         continue;
@@ -5671,6 +5724,62 @@ var OpfsFs = class {
       if (real === at) return;
     }
   }
+  busyAt(at) {
+    return this.renameAt(at) ?? this.copying.get(at);
+  }
+  copying = /* @__PURE__ */ new Map();
+  async copyFile(from, to, options) {
+    const source = await this.locate(from, true);
+    if (source.handle?.kind !== "file") throw fsError("EINVAL", `${from}: not a regular file`);
+    const [entry] = await this.meta.get([source.path]);
+    if (entry?.fifo || entry?.socket) throw fsError("EINVAL", `${from}: not a regular file`);
+    const parent = await this.locate(parentOf4(to), true);
+    if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", to);
+    const destination = resolvePath(parent.path, baseOf(to));
+    if (destination === source.path) throw fsError("EINVAL", `${from}: copied onto itself`);
+    const file = await this.reading(source.path, (handle) => handle.getFile());
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    while (this.copying.has(destination)) await this.copying.get(destination)?.done;
+    this.copying.set(destination, { done: promise });
+    try {
+      await this.copyInto(file, destination, to, options);
+    } finally {
+      this.copying.delete(destination);
+      resolve2();
+    }
+  }
+  async copyInto(file, destination, to, options) {
+    let created4 = false;
+    if (options.exclusive) {
+      await this.createExclusive(destination, options.owner);
+      created4 = true;
+    }
+    let target = destination;
+    let writable2;
+    let handle;
+    try {
+      const [made2, existed, at] = await this.fileFor(destination);
+      handle = made2;
+      target = at;
+      if (!existed && !created4) {
+        created4 = true;
+        await this.stampNew(target, options.owner, false);
+      }
+      const [entry] = await this.meta.get([target]);
+      if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
+      this.wrote(handle);
+      writable2 = await handle.createWritable();
+      await writable2.write(file);
+      await writable2.close();
+    } catch (err) {
+      await writable2?.abort().catch(() => void 0);
+      if (created4) await this.rm(target, { file: true }).catch(() => void 0);
+      throw translate(err, to, "commit", false);
+    } finally {
+      if (handle) this.wrote(handle);
+    }
+    this.committed(target);
+  }
   renameAt(at) {
     for (const m of this.renamingDirs) {
       if (within3(at, m.from) || within3(at, m.to) || at === parentOf4(m.from) || at === parentOf4(m.to))
@@ -5713,7 +5822,9 @@ var OpfsFs = class {
     }
   }
   async place(handle, dir, name2) {
-    const moved2 = await handle.move?.(dir, name2).then(
+    const move = handle.move;
+    if (move) this.others++;
+    const moved2 = await move?.call(handle, dir, name2).then(
       () => true,
       () => false
     );
@@ -5723,7 +5834,7 @@ var OpfsFs = class {
       await this.copy(handle, dir, name2);
     } catch (err) {
       if (handle.kind === "directory" && this.fileMoves === before) {
-        await dir.removeEntry(name2, { recursive: true });
+        await this.io(dir.removeEntry(name2, { recursive: true }));
       }
       throw translate(err, name2);
     }
@@ -5732,6 +5843,7 @@ var OpfsFs = class {
   fileMoves = 0;
   async copy(handle, dir, name2) {
     if (handle.kind === "file" && movable(handle)) {
+      this.others++;
       const moved2 = await handle.move?.(dir, name2).then(
         () => true,
         () => false
@@ -5742,12 +5854,14 @@ var OpfsFs = class {
       }
     }
     if (handle.kind === "file") {
-      const writable2 = await (await dir.getFileHandle(name2, { create: true })).createWritable();
-      await writable2.write(await handle.getFile());
+      const made2 = await this.io(dir.getFileHandle(name2, { create: true }));
+      const writable2 = await this.io(made2.createWritable());
+      await writable2.write(await this.io(handle.getFile()));
       await writable2.close();
       return;
     }
-    const target = await dir.getDirectoryHandle(name2, { create: true });
+    const target = await this.io(dir.getDirectoryHandle(name2, { create: true }));
+    this.others++;
     for await (const child of handle.values()) await this.copy(child, target, child.name);
   }
   async symlink(target, path, owner) {
@@ -5820,7 +5934,7 @@ var OpfsFs = class {
       return;
     }
     const handle = found.handle;
-    const file = handle.kind === "file" ? await handle.getFile() : void 0;
+    const file = handle.kind === "file" ? await this.io(handle.getFile()) : void 0;
     this.dirTimes.delete(found.path);
     this.fileTimes.delete(found.path);
     const ctimeMs = Date.now();
@@ -5913,6 +6027,7 @@ var READS = [
   "readVersioned"
 ];
 var WRITES = [
+  "copyFile",
   "writeFile",
   "pwrite",
   "truncate",
@@ -7277,7 +7392,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.127.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.128.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
@@ -9542,6 +9657,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     ...fs.realpath ? { realpath: fs.realpath.bind(fs) } : {},
     ...fs.chown ? { chown: fs.chown.bind(fs) } : {},
     ...fs.createExclusive ? { createExclusive: fs.createExclusive.bind(fs) } : {},
+    ...fs.copyFile ? { copyFile: fs.copyFile.bind(fs) } : {},
     ...fs.ancestry ? { ancestry: fs.ancestry.bind(fs) } : {},
     ...fs.hasOwner ? { hasOwner: fs.hasOwner.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
@@ -9943,6 +10059,12 @@ var FsWatchers = class {
     const overrides = {
       writeFile: content(fs.writeFile.bind(fs), written2),
       ...fs.createExclusive ? { createExclusive: content(fs.createExclusive.bind(fs), () => ["rename"]) } : {},
+      ...fs.copyFile ? {
+        copyFile: (from, to, options) => content(
+          (_to) => fs.copyFile?.(from, to, options),
+          written2
+        )(to)
+      } : {},
       mkdir: async (path, options) => {
         const created4 = [];
         if (options?.recursive) {
@@ -10600,6 +10722,33 @@ var FifoTable = class {
   }
 };
 
+// src/fs/copy.ts
+async function present2(fs, path) {
+  return fs.lstat(path).then(
+    () => true,
+    (err) => {
+      if (err?.code === "ENOENT") return false;
+      throw err;
+    }
+  );
+}
+async function copyByBytes(fs, from, to, options) {
+  if (!(await fs.stat(from)).isFile) throw fsError("EINVAL", `${from}: not a regular file`);
+  const bytes = await fs.readFileBuffer(from);
+  let created4 = false;
+  if (options.exclusive) {
+    if (fs.createExclusive) await fs.createExclusive(to, options.owner);
+    else if (await present2(fs, to)) throw fsError("EEXIST", to);
+    created4 = true;
+  } else created4 = !await present2(fs, to);
+  try {
+    await fs.writeFile(to, bytes, options.owner);
+  } catch (err) {
+    if (created4) await fs.rm(to, { file: true }).catch(() => void 0);
+    throw err;
+  }
+}
+
 // src/mount/protocol.ts
 var DRIVER_PROTOCOL = [1, 3];
 function driverVersionError(theirs) {
@@ -10983,12 +11132,12 @@ var MountTable = class {
   }
   list() {
     const mounted = [...this.mounts.values()].map(
-      ({ type, source, target, options, state, error, present: present3 }) => ({
+      ({ type, source, target, options, state, error, present: present4 }) => ({
         type,
         source,
         target,
         options: { ...options },
-        state: state === "ok" && present3?.() === false ? "nomedium" : state,
+        state: state === "ok" && present4?.() === false ? "nomedium" : state,
         ...error ? { error } : {}
       })
     );
@@ -11663,6 +11812,23 @@ var MountFs = class _MountFs {
       throw err;
     }
   }
+  async copyFile(from, to, options, redirects = 0) {
+    const source = await realTarget(this, normalizePath(from));
+    const a = this.at(source);
+    const b = this.at(to);
+    const copy = this.base.copyFile?.bind(this.base);
+    if (!a && !b && copy) {
+      return this.based(
+        [source, to],
+        redirects,
+        () => copy(source, to, options),
+        ([f, t], n) => this.copyFile(f, t, options, n)
+      );
+    }
+    if (a?.mount !== b?.mount) throw errnoError("EXDEV", `${from} -> ${to}`);
+    if (a) this.writable(a.mount, normalizePath(to));
+    return copyByBytes(this, source, to, options);
+  }
   async createExclusive(path, owner, redirects = 0) {
     const exclusive = this.base.createExclusive?.bind(this.base);
     if (!this.at(path) && exclusive) {
@@ -12090,6 +12256,7 @@ var SYNC_FS_OPS = [
   "rm",
   "rename",
   "link",
+  "copy",
   "unlink",
   "rmdir",
   "symlink",
@@ -12289,6 +12456,8 @@ async function run(entry, path, req) {
     case "symlink":
       await fs.symlink(req.arg2 ?? "", path, ownerFor2(entry));
       return done;
+    case "copy":
+      return copyOp(entry, path, req);
     case "mkfifo": {
       const owner = ownerFor2(entry, req.mode ?? 438) ?? { uid: 0, gid: 0 };
       await createExclusive(fs, path, { ...owner, fifo: true });
@@ -12395,6 +12564,16 @@ async function guard(g, path, req, cwd) {
       const toWalked = await walkSafe(g, to, false);
       return { path: fromWalked, arg2: toWalked };
     }
+    case "copy": {
+      const to = other();
+      await readable(g, op, path);
+      const there = !req.exclusive && await g.fs.lstat(to).then(
+        () => true,
+        () => false
+      );
+      await (there ? writable(g, op, to) : inParent(g, op, to));
+      return { path: await walkSafe(g, path, true), arg2: await walkSafe(g, to, false) };
+    }
     case "link": {
       const to = other();
       const follow2 = req.mode === 1;
@@ -12495,6 +12674,9 @@ async function mayChange(entry, path, req) {
   const { mayChange: mayChange2 } = entry.fs;
   if (!mayChange2) return;
   const { op } = req;
+  if (op === "copy") {
+    return mayChange2.call(entry.fs, entry.fs.resolvePath(entry.cwd, req.arg2 ?? ""), false);
+  }
   if (CONTENT.has(op) && req.handle === void 0) return mayChange2.call(entry.fs, path, true);
   if (!CHANGING.has(op)) return;
   const follow2 = op === "utimes" || op === "chmod" || op === "chown";
@@ -12518,6 +12700,17 @@ async function guarded(entry, path, req) {
     return { refused: refused3 };
   }
 }
+async function copyOp(entry, path, req) {
+  const { fs, cwd } = entry;
+  const to = fs.resolvePath(cwd, req.arg2 ?? "");
+  const mode = (req.mode ?? 438) & 4095 & ~(entry.umask?.() ?? 18);
+  const owner = ownerFor2(entry, mode);
+  const options = { exclusive: req.exclusive === true, ...owner ? { owner } : {} };
+  await (fs.copyFile ? fs.copyFile(path, to, options) : copyByBytes(fs, path, to, options));
+  if (!owner) await fs.chmod(to, mode);
+  entry.fresh?.(to);
+  return done;
+}
 async function createExclusive(fs, path, owner) {
   if (fs.createExclusive) return fs.createExclusive(path, owner);
   if (await fs.lstat(path).then(
@@ -12692,7 +12885,7 @@ var CREATIONS = /* @__PURE__ */ new Set([
   "create",
   "mkfifo"
 ]);
-var NAMING = /* @__PURE__ */ new Set(["link", "rename"]);
+var NAMING = /* @__PURE__ */ new Set(["link", "rename", "copy"]);
 async function newDevName(entry, path, req) {
   const named = NAMING.has(req.op);
   if (!named && !CREATIONS.has(req.op)) return void 0;
@@ -13363,6 +13556,8 @@ var SYS_TREE = {
     slicc_fs_calls: (listing) => `${listing.fsCalls ?? 0}
 `,
     slicc_opfs_calls: (listing) => `${listing.opfsCalls ?? 0}
+`,
+    slicc_opfs_ops: (listing) => `${listing.opfsOps ?? 0}
 `
   }
 };
@@ -19809,7 +20004,7 @@ var VfsNodes = class {
       if (held) throw fsError("EEXIST", path);
       const exclusive = this.fs.createExclusive;
       if (exclusive) return exclusive.call(this.fs, path, owner);
-      if (await present2(this.fs, path)) throw fsError("EEXIST", path);
+      if (await present3(this.fs, path)) throw fsError("EEXIST", path);
       await this.fs.writeFile(path, new Uint8Array(0), owner);
     });
   }
@@ -20040,7 +20235,7 @@ var VfsNodes = class {
     }
   }
 };
-async function present2(fs, path, follow2 = false) {
+async function present3(fs, path, follow2 = false) {
   const look = (follow2 ? void 0 : fs.lstat) ?? fs.stat;
   try {
     await (look ? look.call(fs, path) : fs.readFileBuffer(path));
@@ -20218,7 +20413,18 @@ function keepingOpen(fs, nodes, changed = () => {
       await nodes.onEntry(key, () => fs.link(from, to, follow2));
       await nodes.linked(at, key);
     },
-    mkdir: (path, options) => nodes.onEntry(fs.resolvePath("/", path), () => fs.mkdir(path, options))
+    mkdir: (path, options) => nodes.onEntry(fs.resolvePath("/", path), () => fs.mkdir(path, options)),
+    ...fs.copyFile ? {
+      async copyFile(from, to, options) {
+        const source = await nodes.targetKey(fs.resolvePath("/", from));
+        await nodes.flush(source);
+        await nodes.flushLinked(source);
+        const at = fs.resolvePath("/", to);
+        const key = await nodes.entryKey(at);
+        if (await heldAt(fs, nodes, at)) return copyByBytes(this, from, to, options);
+        await nodes.onEntry(key, () => fs.copyFile?.(from, to, options));
+      }
+    } : {}
   };
 }
 function vfsFile(fs, opts, nodes) {
@@ -21078,7 +21284,7 @@ var WasmProcess = class {
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
           const marks = this.options.owners || plain2 !== void 0;
-          const fresh2 = marks && !await present2(fs, path, true);
+          const fresh2 = marks && !await present3(fs, path, true);
           this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path), fs));
           await this.fds.get(fd).file.stat?.();
           if (fresh2 && plain2 !== void 0) await fs.chmod?.(path, plain2);
@@ -21097,7 +21303,7 @@ var WasmProcess = class {
           { at: path, gen }
         );
       }
-      if (req.existing && !await present2(fs, path, true)) {
+      if (req.existing && !await present3(fs, path, true)) {
         throw new KernelError("ENOENT");
       }
     } catch (err) {
@@ -21465,12 +21671,12 @@ var WasmProcess = class {
   async stillOpen(at, handle) {
     if (handle === void 0 || this.keptHandle?.(handle) !== void 0) return;
     if (this.holdsHandle?.(handle) !== false) return;
-    if (!await present2(this.options.fs, at, true)) throw new KernelError("ENOENT");
+    if (!await present3(this.options.fs, at, true)) throw new KernelError("ENOENT");
   }
   async keptOr(path, handle) {
     if (handle !== void 0) return this.keptHandle?.(handle) ?? path;
     const kept = this.keptPath?.(path);
-    return kept !== void 0 && !await present2(this.options.fs, path, true) ? kept : path;
+    return kept !== void 0 && !await present3(this.options.fs, path, true) ? kept : path;
   }
   async promote(req) {
     if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
@@ -26955,7 +27161,8 @@ var Launcher = class {
         wasm: this.memories.count(),
         peers: Number(this.locks.shared?.() === true),
         fsCalls: servedFsCalls(),
-        opfsCalls: this.rootFs.opfsCalls?.() ?? 0
+        opfsCalls: this.rootFs.opfsCalls?.() ?? 0,
+        opfsOps: this.rootFs.opfsOps?.() ?? 0
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),