@ai-ecoverse/slicc-kernel 1.167.3 → 1.167.4

package/README.md

@@ -1260,7 +1260,7 @@ Reads retry briefly when a concurrent write has invalidated the OPFS file snapsh
 
 At boot, a kernel drops sidecar records whose file is gone (and symlink records whose name became a real file or whose directory is gone), left behind by a tab that closed mid-change. It does this only when it is the only kernel on the origin (the watch channel's join handshake finds no other), and it drops a record only if it is still the one it found: another tab's live changes made while it looked, such as a placeholder tar replaces with a symlink, are kept. Up to 1.119.2, a tab that booted while another extracted symlinks with tar could drop some of them.
 
-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 in the kernel's next 64 lookups, for at most 100 ms ([#1425](https://github.com/ai-ecoverse/slicc-kernel/issues/1425)), so the count doesn't depend on how fast the machine is. So a file another writer removed is missing, and a rewritten one shows its new contents, within 100 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 the kernel's next 256 lookups, for at most 100 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, up to a few hundred lookups apart); 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 that window is seen up to 100 ms late. While another kernel shares the root, both short-lived windows follow the contract below. From [#945](https://github.com/ai-ecoverse/slicc-kernel/issues/945) until [#984](https://github.com/ai-ecoverse/slicc-kernel/issues/984) they were off then, which made every stat and every miss an OPFS call.
+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 in the kernel's next 64 lookups, for at most 100 ms ([#1425](https://github.com/ai-ecoverse/slicc-kernel/issues/1425)), so the count doesn't depend on how fast the machine is. So a file another writer removed is missing, and a rewritten one shows its new contents, within 100 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 the kernel's next 256 lookups, for at most 100 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, up to a few hundred lookups apart); 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 that window is seen up to 100 ms late. A listing of the directory (`ls`, a glob, `readdir`) ends it too for every name it shows, so `ls` and then `cat` agree ([#1693](https://github.com/ai-ecoverse/slicc-kernel/issues/1693)). A writer outside the kernel whose file must open in the very next run, such as a page that writes a file and then calls `kernel.run`, posts a notice for it (`postFsNotice`, below) or waits 100 ms. While another kernel shares the root, both short-lived windows follow the contract below. From [#945](https://github.com/ai-ecoverse/slicc-kernel/issues/945) until [#984](https://github.com/ai-ecoverse/slicc-kernel/issues/984) they were off then, which made every stat and every miss an OPFS call.
 
 **What another tab sees, and when** ([#984](https://github.com/ai-ecoverse/slicc-kernel/issues/984)): one rule covers everything a kernel caches about a shared root.
 - **Notices:** while another kernel shares the root, a kernel posts a notice before each changing call returns. A notice names the sidecar records it changed (owners, modes, links, times, write counts), the directories it created, removed or renamed into, and the files it wrote back ([#962](https://github.com/ai-ecoverse/slicc-kernel/issues/962)).

package/dist/kernel-worker.js

@@ -2838,6 +2838,10 @@ var OpfsFs = class {
     const children3 = /* @__PURE__ */ new Map();
     this.others++;
     for await (const child of handle.values()) children3.set(child.name, child);
+    if (this.absent.size > 0) {
+      const base = found.path === "/" ? "" : found.path;
+      for (const name2 of children3.keys()) this.absent.delete(`${base}/${name2}`);
+    }
     for (const link2 of await this.meta.links(found.path)) {
       const name2 = baseOf(link2.path);
       if (!children3.has(name2)) children3.set(name2, link2);
@@ -5271,28 +5275,39 @@ async function stickyEntry(g, op, path, dir) {
   if (sticky(g.cred, perm, (await ancestryOf(g.fs, entry)).at(-1))) return;
   if (await present(g.fs, entry, false)) deny(g, op, path, "EPERM");
 }
+async function unwritable(g, op, path, dir) {
+  if (dir.denied === void 0) return false;
+  if (dir.link) {
+    deny(g, op, dir.denied);
+    return false;
+  }
+  const perm = dir.denied === dir.path ? dir.perm : void 0;
+  if (perm && !await present(g.fs, dir.path, true)) return false;
+  if (perm && permits(g.cred, perm, X_OK)) return true;
+  deny(g, op, path);
+  return false;
+}
 async function inParent(g, op, path, old = false) {
   await fence(g, op, path);
-  if (old === "replaced") {
-    const dir2 = await need(g, op, parentOf4(path), W_OK | X_OK, DIR, path);
-    return dir2.denied === void 0 ? stickyEntry(g, op, path, dir2) : void 0;
-  }
-  if (!old) return void await need(g, op, parentOf4(path), W_OK | X_OK, DIR, path);
   const dir = await access(g.fs, g.cred, parentOf4(path), W_OK | X_OK, linked(g, DIR));
+  if (old !== true) {
+    if (await unwritable(g, op, path, dir)) deny(g, op, path);
+    else if (old === "replaced" && dir.denied === void 0) await stickyEntry(g, op, path, dir);
+    return;
+  }
   if (dir.denied === void 0) return stickyEntry(g, op, path, dir);
   if (dir.link) return deny(g, op, dir.denied);
   const lookup2 = dir.denied === dir.path && dir.perm && permits(g.cred, dir.perm, X_OK);
   if (!lookup2 || await present(g.fs, entryIn(dir, path), false)) deny(g, op, path);
 }
-async function makeIn(g, op, path) {
+async function makeIn(g, op, path, parents = true) {
   for (let dir = parentOf4(path); ; dir = parentOf4(dir)) {
     const walked = await access(g.fs, g.cred, dir, W_OK | X_OK, linked(g, DIR));
-    if (walked.link) return deny(g, op, walked.denied);
-    if (walked.denied !== void 0) {
+    if (await unwritable(g, op, path, walked)) {
       if (!await present(g.fs, path, true)) deny(g, op, path);
       return;
     }
-    if (!walked.missing || dir === "/") return;
+    if (!parents || !walked.missing || dir === "/") return;
   }
 }
 async function tree(g, op, dir, perm) {
@@ -8477,7 +8492,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.167.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.167.4" : "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
@@ -15134,7 +15149,7 @@ async function guard(g, path, req, cwd) {
       return { path: w };
     }
     case "mkdir": {
-      await makeIn(g, op, path);
+      await makeIn(g, op, path, !req.exclusive);
       return { path: await walkSafe(g, path, false) };
     }
     case "create":