@ai-ecoverse/slicc-kernel 1.34.1 → 1.36.0

package/dist/node.js

@@ -1938,11 +1938,41 @@ var OpfsFs = class {
     const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
     return (directory ? S_IFDIR : S_IFREG) | (meta?.mode ?? fallback);
   }
+  dirTimes = /* @__PURE__ */ new Map();
+  dirDirty = /* @__PURE__ */ new Set();
+  dirFlush;
+  touch(...dirs) {
+    const now = Date.now();
+    for (const dir of dirs) {
+      this.dirTimes.set(dir, now);
+      this.dirDirty.add(dir);
+    }
+    this.dirFlush ??= Promise.resolve().then(() => this.flushDirTimes()).catch(() => void 0).finally(() => {
+      this.dirFlush = void 0;
+    });
+  }
+  async flushDirTimes() {
+    for (const path of this.dirDirty) {
+      this.dirDirty.delete(path);
+      const ms = this.dirTimes.get(path);
+      if (ms === void 0) continue;
+      await this.meta.update(path, (entry) => ({
+        ...entry,
+        path,
+        mtimeMs: ms,
+        mtimeFor: 0,
+        ctimeMs: ms
+      }));
+      if (this.dirTimes.get(path) === ms) this.dirTimes.delete(path);
+    }
+  }
   async statOf(path, handle, meta) {
     const directory = handle.kind === "directory";
     const file = directory ? void 0 : await handle.getFile();
     const modified = file?.lastModified ?? 0;
-    const mtime = meta?.mtimeMs !== void 0 && meta.mtimeFor === modified ? meta.mtimeMs : modified;
+    const touched = directory ? this.dirTimes.get(path) : void 0;
+    const kept = meta?.mtimeMs !== void 0 && meta.mtimeFor === modified ? meta.mtimeMs : modified;
+    const mtime = touched ?? kept;
     return {
       isFile: !directory,
       isDirectory: directory,
@@ -1951,7 +1981,7 @@ var OpfsFs = class {
       mode: this.mode(path, directory, meta),
       mtime: new Date(mtime),
       atime: new Date(meta?.atimeMs ?? mtime),
-      ctime: new Date(Math.max(meta?.ctimeMs ?? mtime, modified)),
+      ctime: new Date(Math.max(touched ?? meta?.ctimeMs ?? mtime, modified)),
       ino: meta?.ino ?? inodeOf(path),
       ...this.ranged && !directory ? { ranged: true } : {}
     };
@@ -2028,6 +2058,19 @@ var OpfsFs = class {
     const handle = await this.existing(path);
     await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
   }
+  async writeSession(path, truncate) {
+    const handle = (await this.fileFor(path))[0];
+    const writable = await this.retrying(
+      path,
+      () => handle.createWritable({ keepExistingData: !truncate }),
+      true
+    );
+    return {
+      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }),
+      truncate: (size) => writable.truncate(size),
+      close: () => writable.close()
+    };
+  }
   async readFile(path) {
     return new TextDecoder().decode(await this.readFileBuffer(path));
   }
