@ai-ecoverse/slicc-kernel 1.165.2 → 1.166.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`, and `new Function` or `eval` code named by `//# sourceURL`, #1632), `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), `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

@@ -8464,7 +8464,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.165.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.166.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
@@ -24325,6 +24325,7 @@ function within8(path, root) {
   return path === root || path.startsWith(root.endsWith("/") ? root : `${root}/`);
 }
 var VfsNode = class {
+  fid;
   data;
   ranged;
   pin;
@@ -24632,6 +24633,7 @@ var VfsNodes = class {
   keepsOnDisk = false;
   changed;
   movedAway;
+  opened;
   dirtied;
   fs;
   entries;
@@ -24791,6 +24793,7 @@ var VfsNodes = class {
     node.ino ??= ino;
     node.opens++;
     if (writable2) node.writers++;
+    if (node.opens === 1) this.opened?.(node);
     return node;
   }
   adopt(path, contents2, dirty, writable2 = false, id2) {
@@ -24802,6 +24805,7 @@ var VfsNodes = class {
     }
     node.opens++;
     if (writable2) node.writers++;
+    if (node.opens === 1) this.opened?.(node);
     return node;
   }
   holds(prefix) {
@@ -24828,6 +24832,32 @@ var VfsNodes = class {
   held() {
     return this.byPath.keys();
   }
+  heldIds() {
+    const out = [];
+    for (const [path, node] of this.byPath) if (!this.kept.has(node)) out.push([path, node.fid]);
+    return out;
+  }
+  holdsAt(path) {
+    return this.byPath.has(path);
+  }
+  async bindIds(id2) {
+    for (const [path, node] of [...this.byPath]) {
+      if (node.fid !== void 0 || this.kept.has(node)) continue;
+      node.fid = await id2(path)?.catch(() => void 0);
+    }
+  }
+  keepBound(paths, fid, file) {
+    for (const at of paths) {
+      const node = this.byPath.get(at);
+      if (!node || this.kept.has(node) || node.fid !== fid) continue;
+      this.byPath.delete(at);
+      node.renamedTo(file.hidden);
+      this.byPath.set(file.hidden, node);
+      this.kept.set(node, file);
+      return true;
+    }
+    return false;
+  }
   owns() {
     return false;
   }
@@ -31459,7 +31489,7 @@ var Launcher = class {
     enableCdp(this.net, this.cdp);
     this.facades.enable(this.net);
     const fs = this.commandFs(this.base);
-    this.nodes = new VfsNodes(fs, (path) => this.released(path));
+    this.nodes = this.openNodes(fs);
     this.nodes.keepsOnDisk = true;
     this.openFiles.add(this.nodes);
     options.fs.onPeer?.(() => this.flushOpen());
@@ -33020,8 +33050,8 @@ var Launcher = class {
     const at = normalizePath(path);
     this.unlinked.closed(at);
     this.writers?.unlinked.closed(at);
-    if (![...this.held].some((holds2) => holds2.holding(at)))
-      void this.rootFs.announceHolds?.([], [at], false);
+    const holding = [...this.held].some((holds2) => holds2.holding(at)) || [...this.openFiles].some((open3) => open3.holdsAt(at));
+    if (!holding) void this.rootFs.announceHolds?.([], [at], false);
     const open2 = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open2) void this.mounts.commit(at).catch(() => void 0);
   }
@@ -33547,13 +33577,34 @@ var Launcher = class {
       (holds2) => [holds2, [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)]]
     );
     const keeping = bound3.filter(([, ids]) => ids.length > 0);
-    const file = this.unlinked.adopt(hidden, Math.max(keeping.length, 1));
-    if (keeping.length === 0) file.release();
+    const nodes = [...this.openFiles].filter(
+      (open2) => [path, hidden].some((at) => open2.holdsAt(at))
+    );
+    const file = this.unlinked.adopt(hidden, Math.max(keeping.length + nodes.length, 1));
+    const kept = nodes.filter((open2) => open2.keepBound([hidden, path], fid, file)).length;
+    for (let i = kept; i < nodes.length; i++) file.release();
+    if (keeping.length === 0 && nodes.length === 0) file.release();
     for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
     void this.rootFs.announceHolds?.([], [path, hidden], false);
   }
+  openNodes(fs, entries) {
+    const nodes = new VfsNodes(fs, (path) => this.released(path), entries);
+    nodes.opened = (node) => this.nodeOpened(node);
+    return nodes;
+  }
+  nodeOpened(node) {
+    const path = node.path;
+    if (this.locks.shared?.() !== true || this.mounts.locate(path) !== void 0) return;
+    void (async () => {
+      node.fid ??= await this.rootFileId(path)?.catch(() => void 0);
+      if (node.opens > 0) await this.rootFs.announceHolds?.([[node.path, node.fid]], [], false);
+    })();
+  }
   announceHeld() {
-    const held = this.held.heldIds().filter(([path]) => this.mounts.locate(path) === void 0);
+    const nodes = [...this.openFiles].flatMap((open2) => open2.heldIds());
+    const held = [...this.held.heldIds(), ...nodes].filter(
+      ([path]) => this.mounts.locate(path) === void 0 && !path.startsWith(`/${UNLINKED_DIR}/`)
+    );
     return held.length === 0 ? void 0 : this.rootFs.announceHolds?.(held, [], false);
   }
   rootFileId(path) {
@@ -33567,7 +33618,9 @@ var Launcher = class {
       this.changes.flush();
       this.changes.foreign(crowded);
       if (crowded) {
-        void this.held?.bindIds((path) => this.rootFileId(path)).then(() => this.announceHeld());
+        void this.held.bindIds((path) => this.rootFileId(path)).then(
+          () => Promise.all([...this.openFiles].map((open2) => open2.bindIds((p) => this.rootFileId(p))))
+        ).then(() => this.announceHeld());
         for (const nodes of this.openFiles) nodes.shared();
       }
     });
@@ -33592,7 +33645,7 @@ var Launcher = class {
   writerStack() {
     const mounted = this.mounts.wrap(this.unguardedRoot);
     const fs = this.commandFs(this.rooted(mounted));
-    const nodes = new VfsNodes(fs, (path) => this.released(path), this.nodes.entries);
+    const nodes = this.openNodes(fs, this.nodes.entries);
     nodes.keepsOnDisk = true;
     this.openFiles.add(nodes);
     const unlinked = new UnlinkedKeeper(
@@ -33657,6 +33710,7 @@ 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);