@ai-ecoverse/slicc-kernel 1.35.1 → 1.36.0

package/dist/kernel-worker.js

@@ -448,11 +448,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,
@@ -461,7 +491,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 } : {}
     };
@@ -538,6 +568,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));
   }
@@ -555,10 +598,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);
@@ -616,6 +661,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;
@@ -639,6 +685,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;
@@ -670,6 +717,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;
@@ -691,6 +739,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);
@@ -754,6 +803,7 @@ var OpfsFs = class {
       mtimeMs: now,
       ctimeMs: now
     }));
+    this.touch(parent.path);
   }
   async realpath(path, follow) {
     return (await this.locate(path, follow)).path;
@@ -794,6 +844,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,
@@ -5187,18 +5238,36 @@ function parseSize(text) {
   return Math.floor(Number(match[1]) * UNITS[match[2].toLowerCase()]);
 }
 var within3 = (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 (within3(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) {
@@ -5266,6 +5335,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();
@@ -5390,8 +5461,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 settle3 = () => {
+      if (this.committing.get(real) === entry) this.committing.delete(real);
+    };
+    done4.then(settle3, settle3);
+    return done4;
+  }
+  async commitUnder(prefix) {
+    const at = normalizePath(prefix);
+    await Promise.all(
+      [...this.sessions.keys()].filter((p) => within3(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";
@@ -5450,6 +5582,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;
@@ -5509,6 +5648,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) {
@@ -5558,6 +5698,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;
@@ -5580,6 +5721,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,
@@ -5633,6 +5775,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,
@@ -5641,17 +5791,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);
@@ -5663,6 +5816,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 {
@@ -5684,7 +5839,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);
@@ -5711,7 +5875,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)];
       })
@@ -5747,6 +5911,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);
@@ -5770,6 +5935,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 {
@@ -7376,6 +7543,7 @@ var VfsNode = class {
   writeBack;
   writeBackCost = 0;
   opens = 0;
+  writers = 0;
   missing = false;
   revoked = false;
   fs;
@@ -7551,8 +7719,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);
@@ -7590,16 +7760,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);
@@ -7608,15 +7779,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());
@@ -7762,7 +7945,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) => {
@@ -7825,7 +8008,7 @@ function vfsFile(fs, opts, nodes) {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node);
+        nodes?.closed(node, writable);
       }
     })
   });
@@ -9172,7 +9355,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) {
@@ -9212,30 +9399,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) {
@@ -9251,6 +9428,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));
@@ -9966,6 +10150,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);
@@ -9974,6 +10159,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);
@@ -9981,6 +10167,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("/")}`;
@@ -9997,6 +10184,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);
@@ -10004,6 +10193,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);
@@ -10302,7 +10492,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([]);
@@ -10344,7 +10534,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 }, () => {
@@ -10706,6 +10896,11 @@ var Launcher = class {
   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;
   }