@ai-ecoverse/slicc-kernel 1.166.5 → 1.167.1

package/README.md

@@ -1256,7 +1256,7 @@ The database is `slicc-kernel` (or the `metadata` option), schema version 1, wit
 
 Not covered: hard links (OPFS cannot share contents between names; they work only within a mount whose driver offers `links`, such as `tmpfs`). File owners are stored only with `users: 'report'` or `'enforce'` (see [File owners](#file-owners)). With `users: 'off'`, an Emscripten process built against the kernel's credential calls (its glue imports `slicc_cred_js`, as homescoop's H1 builds do) sees every file as owned by its own effective uid and gid: root's 0 by default, a user's own ids when it runs as one, and the new ids after a `setuid`. Owner checks such as git's `safe.directory`, ssh's key checks and gnupg's home directory check then pass, as WASIX programs already see through their libc. An older program, whose libc says it is uid 1000 whoever runs it, sees every file as owned by 1000:1000 as before, so its own checks pass too. The kernel decides this once, when it loads the program. Emscripten also doesn't enforce permission bits, so a file runs whether or not its exec bit is set; the bits are what `ls`, `stat` and `test` report. With `users: 'off'` a file or directory with no permission bits at all shows as `0666` or `0777` to Emscripten programs; with owners on they see the real mode (`0`), and the kernel, not Emscripten's own checks, decides who may read, write or enter it (`cd` asks the kernel for `x` on the directory), so root still enters a `000` directory.
 
-Reads retry briefly when a concurrent write has invalidated the OPFS file snapshot (`NotReadableError`).
+Reads retry briefly when a concurrent write has invalidated the OPFS file snapshot (`NotReadableError`). A positioned read uses the snapshot the kernel's last look at the file took (below) when it is still current and covers the whole range, so a run of reads through a descriptor makes no `getFile` of its own beyond the one each window's look takes ([#1626](https://github.com/ai-ecoverse/slicc-kernel/issues/1626)). A read past the snapshot's end, an empty read, or a snapshot that can't be read any more takes a fresh one. In Chrome the snapshot holds no bytes of its own: it reads the file as it is now, so a write in place (a sync access handle) shows at once, and a file another writer replaced, truncated or removed fails the snapshot (`NotReadableError`, `NotFoundError`), which sends the read to a fresh one. Holding a snapshot blocks no other writer: a sync access handle, `createWritable`, `move` and `removeEntry` all go ahead.
 
 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.
 

package/dist/kernel-worker.js

@@ -1312,6 +1312,7 @@ var RemoteWatch = class {
       };
       const left = /* @__PURE__ */ new Set([to]);
       const timer = setTimeout(done5, cap);
+      timer.unref?.();
       this.waiting.set(seq2, { left, done: done5 });
     });
   }
@@ -1353,6 +1354,9 @@ var RemoteWatch = class {
         this.keeps?.left(tab);
         this.ackers.delete(tab);
         this.holders.delete(tab);
+        for (const wait2 of [...this.waiting.values()]) {
+          if (wait2.left.delete(tab) && wait2.left.size === 0) wait2.done();
+        }
       }
     }
     this.rebuild();
@@ -1598,9 +1602,9 @@ async function unlocked(name2, op) {
       return await op();
     } catch (err) {
       if (!LOCKED.has(err?.name)) throw err;
-      const delay = SYNC_BACKOFF_MS[attempt];
-      if (delay === void 0) throw fsError("EBUSY", name2);
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      const delay2 = SYNC_BACKOFF_MS[attempt];
+      if (delay2 === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay2));
     }
   }
 }
@@ -1611,10 +1615,10 @@ async function openSync(handle) {
     try {
       return await sync.call(handle, { mode: "readwrite-unsafe" });
     } catch (err) {
-      const delay = SYNC_BACKOFF_MS[attempt];
+      const delay2 = SYNC_BACKOFF_MS[attempt];
       if (!LOCKED.has(err?.name)) throw err;
-      if (delay === void 0) return void 0;
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      if (delay2 === void 0) return void 0;
+      await new Promise((resolve2) => setTimeout(resolve2, delay2));
     }
   }
 }
