@ai-ecoverse/slicc-kernel 1.119.0 → 1.119.2

package/README.md

@@ -932,7 +932,7 @@ Not covered: hard links (OPFS cannot share contents between names; they work onl
 
 Reads retry briefly when a concurrent write has invalidated the OPFS file snapshot (`NotReadableError`).
 
-A kernel caches the directory handles it has walked and the sidecar entries it has read. Its own changes keep both caches current, and the other kernels on the origin hear of them through a `BroadcastChannel` named after the database (one for the sidecar, one for directories). A cached directory is checked against its path (`resolve()`) at most once a second before a lookup goes through it, so a directory moved, removed or replaced by another writer, such as a page using the OPFS API, is found at its new place or reported missing within a second. It also keeps the file handles it has looked up (up to 4,096, the least recently used dropped first) for a second after each lookup. Before it uses one, it reads the file through it, which is the read a `stat` needs anyway, and that read serves the handle's uses of the next 2 ms. So a file another writer removed is missing, and a rewritten one shows its new contents, within 2 ms. The kernel's own writes, truncates, rewrites and renames drop the read at once, and a read that started before an own change isn't kept, so the kernel's own changes always show at once. One replaced by a directory is seen as a directory within a second. Its own changes, and the other kernels' notices, drop the handles they touch at once. A lookup of a directory it has cached and checked within the second is answered from the cache, so a directory replaced by another writer is seen as replaced within a second, as above. A name it has just found missing stays missing for 2 ms, which serves the several checks a single create makes of a name that isn't there yet (about ten per file in a pnpm install); its own creates, renames and links in that directory end that at once, so only a file another kernel or a page using the OPFS API makes in those 2 ms is seen up to 2 ms late.
+A kernel caches the directory handles it has walked and the sidecar entries it has read. Its own changes keep both caches current, and the other kernels on the origin hear of them through a `BroadcastChannel` named after the database (one for the sidecar, one for directories). A cached directory is checked against its path (`resolve()`) at most once a second before a lookup goes through it, so a directory moved, removed or replaced by another writer, such as a page using the OPFS API, is found at its new place or reported missing within a second. It also keeps the file handles it has looked up (up to 4,096, the least recently used dropped first) for a second after each lookup. Before it uses one, it reads the file through it, which is the read a `stat` needs anyway, and that read serves the handle's uses of the next 2 ms. So a file another writer removed is missing, and a rewritten one shows its new contents, within 2 ms. The kernel's own writes, truncates, rewrites and renames drop the read at once, and a read that started before an own change isn't kept, so the kernel's own changes always show at once. One replaced by a directory is seen as a directory within a second. Its own changes, and the other kernels' notices, drop the handles they touch at once. A lookup of a directory it has cached and checked within the second is answered from the cache, so a directory replaced by another writer is seen as replaced within a second, as above. A name it has just found missing stays missing for 2 ms, which serves the several checks a single create makes of a name that isn't there yet (about ten per file in a pnpm install); its own creates, renames and links in that directory end that at once, so only a file another kernel or a page using the OPFS API makes in those 2 ms is seen up to 2 ms late. Both 2 ms windows are off while another kernel shares the root (a second tab on the origin, found through the watch channel's join handshake, and until that handshake is done), so between tabs every look is fresh, as before 1.113.0; only a page writing through the OPFS API itself can still be seen up to 2 ms late ([#945](https://github.com/ai-ecoverse/slicc-kernel/issues/945)). A single tab keeps them.
 
 The filesystem is our own rather than [ZenFS](https://github.com/zen-fs/core) (which SLICC uses), because OPFS stays the single source of truth: other writers, such as the BIOS installing packages or a page writing files, need no index to stay consistent with, and nothing is preloaded into memory at mount. POSIX metadata lives in the IndexedDB sidecar described above, which has per-entry transactions instead of one JSON file rewritten on every change.
 

package/dist/kernel-worker.js

@@ -872,6 +872,7 @@ var RemoteWatch = class {
   pruned = 0;
   joined;
   met;
+  settled = false;
   quiet;
   constructor(name2, options = {}) {
     this.name = name2;
@@ -887,7 +888,9 @@ var RemoteWatch = class {
       });
       if (!this.locks) resolve2();
     });
-    this.joined = granted2.then(() => this.join());
+    this.joined = granted2.then(() => this.join()).then(() => {
+      this.settled = true;
+    });
     this.channel.postMessage({ hello: this.tab });
   }
   async join() {
@@ -909,6 +912,9 @@ var RemoteWatch = class {
     await this.joined;
     return this.peers.size > 0;
   }
+  crowded() {
+    return !this.settled || this.peers.size > 0;
+  }
   lockOf(tab) {
     return `${this.name}:${tab}`;
   }
@@ -1493,7 +1499,7 @@ var OpfsFs = class {
     const kept = this.dirs.get(path);
     if (kept && await this.current(path, kept)) return kept;
     const gone = this.absent.get(path);
-    if (gone !== void 0 && performance.now() - gone < ABSENT_MS) {
+    if (gone !== void 0 && !this.shared() && performance.now() - gone < ABSENT_MS) {
       throw translate({ name: "NotFoundError" }, path);
     }
     const seen = this.changes;
@@ -1680,7 +1686,11 @@ var OpfsFs = class {
         if (this.dirTimes.get(path) === ms) this.dirTimes.delete(path);
     }
   }
+  shared() {
+    return this.remote?.crowded() === true;
+  }
   glanced(handle) {
+    if (this.shared()) return void 0;
     const seen = this.glances.get(handle);
     const fresh2 = seen && seen.changes === this.changes && performance.now() - seen.at < GLANCE_MS;
     return fresh2 ? seen.file : void 0;
@@ -6366,7 +6376,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.119.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.119.2" : "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