@@ -2045,10 +2088,12 @@ var OpfsFs = class {
     const [target, existed] = await this.writeTarget(path);
     const [dir, name2] = await this.parent(target);
     try {
-      return [
-        await this.inDir(dir, (parent) => parent.getFileHandle(name2, { create: true })),
-        existed
-      ];
+      const handle = await this.inDir(
+        dir,
+        (parent) => parent.getFileHandle(name2, { create: true })
+      );
+      if (!existed) this.touch(parentOf2(target));
+      return [handle, existed];
     } catch (err) {
       const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
       throw code ? fsError(code, path) : translate(err, path);
@@ -2106,6 +2151,7 @@ var OpfsFs = class {
     const parent = await this.locate(parentOf2(path), true);
     if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
     await parent.handle.getDirectoryHandle(baseOf(path), { create: true });
+    this.touch(parent.path);
   }
   async rm(path, options = {}) {
     let found;
@@ -2129,6 +2175,7 @@ var OpfsFs = class {
       this.changed(found.path);
     }
     await this.meta.remove([found.path]);
+    this.touch(parentOf2(found.path));
   }
   async rename(from, to) {
     if (from === to) return;
@@ -2160,6 +2207,7 @@ var OpfsFs = class {
     if (source.link) {
       if (target?.handle) await this.rm(destination);
       await this.meta.move(source.path, destination, carry);
+      this.touch(parentOf2(source.path), parent.path);
       return;
     }
     const dir = parent.handle;
@@ -2181,6 +2229,7 @@ var OpfsFs = class {
     }
     if (copied) await this.restamp(destination, timed);
     this.changed(source.path, destination);
+    this.touch(parentOf2(source.path), parent.path);
   }
   async modified(path) {
     const handle = await this.handle(path);
@@ -2244,6 +2293,10 @@ var OpfsFs = class {
       mtimeMs: now,
       ctimeMs: now
     }));
+    this.touch(parent.path);
+  }
+  async realpath(path, follow) {
+    return (await this.locate(path, follow)).path;
   }
   async readlink(path) {
     const found = await this.locate(path, false);
@@ -2281,6 +2334,7 @@ var OpfsFs = class {
     }
     const handle = found.handle;
     const file = handle.kind === "file" ? await handle.getFile() : void 0;
+    this.dirTimes.delete(found.path);
     const ctimeMs = Date.now();
     await this.meta.update(found.path, (entry) => ({
       ...entry,
@@ -3303,6 +3357,7 @@ function withCommandDirs(fs, names) {
     rename: (from, to) => fs.rename(from, to),
     symlink: (target, path) => fs.symlink(target, path),
     readlink: (path) => fs.readlink(path),
+    ...fs.realpath ? { realpath: fs.realpath.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
     utimes: (path, atime, mtime) => fs.utimes(path, atime, mtime),
     lutimes: (path, atime, mtime) => lutimesOf(fs, path, atime, mtime),
@@ -3699,18 +3754,36 @@ function parseSize(text) {
   return Math.floor(Number(match[1]) * UNITS[match[2].toLowerCase()]);
 }
 var within2 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var HeldSet = class extends Set {
+  idle;
+  constructor(idle) {
+    super();
+    this.idle = idle;
+  }
+  add(holds) {
+    holds.onIdle = this.idle;
+    return super.add(holds);
+  }
+  delete(holds) {
+    const removed = super.delete(holds);
+    for (const path of holds.keys()) this.idle(path);
+    return removed;
+  }
+};
 function heldUnder(held, target) {
   for (const paths of held) for (const path of paths.keys()) if (within2(path, target)) return true;
   return false;
 }
 var HeldPaths = class extends Map {
   revoked = /* @__PURE__ */ new Set();
+  onIdle;
   hold(path, on) {
     const count = (this.get(path) ?? 0) + (on ? 1 : -1);
     if (count > 0) this.set(path, count);
     else {
       this.delete(path);
       this.revoked.delete(path);
+      this.onIdle?.(path);
     }
   }
   revoke(prefix) {
@@ -3778,6 +3851,8 @@ function spliced(bytes, offset, part) {
 }
 var MountTable = class {
   mounts = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  committing = /* @__PURE__ */ new Map();
   devices = 0;
   pending = /* @__PURE__ */ new Set();
   notes = /* @__PURE__ */ new Map();
@@ -3902,8 +3977,69 @@ var MountTable = class {
     if (!detach && this.deps.busy(at)) throw errnoError("EBUSY", `${at} has open files`);
     this.notes.delete(at);
     this.mounts.delete(at);
-    mount.conn.close();
-    mount.dispose();
+    const waits = [...this.sessions].filter(([, s]) => s.mount === mount).map(([real]) => this.commit(real));
+    for (const c of this.committing.values()) if (c.mount === mount) waits.push(c.done);
+    const close = () => {
+      mount.conn.close();
+      mount.dispose();
+    };
+    if (waits.length === 0) close();
+    else void Promise.allSettled(waits).then(close);
+  }
+  session(mount, real, rel2) {
+    let session = this.sessions.get(real);
+    if (!session) {
+      const open = () => mount.conn.call({
+        op: "open",
+        path: rel2,
+        write: true,
+        create: true,
+        truncate: false,
+        exclusive: false
+      });
+      const before = this.committing.get(real)?.done ?? Promise.resolve();
+      const fh = before.then(open, open);
+      session = { mount, fh, extents: [], truncated: false };
+      this.sessions.set(real, session);
+      fh.catch(() => this.sessions.delete(real));
+    }
+    return session;
+  }
+  writing(real) {
+    return this.sessions.get(real);
+  }
+  async commit(real) {
+    const session = this.sessions.get(real);
+    if (!session) return this.committing.get(real)?.done;
+    this.sessions.delete(real);
+    const done4 = (async () => {
+      try {
+        await session.mount.conn.call({ op: "release", fh: await session.fh });
+      } finally {
+        this.forget(session.mount, real);
+      }
+    })();
+    const entry = { mount: session.mount, done: done4 };
+    this.committing.set(real, entry);
+    const settle = () => {
+      if (this.committing.get(real) === entry) this.committing.delete(real);
+    };
+    done4.then(settle, settle);
+    return done4;
+  }
+  async commitUnder(prefix) {
+    const at = normalizePath(prefix);
+    await Promise.all(
+      [...this.sessions.keys()].filter((p) => within2(p, at)).map((p) => this.commit(p))
+    );
+  }
+  async commitOverlapping(real, offset, length2) {
+    const session = this.sessions.get(real);
+    if (!session) return;
+    const end = offset + length2;
+    if (session.truncated || session.extents.some(([a, b]) => a < end && offset < b)) {
+      await this.commit(real);
+    }
   }
   crashed(mount, error) {
     mount.state = "failed";
@@ -3962,6 +4098,13 @@ var MountTable = class {
     return new MountFs(this, base);
   }
 };
+function noteExtent(extents, from, to) {
+  const last = extents.at(-1);
+  if (last && from <= last[1] && to >= last[0]) {
+    last[0] = Math.min(last[0], from);
+    last[1] = Math.max(last[1], to);
+  } else extents.push([from, to]);
+}
 var MountFs = class {
   table;
   base;
@@ -4021,6 +4164,7 @@ var MountFs = class {
     }
   }
   async readWhole(mount, real, rel2) {
+    await this.table.commit(real);
     const attr = await this.table.getattr(mount, real, rel2);
     if (attr.kind === "directory") throw errnoError("EISDIR", real);
     if (mount.maxFile > 0 && attr.size > mount.maxFile) {
@@ -4070,6 +4214,7 @@ var MountFs = class {
     }
   }
   async writeWhole(mount, real, rel2, bytes) {
+    await this.table.commit(real);
     this.table.forget(mount, real);
     const fh = await this.open(mount, rel2, true);
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
@@ -4092,6 +4237,7 @@ var MountFs = class {
     if ((await this.table.getattr(mount, real, rel2)).kind === "directory") {
       throw errnoError("EISDIR", real);
     }
+    await this.table.commitOverlapping(real, offset, length2);
     const fh = await mount.conn.call({
       op: "open",
       path: rel2,
@@ -4145,6 +4291,14 @@ var MountFs = class {
     this.writable(mount, real);
     this.fits(mount, real, offset + bytes.length);
     this.table.forget(mount, real);
+    if (mount.caps.sessions) {
+      const session = this.table.session(mount, real, rel2);
+      const end = offset + bytes.length;
+      await this.writeRuns(mount, await session.fh, offset, bytes, transfer);
+      noteExtent(session.extents, offset, end);
+      this.table.forget(mount, real);
+      return;
+    }
     const fh = await mount.conn.call({
       op: "open",
       path: rel2,
@@ -4153,17 +4307,20 @@ var MountFs = class {
       truncate: false,
       exclusive: false
     });
-    const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     try {
-      for (let at = 0; at < bytes.length; at += chunk2) {
-        const part = handed(bytes, transfer, chunk2) ? bytes : bytes.slice(at, at + chunk2);
-        await mount.conn.call({ op: "write", fh, offset: offset + at, bytes: part }, [part.buffer]);
-      }
+      await this.writeRuns(mount, fh, offset, bytes, transfer);
     } finally {
       await mount.conn.call({ op: "release", fh });
       this.table.forget(mount, real);
     }
   }
+  async writeRuns(mount, fh, offset, bytes, transfer) {
+    const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
+    for (let at = 0; at < bytes.length; at += chunk2) {
+      const part = handed(bytes, transfer, chunk2) ? bytes : bytes.slice(at, at + chunk2);
+      await mount.conn.call({ op: "write", fh, offset: offset + at, bytes: part }, [part.buffer]);
+    }
+  }
   async truncate(path, size) {
     const real = await this.follow(path);
     const found = this.at(real);
@@ -4175,6 +4332,8 @@ var MountFs = class {
     this.writable(mount, real);
     this.fits(mount, real, size);
     this.table.forget(mount, real);
+    const session = this.table.writing(real);
+    if (session) session.truncated = true;
     try {
       await mount.conn.call({ op: "setattr", path: rel2, size });
     } finally {
@@ -4196,7 +4355,16 @@ var MountFs = class {
     const found = this.at(path);
     if (!found) return this.base.lstat(path);
     const real = normalizePath(path);
-    return statOf(await this.table.getattr(found.mount, real, found.rel), real, found.mount);
+    if (this.table.writing(real)?.truncated) await this.table.commit(real);
+    return this.statWriting(
+      await this.table.getattr(found.mount, real, found.rel),
+      real,
+      found.mount
+    );
+  }
+  statWriting(attr, real, mount) {
+    const ends = (this.table.writing(real)?.extents ?? []).map(([, end]) => end);
+    return statOf({ ...attr, size: Math.max(attr.size, ...ends) }, real, mount);
   }
   async stat(path) {
     const real = await this.follow(path);
@@ -4223,7 +4391,7 @@ var MountFs = class {
       list.map(async (entry) => {
         const child = normalizePath(`${real}/${entry.name}`);
         if (entry.attr && mount.caps.listingStats) {
-          return [entry.name, statOf(entry.attr, child, mount)];
+          return [entry.name, this.statWriting(entry.attr, child, mount)];
         }
         return [entry.name, await this.lstat(child).catch(() => null)];
       })
@@ -4259,6 +4427,7 @@ var MountFs = class {
     const real = normalizePath(path);
     if (rel2 === "/") throw errnoError("EBUSY", `${real} is a mount point`);
     this.writable(mount, real);
+    await this.table.commitUnder(real);
     let attr;
     try {
       attr = await this.table.getattr(mount, real, rel2);
@@ -4282,6 +4451,8 @@ var MountFs = class {
     if (!a && !b) return this.base.rename(from, to);
     if (!a || !b || a.mount !== b.mount) throw errnoError("EXDEV", `${from} -> ${to}`);
     this.writable(a.mount, normalizePath(to));
+    await this.table.commitUnder(from);
+    await this.table.commitUnder(to);
     this.table.forget(a.mount, normalizePath(from));
     this.table.forget(a.mount, normalizePath(to));
     try {
@@ -4300,6 +4471,12 @@ var MountFs = class {
     this.table.forget(found.mount, normalizePath(path));
     await found.mount.conn.call({ op: "symlink", target, path: found.rel });
   }
+  async realpath(path, follow) {
+    if (this.at(path) || !this.base.realpath) throw errnoError("ENOSYS", path);
+    const real = await this.base.realpath(path, follow);
+    if (this.at(real)) throw errnoError("ENOSYS", path);
+    return real;
+  }
   async readlink(path) {
     const found = this.at(path);
     if (!found) return this.base.readlink(path);
@@ -7084,6 +7261,7 @@ var VfsNode = class {
   writeBack;
   writeBackCost = 0;
   opens = 0;
+  writers = 0;
   missing = false;
   revoked = false;
   fs;
@@ -7259,8 +7437,10 @@ var VfsNodes = class {
   byPath = /* @__PURE__ */ new Map();
   fs;
   entries = /* @__PURE__ */ new Map();
-  constructor(fs) {
+  onClosed;
+  constructor(fs, onClosed) {
     this.fs = fs;
+    this.onClosed = onClosed;
   }
   async onEntry(path, op) {
     const key = await this.entryKey(path);
@@ -7274,9 +7454,21 @@ var VfsNodes = class {
   }
   async entryKey(path) {
     const parent = parentOf5(path);
-    const dir = await realDir(this.fs, parent).catch(() => parent);
-    const name2 = path.slice(path.lastIndexOf("/") + 1);
-    return dir === "/" ? `/${name2}` : `${dir}/${name2}`;
+    const dir = await this.real(parent, true, () => realDir(this.fs, parent));
+    return joinName(dir, path.slice(path.lastIndexOf("/") + 1));
+  }
+  targetKey(path) {
+    return this.real(path, true, () => realTarget(this.fs, path));
+  }
+  async real(path, follow, walk) {
+    if (this.fs.realpath) {
+      try {
+        return await this.fs.realpath(path, follow);
+      } catch (err) {
+        if (errCode(err) === "ELOOP") throw err;
+      }
+    }
+    return walk();
   }
   createExclusive(path) {
     return this.onEntry(path, async () => {
@@ -7286,16 +7478,17 @@ var VfsNodes = class {
       await this.fs.writeFile(path, new Uint8Array(0));
     });
   }
-  open(path, pin) {
+  open(path, pin, writable = false) {
     let node = this.byPath.get(path);
     if (!node) {
       node = new VfsNode(this.fs, path, void 0, false, false, pin);
       this.byPath.set(path, node);
     }
     node.opens++;
+    if (writable) node.writers++;
     return node;
   }
-  adopt(path, contents2, dirty) {
+  adopt(path, contents2, dirty, writable = false) {
     let node = this.byPath.get(path);
     if (!node) {
       node = new VfsNode(this.fs, path, contents2, false, dirty);
@@ -7304,15 +7497,27 @@ var VfsNodes = class {
       node.replace(contents2);
     }
     node.opens++;
+    if (writable) node.writers++;
     return node;
   }
   holds(prefix) {
     for (const path of this.byPath.keys()) if (within4(path, prefix)) return true;
     return false;
   }
-  closed(node) {
+  writes(prefix) {
+    for (const [path, node] of this.byPath)
+      if (node.writers > 0 && within4(path, prefix)) return true;
+    return false;
+  }
+  closed(node, writable = false) {
     node.opens--;
-    if (node.opens === 0 && this.byPath.get(node.path) === node) this.byPath.delete(node.path);
+    if (writable) node.writers--;
+    if (node.opens > 0) {
+      if (writable && node.writers === 0) this.onClosed?.(node.path);
+      return;
+    }
+    if (this.byPath.get(node.path) === node) this.byPath.delete(node.path);
+    this.onClosed?.(node.path);
   }
   async flush(path) {
     for (const [p, node] of this.byPath) if (within4(p, path)) await node.serial(() => node.flush());
@@ -7371,10 +7576,9 @@ function parentOf5(path) {
 async function linkOf(fs, path) {
   return fs.readlink?.(path).catch(() => void 0);
 }
-async function realDir(fs, dir) {
+async function realDir(fs, dir, budget = { hops: 0 }) {
   const queue = dir.split("/").filter(Boolean);
   let at = "/";
-  let hops = 0;
   while (queue.length > 0) {
     const part = queue.shift();
     if (part === ".") continue;
@@ -7383,28 +7587,41 @@ async function realDir(fs, dir) {
       continue;
     }
     const next = at === "/" ? `/${part}` : `${at}/${part}`;
-    const link2 = hops < MAX_LINKS5 ? await linkOf(fs, next) : void 0;
+    const link2 = await linkOf(fs, next);
     if (link2 === void 0) {
       at = next;
       continue;
     }
-    hops++;
+    if (budget.hops >= MAX_LINKS5) throw fsError("ELOOP", dir);
+    budget.hops++;
     queue.unshift(...link2.split("/").filter(Boolean));
     if (link2.startsWith("/")) at = "/";
   }
   return at;
 }
-async function targetDir(fs, path) {
-  let dir = await realDir(fs, parentOf5(path));
+function errCode(err) {
+  return err?.code;
+}
+function joinName(dir, name2) {
+  return dir === "/" ? `/${name2}` : `${dir}/${name2}`;
+}
+async function realTarget(fs, path) {
+  const budget = { hops: 0 };
+  let dir = await realDir(fs, parentOf5(path), budget);
   let name2 = path.slice(path.lastIndexOf("/") + 1);
-  for (let hops = 0; hops < MAX_LINKS5; hops++) {
-    const link2 = await linkOf(fs, dir === "/" ? `/${name2}` : `${dir}/${name2}`);
-    if (link2 === void 0) return dir;
-    const target = link2.startsWith("/") ? link2 : `${dir}/${link2}`;
-    dir = await realDir(fs, parentOf5(target));
+  for (; ; ) {
+    const link2 = await linkOf(fs, joinName(dir, name2));
+    if (link2 === void 0) break;
+    if (budget.hops >= MAX_LINKS5) throw fsError("ELOOP", path);
+    budget.hops++;
+    const target = link2.startsWith("/") ? link2 : joinName(dir, link2);
+    dir = await realDir(fs, parentOf5(target), budget);
     name2 = target.slice(target.lastIndexOf("/") + 1);
   }
-  return dir;
+  return joinName(dir, name2);
+}
+async function targetDir(fs, path) {
+  return parentOf5(await realTarget(fs, path).catch(() => path));
 }
 async function refuseReadonly(fs, path, flags, opts = {}) {
   const writes = (flags & O_ACCMODE) !== 0 || opts.truncate === true;
@@ -7423,13 +7640,14 @@ function keepingOpen(fs, nodes) {
   return {
     ...fs,
     async rm(path, options) {
-      const at = fs.resolvePath("/", path);
+      const at = await nodes.entryKey(fs.resolvePath("/", path));
       await nodes.unlinking(at);
       await fs.rm(path, options);
       nodes.unlinked(at);
     },
-    rename(from, to) {
-      const [a, b] = [fs.resolvePath("/", from), fs.resolvePath("/", to)];
+    async rename(from, to) {
+      const a = await nodes.entryKey(fs.resolvePath("/", from));
+      const b = await nodes.entryKey(fs.resolvePath("/", to));
       return nodes.onEntry(b, async () => {
         await nodes.unlinking(b);
         await fs.rename(from, to);
@@ -7445,7 +7663,7 @@ function vfsFile(fs, opts, nodes) {
   const access = opts.flags & O_ACCMODE;
   const readable = access !== O_WRONLY;
   const writable = access === O_WRONLY || access === 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) : nodes.open(opts.path, opts.pin);
+  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, writable) : nodes.open(opts.path, opts.pin, writable);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -7508,7 +7726,7 @@ function vfsFile(fs, opts, nodes) {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node);
+        nodes?.closed(node, writable);
       }
     })
   });
@@ -7575,10 +7793,12 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-cloexec",
   "fd-list",
   "proc-alarm",
+  "proc-umask",
   "dl-log",
   "fd-renumber",
   "fd-promote",
   "fd-open-tty",
+  "fd-tty-names",
   "tty-get",
   "tty-set",
   "tty-winsz",
@@ -7612,6 +7832,7 @@ function isWasmSyscall(req) {
   return typeof op === "string" && SYSCALL_OPS.has(op);
 }
 var MAX_READ = 1024 * 1024;
+var DEFAULT_UMASK = 18;
 var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
@@ -7622,6 +7843,7 @@ var WasmProcess = class {
   inherited = 0;
   interrupt = new AbortController();
   dying = false;
+  umask = DEFAULT_UMASK;
   execChild;
   execTermsig;
   stopped = 0;
@@ -7639,6 +7861,7 @@ var WasmProcess = class {
     this.fds = fds;
     this.options = options;
     this.inherited = options.ignored ?? 0;
+    this.umask = options.umask ?? DEFAULT_UMASK;
     this.children = new ChildTable(fds, options.spawner, options.forker);
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
     if (!options.nodes) options.openFiles?.add(this.nodes);
@@ -7711,6 +7934,11 @@ var WasmProcess = class {
       return result;
     }
   }
+  setUmask(mask) {
+    const old = this.umask;
+    if (mask !== void 0) this.umask = mask & 511;
+    return old;
+  }
   die() {
     if (this.dying) return;
     this.dying = true;
@@ -7781,9 +8009,21 @@ var WasmProcess = class {
     await refuseReadonly(this.options.fs, req.path, req.flags, req);
     const fd = this.fds.install(heldFile(), 3);
     try {
-      if (req.exclusive) await this.nodes.createExclusive(req.path);
-      this.fds.installAt(fd, this.openVfsFile(req));
-      if (req.existing && !await present(this.options.fs, req.path, true)) {
+      const nodes = this.nodes;
+      const path = req.orphan ? req.path : req.exclusive ? await nodes.entryKey(req.path) : await nodes.targetKey(req.path);
+      const open = { ...req, path };
+      if (req.exclusive) {
+        await nodes.createExclusive(path);
+        this.fds.installAt(fd, this.openVfsFile(open));
+      } else if (req.create) {
+        await nodes.onEntry(path, async () => {
+          this.fds.installAt(fd, this.openVfsFile(open));
+          await this.fds.get(fd).file.stat?.();
+        });
+      } else {
+        this.fds.installAt(fd, this.openVfsFile(open));
+      }
+      if (req.existing && !await present(this.options.fs, path, true)) {
         throw new KernelError("ENOENT");
       }
     } catch (err) {
@@ -7862,7 +8102,7 @@ var WasmProcess = class {
       case "fd-reserve":
         return { ok: true, kind: "json", json: this.reserve(req.fd, req.min, req.meta) };
       case "fd-promote":
-        this.promote(req);
+        await this.promote(req);
         return { ok: true, kind: "void" };
       case "fd-renumber":
         if (req.from !== req.to) {
@@ -7875,6 +8115,8 @@ var WasmProcess = class {
         if (!tty) throw new KernelError("ENXIO");
         return { ok: true, kind: "json", json: this.fds.install(tty.file(), 3) };
       }
+      case "fd-tty-names":
+        return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
         const signal = this.blockingSignal();
@@ -7896,10 +8138,14 @@ var WasmProcess = class {
   async vfsSyscall(req) {
     if ("path" in req || "from" in req) {
       const nodes = this.nodes;
-      if (req.op === "fd-path-flush") await nodes.flush(req.path);
-      else if (req.op === "fd-path-unlinking") await nodes.unlinking(req.path);
-      else if (req.op === "fd-path-unlinked") nodes.unlinked(req.path);
-      else if (req.op === "fd-path-renamed") nodes.renamed(req.from, req.to);
+      if (req.op === "fd-path-flush") {
+        await nodes.flush(await nodes.targetKey(req.path).catch(() => req.path));
+      } else if (req.op === "fd-path-unlinking")
+        await nodes.unlinking(await nodes.entryKey(req.path));
+      else if (req.op === "fd-path-unlinked") nodes.unlinked(await nodes.entryKey(req.path));
+      else if (req.op === "fd-path-renamed") {
+        nodes.renamed(await nodes.entryKey(req.from), await nodes.entryKey(req.to));
+      }
       return { ok: true, kind: "void" };
     }
     const file = this.fds.get(req.fd).file;
@@ -7920,17 +8166,19 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: await file.stat() };
     }
   }
-  promote(req) {
+  async promote(req) {
     if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
     if (req.share !== void 0) {
       this.fds.dup2(req.share, req.fd);
       return;
     }
     if (req.path === void 0) throw new KernelError("EINVAL");
+    const path = req.orphan ? req.path : await this.nodes.targetKey(req.path);
+    if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
     const file = vfsFile(
       this.options.fs,
       {
-        path: req.path,
+        path,
         flags: req.flags ?? 0,
         position: req.position ?? 0,
         ...req.contents !== void 0 ? { contents: req.contents } : {},
@@ -8106,6 +8354,8 @@ var WasmProcess = class {
       case "proc-alarm":
         this.setAlarm(req.sig, req.firstMs ?? req.ms, req.repeat ? req.ms : 0, req.timer);
         return { ok: true, kind: "void" };
+      case "proc-umask":
+        return { ok: true, kind: "json", json: this.setUmask(req.mask) };
       case "dl-log":
         if (req.append) this.dlLog.push(req.append);
         return { ok: true, kind: "json", json: this.dlLog.slice(req.from) };
@@ -8255,7 +8505,7 @@ var Dying = class {
     return [typeof reported === "number" ? reported : CRASHED, void 0];
   }
 };
-function processInit(opts, sab) {
+function processInit(opts, sab, umask) {
   const base = {
     type: WASM_PROCESS_INIT,
     pid: opts.shownPid ?? opts.pid,
@@ -8264,6 +8514,7 @@ function processInit(opts, sab) {
     env: opts.env,
     cwd: opts.cwd,
     sab,
+    umask,
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
   };
   if (opts.program.abi === "js") {
@@ -8275,11 +8526,17 @@ function processInit(opts, sab) {
     ...opts.fork ? { fork: opts.fork } : { fds: inheritedFds(opts.fds) }
   };
 }
+function inherited(opts) {
+  return {
+    ...opts.ignored ? { ignored: opts.ignored } : {},
+    ...opts.umask !== void 0 ? { umask: opts.umask } : {}
+  };
+}
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const process = new WasmProcess(opts.pid, opts.fds, {
-    ...opts.ignored ? { ignored: opts.ignored } : {},
+    ...inherited(opts),
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     spawner: opts.spawner,
@@ -8413,7 +8670,7 @@ function spawnWasmProcess(opts) {
     };
     tw.postMessage(tinit);
   };
-  const init = processInit(opts, sab);
+  const init = processInit(opts, sab, process.umask);
   worker.postMessage(init, opts.fork ? [opts.fork.memory.buffer] : []);
   const signal = (sig) => {
     if (process.signal(sig) !== "terminate") return;
@@ -8431,6 +8688,7 @@ function spawnWasmProcess(opts) {
     onState: (listener) => process.onState(listener),
     memory: () => Atomics.load(header3, SAB_I_MEMORY) * 65536,
     ignoredSignals: (fork) => process.inheritable(fork),
+    umask: () => process.umask,
     writesBack: () => opts.program.abi === "wasi" && !done4
   };
 }
@@ -8536,8 +8794,13 @@ var JobTable = class {
     return id;
   }
   terminalNamed(name2) {
-    const known = /* @__PURE__ */ new Set([...this.terminals.values(), ...this.foreground.keys()]);
-    return [...known].find((tty) => tty.name === name2);
+    return this.knownTerminals().find((tty) => tty.name === name2);
+  }
+  terminalNames() {
+    return this.knownTerminals().flatMap((tty) => tty.name ? [tty.name] : []);
+  }
+  knownTerminals() {
+    return [.../* @__PURE__ */ new Set([...this.terminals.values(), ...this.foreground.keys()])];
   }
   controllingTerminal(pid) {
     const member = this.members.get(pid);
@@ -8810,7 +9073,11 @@ function mediumSlot(lost, onLost) {
 }
 
 // src/mount/fsa.ts
-var FSA_CAPABILITIES = { listingStats: true };
+var FSA_CAPABILITIES = {
+  listingStats: true,
+  ranges: true,
+  sessions: true
+};
 var codeOf2 = (err) => err?.code;
 var denied = (err) => codeOf2(err) === "EACCES" || err?.name === "NotAllowedError";
 function attrOf(st) {
@@ -8850,30 +9117,20 @@ function kernelFsHandlers(fs) {
       if (st && flags.exclusive) throw fsError2("EEXIST", path);
       if (st?.isDirectory && flags.write) throw fsError2("EISDIR", path);
       if (!st && !flags.create) throw fsError2("ENOENT", path);
-      const data = st && !flags.truncate ? await fs.readFileBuffer(path) : new Uint8Array(0);
-      handles.set(++nextFh, { path, data, length: data.length, dirty: !st || flags.truncate });
+      if (!st || flags.truncate) await fs.writeFile(path, new Uint8Array(0));
+      handles.set(++nextFh, { path });
       return nextFh;
     },
-    async read(fh, offset, size) {
-      const h = handle(fh);
-      return h.data.slice(offset, Math.min(h.length, offset + size));
-    },
+    read: async (fh, offset, size) => fs.pread(handle(fh).path, offset, size),
     async write(fh, offset, bytes) {
       const h = handle(fh);
-      const end = offset + bytes.length;
-      if (end > h.data.length) {
-        const grown = new Uint8Array(Math.max(end, h.data.length * 2));
-        grown.set(h.data.subarray(0, h.length));
-        h.data = grown;
-      }
-      h.data.set(bytes, offset);
-      h.length = Math.max(h.length, end);
-      h.dirty = true;
+      h.session ??= fs.writeSession(h.path, false);
+      await (await h.session).write(offset, bytes);
     },
     async release(fh) {
       const h = handle(fh);
       handles.delete(fh);
-      if (h.dirty) await fs.writeFile(h.path, h.data.slice(0, h.length));
+      if (h.session !== void 0) await (await h.session).close();
     },
     mkdir: (path) => fs.mkdir(path),
     async rmdir(path) {
@@ -8889,6 +9146,13 @@ function kernelFsHandlers(fs) {
     symlink: (target, path) => fs.symlink(target, path),
     readlink: (path) => fs.readlink(path),
     async setattr(path, change) {
+      if (change.size !== void 0) {
+        const open = [...handles.values()].find(
+          (h) => h.path === path && h.session !== void 0
+        )?.session;
+        if (open !== void 0) await (await open).truncate(change.size);
+        else await fs.truncate?.(path, change.size);
+      }
       if (change.mode !== void 0) await fs.chmod(path, change.mode);
       if (change.mtime !== void 0) {
         await fs.utimes(path, new Date(change.mtime), new Date(change.mtime));
@@ -9613,6 +9877,7 @@ function tmpfs() {
       const { dir, name: name2 } = parent(path);
       if (dir.children.has(name2)) throw fsError2("EEXIST", path);
       dir.children.set(name2, make("directory", 16877));
+      dir.mtime = Date.now();
     },
     async rmdir(path) {
       const { dir, name: name2 } = parent(path);
@@ -9621,6 +9886,7 @@ function tmpfs() {
       if (node.kind !== "directory") throw fsError2("ENOTDIR", path);
       if (node.children.size > 0) throw fsError2("ENOTEMPTY", path);
       dir.children.delete(name2);
+      dir.mtime = Date.now();
     },
     async unlink(path) {
       const { dir, name: name2 } = parent(path);
@@ -9628,6 +9894,7 @@ function tmpfs() {
       if (!node) throw fsError2("ENOENT", path);
       if (node.kind === "directory") throw fsError2("EISDIR", path);
       dir.children.delete(name2);
+      dir.mtime = Date.now();
     },
     async rename(from, to) {
       const a = `/${parts(from).join("/")}`;
@@ -9644,6 +9911,8 @@ function tmpfs() {
       }
       source.dir.children.delete(source.name);
       target.dir.children.set(target.name, node);
+      source.dir.mtime = Date.now();
+      target.dir.mtime = source.dir.mtime;
     },
     async symlink(target, path) {
       const { dir, name: name2 } = parent(path);
@@ -9651,6 +9920,7 @@ function tmpfs() {
       const node = make("symlink", 41471);
       node.target = target;
       dir.children.set(name2, node);
+      dir.mtime = Date.now();
     },
     async readlink(path) {
       const node = find(path);
@@ -9949,7 +10219,7 @@ var Launcher = class {
   deciding = /* @__PURE__ */ new Map();
   identities = { asked: 0, timedOut: 0 };
   nodes;
-  held = /* @__PURE__ */ new Set();
+  held = new HeldSet((path) => this.released(path));
   processMounts;
   booting = new AbortController();
   fstab = Promise.resolve([]);
@@ -9991,7 +10261,7 @@ var Launcher = class {
     });
     enableCdp(this.net, this.cdp);
     const fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
-    this.nodes = new VfsNodes(fs);
+    this.nodes = new VfsNodes(fs, (path) => this.released(path));
     this.openFiles.add(this.nodes);
     this.fs = keepingOpen(fs, this.nodes);
     this.watchers.watch([this.modulesDir, this.pnpmHome], { recursive: true }, () => {
@@ -10180,6 +10450,7 @@ var Launcher = class {
         this.settling.syscall(pid, call.op);
       },
       ...req.ignored ? { ignored: req.ignored } : {},
+      ...req.umask !== void 0 ? { umask: req.umask } : {},
       program: req.program,
       argv0: req.argv0,
       args: req.args,
@@ -10271,7 +10542,8 @@ var Launcher = class {
         ...described,
         started: (this.described.get(root.pid) ?? described).started,
         state: this.processes.has(member.pid) ? "S" : "Z",
-        memory: this.processes.get(member.pid)?.memory() ?? 0
+        memory: this.processes.get(member.pid)?.memory() ?? 0,
+        umask: this.umaskOf(member.pid)
       });
     }
     return listed;
@@ -10293,6 +10565,7 @@ var Launcher = class {
         report,
         ppid,
         ignored: this.ignoredBy(ppid),
+        umask: this.umaskOf(ppid),
         ...exec
       });
       deciding?.attach();
@@ -10337,7 +10610,8 @@ var Launcher = class {
         fds,
         ppid,
         fork: state,
-        ignored: this.ignoredBy(ppid, true)
+        ignored: this.ignoredBy(ppid, true),
+        umask: this.umaskOf(ppid)
       })
     );
   }
@@ -10346,6 +10620,14 @@ var Launcher = class {
     const foreground = () => this.jobs.tcgetpgrp(tty, fallback);
     this.settling.deliver(sig, pgid, send, tty.reading ? void 0 : foreground);
   }
+  umaskOf(pid) {
+    return this.processes.get(pid)?.umask?.() ?? DEFAULT_UMASK;
+  }
+  released(path) {
+    const at = normalizePath(path);
+    const open = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
+    if (!open) void this.mounts.commit(at).catch(() => void 0);
+  }
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }