@ai-ecoverse/slicc-kernel 1.142.3 → 1.143.1

package/README.md

@@ -406,6 +406,7 @@ The module's default export (or its `main` export) is called with a context and
   - **Only the named descriptors reach the child.** Others the program holds, the other end of a pair included, don't, and a grandchild gets fd 3 only if the child names it again.
   - **The parent's copy:** the program keeps `f` and closes it itself when it no longer needs it, so the child sees end of file once it's the only one left.
   - **Why a `Record`:** it can't name a child fd twice, and it reads like Node's `stdio` index, so it's this rather than a list of `{ fd, from }`.
+- `asyncContext` (the Node entry only; absent in a browser, so a runtime feature-detects it; #1350, slicc-jsh#375) is `{ run(store, fn, ...args), getStore(), enterWith(store) }`, backed by one host `AsyncLocalStorage` the process worker makes for each program, since a program can't import `node:async_hooks` and the realm has no promise hooks of its own. A store follows the program's native `await` continuations and promise jobs, as an `AsyncLocalStorage` does in Node, so Next.js, OpenTelemetry and request-context loggers keep their context. Each process and each thread has its own. Only these three frozen functions on a frozen null-prototype object reach the program: they hold the host storage in a closure, `run` calls the program's function with its own arguments, and nothing they return or expose is a host object.
 - `memory()`, synchronous and without a kernel call, measures the calling isolate: each `thread` answers for its own (#1240, slicc-jsh#397). It returns a fresh plain object of numbers in bytes, each field only where it's measured: `heapUsed`, `heapTotal`, `heapLimit` (V8's heap size limit), `external` and `arrayBuffers`. On the Node entry they come from V8's heap statistics and Node's memory usage, through functions the worker captured before its lockdown, so nothing reachable from the program leads back to `process` or `v8`; there is no `rss`, which is the whole host's. In a browser `memory()` answers `{}` for now.
 - **`thread`, kernel threads of the same process** ([#1094](https://github.com/ai-ecoverse/slicc-kernel/issues/1094)), the base for Node's `worker_threads` (tinypool, piscina, vitest's and jest's thread pools, eslint's concurrency). `thread.spawn({ data, transfer })` resolves with `{ tid, port, exited, terminate() }`.
   - **What a thread is:** a new process worker in the **same process**. It has the same pid, descriptor table, cwd, umask, credentials and lockdown, and a sync lane of its own, so `sync` calls in one thread don't hold another.

package/dist/kernel-worker.js

@@ -1279,6 +1279,7 @@ var escapeRoot = (name2) => name2.replace(/[%:]/g, (c) => `%${c.charCodeAt(0).to
 var LEGACY_RENAME_LOCK = /^slicc-rename:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var PAIRED = /* @__PURE__ */ new Set(["rename", "link", "copyFile"]);
 var LISTINGS = /* @__PURE__ */ new Set(["readdir", "readdirStat"]);
+var REMOVALS = /* @__PURE__ */ new Set(["rm", "rename"]);
 var RETRY = /* @__PURE__ */ Symbol("retry");
 var ACK_SAMPLES = 4096;
 var INTENT_POLL_MS = 5;
@@ -2757,10 +2758,11 @@ var OpfsFs = class {
     const running = [...this.inflight];
     const reached = await Promise.all(
       running.map(async (op) => {
-        if (op.paths.some((at) => touches(at, trees))) return true;
+        const near = (at) => touches(at, trees, true, op.removing === true);
+        if (op.paths.some(near)) return true;
         for (const at of op.paths) {
           const forms = await this.resolvedForms(at);
-          if (forms.some((form) => touches(form, trees))) return true;
+          if (forms.some(near)) return true;
         }
         return false;
       })
@@ -2777,10 +2779,10 @@ var OpfsFs = class {
       })
     );
   }
-  peerAt(at, listing) {
+  peerAt(at, listing, removing = false) {
     for (const move of this.peerMoves.values()) {
       if (this.ownLocks.has(move.lock)) continue;
-      if (touches(at, move.trees, listing)) return move;
+      if (touches(at, move.trees, listing, removing)) return move;
     }
     return void 0;
   }
@@ -2815,11 +2817,11 @@ var OpfsFs = class {
     this.peerWaits.set(move.lock, wait2);
     return wait2;
   }
-  async peerSettled(at, listing) {
+  async peerSettled(at, listing, removing) {
     await this.lookForRenames();
     for (let reals; ; ) {
       const forms = [at, ...reals ?? []];
-      const move = forms.map((form) => this.peerAt(form, listing)).find(Boolean);
+      const move = forms.map((form) => this.peerAt(form, listing, removing)).find(Boolean);
       if (move) {
         this.peerWaited++;
         await this.peerMoved(move);
@@ -2857,13 +2859,14 @@ var OpfsFs = class {
   async peerOp(name2, args, inner) {
     const paths = (name2 === "symlink" ? args.slice(1, 2) : PAIRED.has(name2) ? args.slice(0, 2) : args.slice(0, 1)).filter((path) => typeof path === "string").map(normalizePath);
     const listing = LISTINGS.has(name2);
+    const removing = REMOVALS.has(name2);
     const checked = [...paths];
     while (this.amongPeers()) {
       checked.length = 0;
-      for (const at of paths) checked.push(...await this.peerSettled(at, listing));
-      if (!checked.some((at) => this.peerAt(at, listing))) break;
+      for (const at of paths) checked.push(...await this.peerSettled(at, listing, removing));
+      if (!checked.some((at) => this.peerAt(at, listing, removing))) break;
     }
-    const busy = { paths: checked, release: () => void 0 };
+    const busy = { paths: checked, removing, release: () => void 0 };
     const done5 = () => {
       this.inflight.delete(busy);
       busy.waiting?.resolve();
@@ -3288,9 +3291,9 @@ var OpfsFs = class {
 function nothing() {
   return void 0;
 }
-function touches(at, trees, listing = true) {
+function touches(at, trees, listing = true, removing = false) {
   return trees.some(
-    ([from, to]) => within2(at, from) || within2(at, to) || listing && (at === parentOf3(from) || at === parentOf3(to))
+    ([from, to]) => within2(at, from) || within2(at, to) || listing && (at === parentOf3(from) || at === parentOf3(to)) || removing && (at === "/" || within2(from, at) || within2(to, at))
   );
 }
 function byIntent(a, b) {
@@ -7595,7 +7598,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.142.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.143.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
@@ -13577,7 +13580,7 @@ async function guardAndResolve(entry, path, req) {
     entry: { ...entry, fs: noLinks }
   };
 }
-var REMOVALS = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm"]);
+var REMOVALS2 = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm"]);
 var CREATIONS = /* @__PURE__ */ new Set([
   "write",
   "mkdir",
@@ -13623,7 +13626,7 @@ async function dispatchPath(entry, req) {
   const { fs, cwd } = entry;
   try {
     const path = fs.resolvePath(cwd, req.path);
-    const device = REMOVALS.has(req.op) ? devRemoval(path, entry.cred?.()) : void 0;
+    const device = REMOVALS2.has(req.op) ? devRemoval(path, entry.cred?.()) : void 0;
     if (device) return { ok: false, errno: device, message: `${path}: a device entry stays` };
     const made2 = await newDevName(entry, path, req);
     if (made2) return made2;