@ai-ecoverse/slicc-kernel 1.166.4 → 1.167.0

package/README.md

@@ -424,7 +424,7 @@ The module's default export (or its `main` export) is called with a context and
 - `sync.promiseState(promise)` (#1531, slicc-jsh#974) tells a native promise's state synchronously, as Node's `util.inspect` does: `{ state: 'pending' | 'fulfilled' | 'rejected', value }`. `value` is the very fulfillment value or rejection reason (`undefined` while pending), and probing doesn't handle a rejection. On the Node entry it reads the promise through an inspector session the process worker opens on first use, one per process and per thread; the probe runs no program code. Anything that isn't a native promise (a thenable, a proxy) is a `TypeError`. It answers `undefined` in a browser, where a worker has no inspector, on a Node built without one, once a program has changed `Object.prototype` or put a `toJSON` on a built-in prototype, and when the global object can't take a new property (`Object.preventExtensions(globalThis)`, or a frozen global).
 - `sync.setStackFormatter(fn | null)` (#1612, slicc-jsh#1091) is Node only, so check it with `typeof ctx.sync.setStackFormatter === 'function'`. It returns the previous formatter, and `null` removes it.
   - **When `fn` runs:** it formats an error's `.stack` the way V8's prepare-stack-trace callback does, as `fn(error, callSites)` returning the string. It runs only when no own `Error.prepareStackTrace` function is set, as in Node, so `Error.prepareStackTrace` stays an ordinary property: after `delete` it's `undefined`, `Object.getPrototypeOf(Error)` stays `Function.prototype`, and an assignment to a frozen subclass throws in strict mode.
-  - **What `fn` gets:** a fresh array of V8 CallSites holding only the program's own frames (its modules, `data:` imports, `sync.runScript` scripts, code they `eval`, `new Function` or `eval` code named by `//# sourceURL`, #1632, and code such a body `eval`s, #1648), `node:` frames and native frames. Kernel frames are dropped by script identity, so a script named like a kernel file doesn't let them through, and so are host files. A program's strict frames give `getFunction()` and `getThis()` as `undefined`.
+  - **What `fn` gets:** a fresh array of V8 CallSites holding only the program's own frames (its modules, `data:` imports, `sync.runScript` scripts, code they `eval`, `new Function` or `eval` code named by `//# sourceURL`, #1632, and code such a body `eval`s, #1648; the kernel remembers the 4096 sourceURL names it saw last, #1658), `node:` frames and native frames. Kernel frames are dropped by script identity, so a script named like a kernel file doesn't let them through, and so are host files. A program's strict frames give `getFunction()` and `getThis()` as `undefined`.
   - **Fallback:** if `fn` throws or returns a non-string, or an error is formatted while `fn` runs, the default stack is used.
   - **`{ own: true }`** (#1631): `setStackFormatter(fn, { own: true })` calls `fn(error, callSites, own)` for every stack. `own` is the program's own `Error.prepareStackTrace` (the realm's `Error`, then the main one, read as Node 26 reads it), or `undefined` when none is set or it's Node's default. `fn`'s result is the stack whatever its type, and a throw propagates out of the `.stack` read, as with Node's own callback.
 - **An own `Error.prepareStackTrace` on the Node entry** (#1631): the process worker replaces Node's stack callback with a copy of Node 26's order. A program's own `Error.prepareStackTrace`, and a host preload's, still gets V8's CallSites as in Node, kernel frames included (named `slicc-kernel:/node-process-worker.js`), with its `Error` as receiver; its result and throws are the stack. To hand it the filtered CallSites instead (no kernel frame, no host path), use `setStackFormatter(fn, { own: true })` and call `own` from `fn`. 1.165.0 filtered by default, which broke runtimes that read their own frames through an own `prepareStackTrace`; the release after it went back to V8's CallSites. Node's own internal overrides still come first with raw frames, and so do the kernel's own diagnostics: a crash report and a WASI trap backtrace still show kernel and wasm frames.

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));
     }
   }
 }
@@ -3623,9 +3627,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 +8468,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.166.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.167.0" : "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 +9419,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 +9769,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 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));
+      }
+    };
   }
-  async undoing(op, peers, sends, heard) {
+  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 +9995,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 +24716,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 +33690,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 +33702,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 +33871,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);