@ai-ecoverse/slicc-kernel 1.75.0 → 1.75.1

package/README.md

@@ -664,7 +664,7 @@ The kernel writes `/etc/passwd` and `/etc/group` when it starts (see [Users](#us
 OPFS stores names, bytes, sizes and modification times, nothing else. Everything POSIX needs on top of that lives in an IndexedDB sidecar, so it survives reloads and new kernels:
 
 - mode bits (`chmod`);
-- access and change times, and a modification time set explicitly with `utime` (it holds until the file is written again); a directory's times move whenever an entry is created, removed or renamed in it, as POSIX asks, and a time set explicitly after such a change keeps winning, also when the change was made in another kernel and its write lands later; an Emscripten program reads a directory's times again after any call that can wait on another process (a pipe or socket read, `wait`, `poll`, a sleep), so a program that waits for a child or a peer to fill a directory sees the new times (rsync's final directory times rely on it), while a walk without waits reads each directory once; `chown`/`fchown` leave the times alone (Emscripten stamps the setattr of a chown with the current time, which isn't taken as an mtime);
+- access and change times, and a modification time set explicitly with `utime` (it holds until the file is written again: any write or truncate moves it to the time of the write, also in Chrome, whose OPFS doesn't move a file's `lastModified` for writes through a sync access handle, so the kernel records the write's time itself, and it reaches the metadata store up to 100 ms after the write, so a tab closed inside that window keeps the old mtime on disk; the time follows a rename and is dropped with the file); a directory's times move whenever an entry is created, removed or renamed in it, as POSIX asks, and a time set explicitly after such a change keeps winning, also when the change was made in another kernel and its write lands later; an Emscripten program reads a directory's times again after any call that can wait on another process (a pipe or socket read, `wait`, `poll`, a sleep), so a program that waits for a child or a peer to fill a directory sees the new times (rsync's final directory times rely on it), while a walk without waits reads each directory once; `chown`/`fchown` leave the times alone (Emscripten stamps the setattr of a chown with the current time, which isn't taken as an mtime);
 - inode numbers that stay stable across renames;
 - symbolic links (`symlink`, `readlink`, `lstat`, and following them in paths), which exist only in the sidecar, with their own times: `touch -h`, `lutimes` and `utimensat` with `AT_SYMLINK_NOFOLLOW` set the link's, never the target's. A link's own mode can't be changed, as on Linux: `chmod -h`, `lchmod` and `fchmodat` with `AT_SYMLINK_NOFOLLOW` fail with `EOPNOTSUPP` (which `chmod -h` and `tar` ignore for links) and never follow it, and `open` with `O_PATH | O_NOFOLLOW` gives a descriptor for the link itself.
 

package/dist/kernel-worker.js

@@ -783,6 +783,7 @@ function syncAccessHandles(scope = globalThis) {
 function isHandle(child) {
   return "kind" in child;
 }
+var FILE_TIMES_MS = 100;
 var OpfsFs = class {
   root;
   meta;
@@ -1053,8 +1054,50 @@ var OpfsFs = class {
     const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
     return (directory ? S_IFDIR : S_IFREG) | (meta?.mode ?? fallback);
   }
+  id = crypto.randomUUID();
   dirTimes = /* @__PURE__ */ new Map();
   dirDirty = /* @__PURE__ */ new Set();
+  fileTimes = /* @__PURE__ */ new Map();
+  written(target) {
+    this.committed(target);
+    if (!this.ranged) return;
+    this.fileTimes.set(target, Date.now());
+    this.scheduleFileTimes();
+  }
+  scheduleFileTimes() {
+    if (this.flushing.file || this.fileTimes.size === 0) return;
+    this.flushing.file = setTimeout(() => {
+      void this.flushFileTimes().catch(() => void 0).finally(() => {
+        this.flushing.file = void 0;
+        this.scheduleFileTimes();
+      });
+    }, FILE_TIMES_MS);
+    this.flushing.file.unref?.();
+  }
+  async flushFileTimes() {
+    for (const [path, ms] of [...this.fileTimes]) {
+      const mtimeFor = await this.modified(path).catch(() => 0);
+      await this.meta.update(
+        path,
+        (entry) => this.fileTimes.get(path) !== ms || this.explicitWins(entry, ms) ? entry : { ...entry, path, mtimeMs: ms, mtimeFor, ctimeMs: ms }
+      );
+      if (this.fileTimes.get(path) === ms) this.fileTimes.delete(path);
+    }
+  }
+  timesOf(path) {
+    return this.dirTimes.get(path) ?? this.fileTimes.get(path);
+  }
+  explicitWins(entry, ms) {
+    if (entry?.timesAt === void 0 || entry.timesBy === this.id) return false;
+    return entry.timesAt >= ms;
+  }
+  movePending(from, to) {
+    for (const [path, ms] of [...this.fileTimes]) {
+      if (!within2(path, from)) continue;
+      this.fileTimes.delete(path);
+      if (to !== void 0) this.fileTimes.set(to + path.slice(from.length), ms);
+    }
+  }
   flushing = {};
   touch(...dirs) {
     const now = Date.now();
@@ -1078,11 +1121,10 @@ var OpfsFs = class {
       if (this.dirTimes.get(path) === ms) this.dirTimes.delete(path);
     }
   }
-  async statOf(path, handle, meta) {
+  async statOf(path, handle, meta, touched) {
     const directory = handle.kind === "directory";
     const file = directory ? void 0 : await handle.getFile();
     const modified = file?.lastModified ?? 0;
-    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 {
@@ -1114,13 +1156,14 @@ var OpfsFs = class {
   }
   async describe(found) {
     if (found.link) return this.owned(this.linkStat(found.link), found.path, found.link);
+    const touched = this.timesOf(found.path);
     if (!this.owners) {
       const [meta2] = await this.meta.get([found.path]);
-      return this.statOf(found.path, found.handle, meta2);
+      return this.statOf(found.path, found.handle, meta2, touched);
     }
     const entries = await this.meta.get(chain(found.path));
     const meta = entries.pop();
-    const stat = await this.statOf(found.path, found.handle, meta);
+    const stat = await this.statOf(found.path, found.handle, meta, touched);
     return { ...stat, ...ownOf(meta) ?? inherit(entries) };
   }
   async stat(path) {
@@ -1177,13 +1220,14 @@ var OpfsFs = class {
   async pwrite(path, offset, bytes) {
     const [handle, , target] = await this.fileFor(path);
     await this.retrying(path, () => positioned(handle, (io) => io.write(offset, bytes)), true);
-    this.committed(target);
+    this.written(target);
   }
   async truncate(path, size) {
     const handle = await this.existing(path, true);
-    const target = this.remote?.watched() ? (await this.locate(path, true)).path : path;
+    const resolve = this.ranged || this.remote?.watched();
+    const target = resolve ? (await this.locate(path, true)).path : path;
     await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
-    this.committed(target);
+    this.written(target);
   }
   async writeSession(path, truncate) {
     const [handle, , target] = await this.fileFor(path);
@@ -1273,13 +1317,16 @@ var OpfsFs = class {
   async readdirStat(path) {
     const [dir, children2] = await this.listing(path);
     const base = dir === "/" ? "" : dir;
+    const touched = children2.map(([name2]) => this.timesOf(`${base}/${name2}`));
     const metas = await this.meta.get(children2.map(([name2]) => `${base}/${name2}`));
     const handed2 = this.owners ? await this.handedTo(dir) : void 0;
     const owned4 = (stat, entry) => handed2 ? { ...stat, ...ownOf(entry) ?? handed2 } : stat;
     return Promise.all(
       children2.map(async ([name2, child], i) => {
         if (!isHandle(child)) return [name2, owned4(this.linkStat(child), child)];
-        const stat = await this.statOf(`${base}/${name2}`, child, metas[i]).catch(() => null);
+        const stat = await this.statOf(`${base}/${name2}`, child, metas[i], touched[i]).catch(
+          () => null
+        );
         return [name2, stat && owned4(stat, metas[i])];
       })
     );
@@ -1337,6 +1384,7 @@ var OpfsFs = class {
         throw translate(err, path);
       }
       this.changed(found.path);
+      this.movePending(found.path);
     }
     await this.meta.remove([found.path]);
     this.touch(parentOf3(found.path));
@@ -1400,6 +1448,7 @@ var OpfsFs = class {
     const moved2 = await this.place(source.handle, dir, staging);
     if (swap) await this.rm(destination, { recursive: true });
     await this.meta.move(source.path, destination, carry);
+    this.movePending(source.path, destination);
     if (!moved2) await this.rm(source.path, { recursive: true });
     let copied = !moved2;
     if (swap) {
@@ -1521,6 +1570,7 @@ var OpfsFs = class {
     const handle = found.handle;
     const file = handle.kind === "file" ? await handle.getFile() : void 0;
     this.dirTimes.delete(found.path);
+    this.fileTimes.delete(found.path);
     const ctimeMs = Date.now();
     await this.meta.update(found.path, (entry) => ({
       ...entry,
@@ -1529,7 +1579,8 @@ var OpfsFs = class {
       mtimeMs: mtime.getTime(),
       mtimeFor: file?.lastModified ?? 0,
       ctimeMs,
-      timesAt: ctimeMs
+      timesAt: ctimeMs,
+      timesBy: this.id
     }));
   }
   async reconcile() {