@@ -2552,6 +2556,15 @@ var OpfsFs = class {
   }
   async pread(path, offset, length2) {
     return this.reading(path, async (handle) => {
+      const seen = this.glanced(handle);
+      if (seen && length2 > 0 && offset + length2 <= seen.size) {
+        const bytes = await this.io(seen.slice(offset, offset + length2).arrayBuffer()).then(
+          (buffer) => new Uint8Array(buffer),
+          () => void 0
+        );
+        if (bytes?.length === length2) return bytes;
+        this.glances.delete(handle);
+      }
       const file = await this.io(handle.getFile());
       await this.refuseNode(path, file.size === 0);
       return new Uint8Array(await file.slice(offset, offset + length2).arrayBuffer());
@@ -3623,9 +3636,9 @@ var OpfsFs = class {
       if (!failed3) return true;
       const error = failed3.err?.name;
       if (handle.kind !== "file" || !LOCKED.has(error)) return false;
-      const delay = SYNC_BACKOFF_MS[attempt];
-      if (delay === void 0) throw fsError("EBUSY", name2);
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      const delay2 = SYNC_BACKOFF_MS[attempt];
+      if (delay2 === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay2));
     }
   }
   async copy(handle, dir, name2, copies, rest2 = "") {
@@ -8464,7 +8477,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.166.5" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.167.1" : "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
@@ -9415,8 +9428,41 @@ var within4 = (path, target) => path === target || target === "/" || path.starts
 var TOUCHED_MAX = 4096;
 var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var PEER_RM_MS = 1e3;
+var SHARED_ACK_MS = 24 * 60 * 60 * 1e3;
+var delay = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var PEER_RENAME_MS = 1e4;
 var PEER_GATE_MS = PEER_RENAME_MS + 5e3;
+var SHARED_PREFIX = "shared.";
+var keptLock = (hidden) => `slicc-kept:${hidden}`;
+function sharedKept(hidden) {
+  const at = `/${UNLINKED_DIR}/${SHARED_PREFIX}`;
+  return hidden.startsWith(at) && /^[0-9a-f]+$/.test(hidden.slice(at.length));
+}
+function holdShared(locks, name2) {
+  if (!locks) return Promise.resolve(async () => void 0);
+  return new Promise((resolve2) => {
+    const settled = locks.request(name2, { mode: "shared" }, () => {
+      const { promise, resolve: done5 } = Promise.withResolvers();
+      resolve2(async () => {
+        done5();
+        await settled.catch(() => void 0);
+      });
+      return promise;
+    });
+  });
+}
+async function whenLast(locks, name2, op) {
+  if (!locks) {
+    await op();
+    return true;
+  }
+  let free = false;
+  await locks.request(name2, { mode: "exclusive", ifAvailable: true }, async (lock) => {
+    free = lock !== null;
+    if (free) await op();
+  });
+  return free;
+}
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
 var PathGate = class {
@@ -9732,52 +9778,124 @@ var UnlinkedKeeper = class {
         void peers.ask(tab, { kept: { items: [], paths } }, PEER_RM_MS);
       throw fsError("EBUSY", `${target}: open in another tab that did not answer`);
     }
-    const { whole, sends } = await this.setAside(target, asked);
-    return { whole, undoing: (op) => this.undoing(op, peers, sends, heard) };
+    const { whole, sends, shared } = await this.setAside(target, asked);
+    return { whole, undoing: (op) => this.undoing(op, peers, sends, heard, shared) };
   }
   async setAside(target, asked) {
     const mine = this.heldWithin(target);
-    const taken = /* @__PURE__ */ new Set();
-    let whole = false;
+    const tabsOf = /* @__PURE__ */ new Map();
+    for (const { holders } of asked)
+      for (const { path } of holders) tabsOf.set(path, (tabsOf.get(path) ?? 0) + 1);
+    const done5 = /* @__PURE__ */ new Map();
+    const shared = [];
     const sends = [];
     for (const { tab, holders, paths } of asked) {
       const items = [];
       for (const holder of holders) {
-        const free = !mine.has(holder.path) && !taken.has(holder.path);
-        const hidden = free ? await this.asideFor(holder.path, holder.instance) : void 0;
-        if (hidden !== void 0) {
-          taken.add(holder.path);
-          if (holder.path === target) whole = true;
+        if (!done5.has(holder.path)) {
+          const many = mine.has(holder.path) || (tabsOf.get(holder.path) ?? 0) > 1;
+          done5.set(holder.path, await this.asideOne(holder, many, mine, shared));
         }
-        items.push({ path: holder.path, hidden, fid: holder.fid });
+        items.push({ path: holder.path, hidden: done5.get(holder.path), fid: holder.fid });
       }
       sends.push({ tab, items, paths });
     }
-    return { whole, sends };
+    return { whole: done5.get(target) !== void 0, sends, shared };
   }
-  async undoing(op, peers, sends, heard) {
+  async asideOne(holder, many, mine, shared) {
+    if (!many) return this.asideFor(holder.path, holder.instance);
+    const one = await this.sharedAside(holder.path, mine);
+    if (one) shared.push(one);
+    return one?.hidden;
+  }
+  async sharedAside(path, mine) {
+    const hidden = `${dirOf("/")}/${SHARED_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
+    const release = await holdShared(this.sharedLocks(), keptLock(hidden));
+    const moved2 = await this.serial(async () => {
+      try {
+        const owner = this.dirOwner;
+        await this.fs.mkdir(dirOf("/"), { recursive: true, ...owner ? { owner } : {} });
+        await this.fs.rename(path, hidden);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!moved2) {
+      await release();
+      return void 0;
+    }
+    const local2 = mine.get(path) ?? [];
+    const file = local2.length > 0 ? await this.sharedFile(hidden, local2.length) : void 0;
+    if (file) for (const holder of local2) holder.keep(path, file);
+    return { path, hidden, release, local: local2, file };
+  }
+  async sharedFile(hidden, refs) {
+    const locks = this.sharedLocks();
+    const mine = await holdShared(locks, keptLock(hidden));
+    let left = refs;
+    return {
+      hidden,
+      release: () => {
+        if (--left > 0) return;
+        void mine().then(() => this.dropIfLast(hidden));
+      }
+    };
+  }
+  dropIfLast(hidden) {
+    return this.serial(
+      () => whenLast(this.sharedLocks(), keptLock(hidden), () => this.drop(hidden))
+    );
+  }
+  sharedLocks() {
+    return this.locks;
+  }
+  async undoing(op, peers, sends, heard, shared = []) {
     let failed3;
     let out;
     try {
       out = await op();
     } catch (err) {
       failed3 = err ?? new Error("failed");
-      for (const send2 of sends) {
-        for (const item of send2.items) {
-          const { hidden, path } = item;
-          if (hidden !== void 0 && await this.moveBack(hidden, path)) item.hidden = void 0;
-        }
-      }
+      await this.rollBackAsides(sends, shared);
     }
+    const hiddenShared = new Set(shared.map((one) => one.hidden));
+    const answers2 = sends.map(({ tab, items, paths }) => {
+      const keeps = items.some((item) => item.hidden && hiddenShared.has(item.hidden));
+      return {
+        keeps,
+        told: peers.ask(tab, { kept: { items, paths } }, keeps ? SHARED_ACK_MS : PEER_RM_MS)
+      };
+    });
     await Promise.all(
-      sends.map(({ tab, items, paths }, i) => {
-        const told = peers.ask(tab, { kept: { items, paths } }, PEER_RM_MS);
-        return heard[i] ? told : void 0;
-      })
+      answers2.map(({ told }, i) => heard[i] ? Promise.race([told, delay(PEER_RM_MS)]) : void 0)
     );
+    for (const one of shared) {
+      const waits = answers2.filter(
+        ({ keeps }, i) => keeps && sends[i]?.items.some((item) => item.hidden === one.hidden)
+      );
+      const done5 = () => one.release().then(() => this.dropIfLast(one.hidden));
+      void Promise.all(waits.map(({ told }) => told)).then(done5, done5);
+    }
     if (failed3 !== void 0) throw failed3;
     return out;
   }
+  async rollBackAsides(sends, shared) {
+    const back = /* @__PURE__ */ new Map();
+    for (const item of sends.flatMap((send2) => send2.items)) {
+      const { hidden, path } = item;
+      if (hidden === void 0) continue;
+      if (!back.has(hidden)) back.set(hidden, await this.moveBack(hidden, path));
+      if (back.get(hidden)) item.hidden = void 0;
+    }
+    for (const { hidden, path, local: local2, file } of shared) {
+      if (!back.get(hidden) || !file) continue;
+      for (const holder of local2) {
+        holder.unkeep(path, file);
+        file.release();
+      }
+    }
+  }
   moveBack(hidden, path) {
     return this.serial(async () => {
       if (await this.present(path)) return false;
@@ -9886,6 +10004,15 @@ var UnlinkedKeeper = class {
       for (const name2 of names2) {
         const id2 = name2.slice(0, name2.lastIndexOf("."));
         const at = id2.indexOf("~");
+        if (name2.startsWith(SHARED_PREFIX)) {
+          const at2 = `${dir}/${name2}`;
+          await whenLast(
+            this.sharedLocks(),
+            keptLock(at2),
+            () => this.fs.rm(at2, { recursive: true }).catch(() => void 0)
+          );
+          continue;
+        }
         const dead = id2 !== this.instance && (at < 0 ? held !== void 0 && !held.has(lockName(id2)) : owner?.alive(id2.slice(0, at)) === false);
         if (dead) await this.fs.rm(`${dir}/${name2}`, { recursive: true }).catch(() => void 0);
       }
@@ -24598,13 +24725,13 @@ var VfsNode = class {
     this.recount();
     if (!this.orphaned) this.onDirty?.();
     if (this.writeBack !== void 0 || this.orphaned) return;
-    const delay = Math.max(WRITEBACK_MS, this.writeBackCost * WRITEBACK_COST_FACTOR);
+    const delay2 = Math.max(WRITEBACK_MS, this.writeBackCost * WRITEBACK_COST_FACTOR);
     this.writeBack = setTimeout(() => {
       this.writeBack = void 0;
       this.serial(() => this.flush()).catch(() => {
         this.failed = true;
       });
-    }, delay);
+    }, delay2);
   }
   ensure(need2) {
     const cur = this.data ?? new Uint8Array(0);
@@ -33572,7 +33699,10 @@ var Launcher = class {
         await Promise.all(mine);
       },
       kept: async (tab, items, paths) => {
-        for (const { path, hidden, fid } of items) this.adoptKept(path, hidden, fid, ours);
+        for (const { path, hidden, fid } of items) {
+          if (hidden !== void 0 && sharedKept(hidden)) await this.adoptShared(path, hidden, fid);
+          else this.adoptKept(path, hidden, fid, ours);
+        }
         await open2(tab, paths);
       },
       left: (tab) => {
@@ -33581,6 +33711,33 @@ var Launcher = class {
       }
     };
   }
+  async adoptShared(path, hidden, fid) {
+    const bound3 = [...this.held].map(
+      (holds2) => [holds2, [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)]]
+    );
+    const keeping = bound3.filter(([, ids]) => ids.length > 0);
+    const nodes = [...this.openFiles].filter(
+      (open2) => [path, hidden].some((at) => open2.holdsAt(at))
+    );
+    const refs = keeping.length + nodes.length;
+    if (refs === 0) {
+      this.held.doubt([path]);
+      return;
+    }
+    const file = await this.unlinked.sharedFile(hidden, refs);
+    if (!await this.rootFs.lstat(hidden).then(
+      () => true,
+      () => false
+    )) {
+      for (let i = 0; i < refs; i++) file.release();
+      this.held.doubt([path]);
+      return;
+    }
+    const kept = nodes.filter((open2) => open2.keepBound([hidden, path], fid, file)).length;
+    for (let i = kept; i < nodes.length; i++) file.release();
+    for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
+    void this.rootFs.announceHolds?.([], [path, hidden], false);
+  }
   adoptKept(path, hidden, fid, ours) {
     if (hidden === void 0 || !ours(hidden)) {
       this.held.doubt([path]);
@@ -33723,7 +33880,6 @@ var Launcher = class {
   moved(from, to, source) {
     this.renameLog.add(from, to);
     for (const holds2 of this.held) holds2.renamed(from, to);
-    if (this.mounts.locate(to) === void 0) this.rootFs.rehold?.(from, to);
     if (source) return;
     for (const nodes of this.openFiles) nodes.renamed(from, to);
     this.watchers.moved(from, to);