@ai-ecoverse/slicc-kernel 1.164.5 → 1.165.1

package/README.md

@@ -426,12 +426,14 @@ The module's default export (or its `main` export) is called with a context and
   - **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`.
   - **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.
   - **How it works:** process workers start with `--expose-internals`, so the worker can install the formatter before the lockdown. Host flags a worker refuses are dropped. If the worker still can't start with the flag, the method is absent. Every `internal/*` and `node:internal/*` module stays refused to programs, as do `node:module` and `node:worker_threads`.
 - `sync.errorSource(error)` (#1610, slicc-jsh#1082) is Node only, so check it with `typeof ctx.sync.errorSource === 'function'`. It gives `{ sourceLine, lineNumber, startColumn }` (null-prototype and frozen), the source line Node prints over an uncaught error, for an error in the program's own code. The kernel takes V8's position while the stack is formatted (#1633), so this also works after `.stack` was read, and for a call of a non-function, a ReferenceError, a TDZ error or a thrown `Error`. For code named by `//# sourceURL` it matches on that name (#1632). That includes a direct `eval` of a value that isn't a string literal (`const s = 'null.d'; eval(s)` gives `null.d` and line 1) and a `sync.runScript` script.
   - **Only the program's own code:** it answers only when the error's top frame is a program frame and the position V8 kept is in that same script and line.
-  - **`undefined` cases:** kernel-made errors; values that aren't native errors; a script that borrows the kernel worker's name; and an error an own `Error.prepareStackTrace` formats.
+  - **`undefined` cases:** kernel-made errors; values that aren't native errors; and a script that borrows the kernel worker's name. An error an own `Error.prepareStackTrace` formats answers too (#1631).
   - **How it works:** it reads V8's message through Node's internal errors binding, which the worker loads at start-up through the same `--expose-internals` as `setStackFormatter`. It prints no warning and needs no inspector.
-- **Kernel frames in a program's stacks** (#1583): on the Node entry, the process worker's bundle names itself `slicc-kernel:/node-process-worker.js` (a `sourceURL`), so the kernel's own frames in an error a program sees (its own errors, a failed `ctx` call, `runScript`) show that name and not the host directory the kernel is installed in. The same holds in `CallSite.toString()` and `getScriptNameOrSourceURL()`, which a program's own `Error.prepareStackTrace` gets; `getFileName()` still returns the bundle's file URL. Line and column numbers are unchanged, so they still point into `dist/node-process-worker.js`. Don't run an embedder with `--enable-source-maps` if program-visible paths matter: Node then maps the kernel's frames back to the absolute paths of its sources. In a browser the frames keep the bundle's URL, because Chrome ignores `sourceURL` in a module worker loaded by URL.
+- **Kernel frames in a program's stacks** (#1583): on the Node entry, the process worker's bundle names itself `slicc-kernel:/node-process-worker.js` (a `sourceURL`), so the kernel's own frames in an error a program sees (its own errors, a failed `ctx` call, `runScript`) show that name and not the host directory the kernel is installed in. The stack formatter, and an own `Error.prepareStackTrace` called through `{ own: true }`, get no kernel CallSites at all (#1612, #1631). Line and column numbers are unchanged, so they still point into `dist/node-process-worker.js`. Don't run an embedder with `--enable-source-maps` if program-visible paths matter: Node then maps the kernel's frames back to the absolute paths of its sources. In a browser the frames keep the bundle's URL, because Chrome ignores `sourceURL` in a module worker loaded by URL.
 - `module` (#1598, slicc-jsh#566) is a frozen `{ path }` with the command module's own path in the kernel's file system (e.g. `/usr/lib/node_modules/jsh/dist/jsh.mjs`), so a program can read its package's other files through `ctx.fs` on first use. It's the path the kernel found the package under, with symlinks left as they are (a pnpm-style `node_modules/<name>` link stays in it), and reads the same files through `ctx.fs`. It's a kernel path, never a host one, and a thread gets the same. It's absent for the kernel's built-in programs (`sudo`, `crontab`) and for a program run from inline source with no file.
 - `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`, `arrayBuffers` and `rss`. 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`. `rss` is the host process's resident set size, as a Node worker thread reports it in `process.memoryUsage().rss`: it isn't per process, but shared by every process and thread of the kernel, and by any other kernel in that host process (#1563, slicc-jsh#539). In a browser `memory()` answers `{}` for now, with no `rss`.
 - **`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() }`.

package/dist/kernel-worker.js

@@ -8440,7 +8440,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.164.5" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.165.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

package/dist/node-driver-worker.js

@@ -564,23 +564,23 @@ function errorWithCode(message) {
 }
 function dialStream(port, onClose) {
   let closed = false;
-  let reader;
+  let reader2;
   const acks = [];
   const readable = new ReadableStream({
     start(controller) {
-      reader = controller;
+      reader2 = controller;
     },
     pull() {
       if (!closed) port.postMessage({ more: true });
     },
     cancel() {
-      reader = void 0;
+      reader2 = void 0;
       close();
     }
   });
   const finish = (fail2) => {
-    const controller = reader;
-    reader = void 0;
+    const controller = reader2;
+    reader2 = void 0;
     for (const ack of acks.splice(0)) {
       if (fail2) ack.reject(fail2);
       else ack.resolve();
@@ -601,7 +601,7 @@ function dialStream(port, onClose) {
     finish();
   }
   port.addEventListener("message", ({ data }) => {
-    if (data instanceof Uint8Array) reader?.enqueue(data);
+    if (data instanceof Uint8Array) reader2?.enqueue(data);
     else if ("ack" in data) acks.shift()?.resolve();
     else if ("end" in data) finish();
     else finish(errorWithCode(data.error));
@@ -636,8 +636,8 @@ var latin1 = new TextDecoder("latin1");
 var ByteSource = class {
   buffered = new Uint8Array(0);
   reader;
-  constructor(reader) {
-    this.reader = reader;
+  constructor(reader2) {
+    this.reader = reader2;
   }
   async more() {
     const { done, value } = await this.reader.read();
@@ -1423,6 +1423,14 @@ import { types as types2 } from "node:util";
 // src/node-stack.ts
 import { createRequire } from "node:module";
 import { types } from "node:util";
+
+// src/process/raw-stack.ts
+var reader = (error) => error.stack;
+function setRawStack(read) {
+  reader = read;
+}
+
+// src/node-stack.ts
 function quietly(target, run) {
   const emit = target.emitWarning;
   target.emitWarning = () => {
@@ -1433,18 +1441,20 @@ function quietly(target, run) {
     target.emitWarning = emit;
   }
 }
-function positionsOf(load) {
+function bindingOf(load) {
   try {
     const { internalBinding } = quietly(
       process,
       () => load("internal/test/binding")
     );
-    const get = internalBinding("errors").getErrorSourcePositions;
-    return typeof get === "function" ? get : void 0;
+    return internalBinding("errors");
   } catch {
-    return void 0;
+    return {};
   }
 }
+function fn(value) {
+  return typeof value === "function" ? value : void 0;
+}
 var apply = Reflect.apply;
 var push = Array.prototype.push;
 var startsWith = String.prototype.startsWith;
@@ -1455,6 +1465,9 @@ var setHas = Set.prototype.has;
 var setAdd = Set.prototype.add;
 var mapGet = WeakMap.prototype.get;
 var mapSet = WeakMap.prototype.set;
+var mapHas = WeakMap.prototype.has;
+var mapDelete = WeakMap.prototype.delete;
+var MainError = Error;
 var isNativeError = types.isNativeError;
 var freeze = Object.freeze;
 var blank = Object.create;
@@ -1467,11 +1480,17 @@ function internals() {
     if (process.sourceMapsEnabled) {
       fallback = load("internal/source_map/prepare_stack_trace").prepareStackTraceWithSourceMaps;
     }
-    if (typeof set !== "function" || typeof fallback !== "function") return void 0;
+    const overrides = errors.overrideStackTrace;
+    const usable = typeof set === "function" && typeof fallback === "function";
+    if (!usable || !types.isWeakMap(overrides)) return void 0;
+    const binding = bindingOf(load);
     return {
       setInternalPrepareStackTrace: set,
       fallback,
-      positions: positionsOf(load)
+      positions: fn(binding.getErrorSourcePositions),
+      setCallback: fn(binding.setPrepareStackTraceCallback),
+      overrides,
+      nodeDefault: errors.ErrorPrepareStackTrace
     };
   } catch {
     return void 0;
@@ -1563,6 +1582,7 @@ function keptFrames(trace) {
   return out;
 }
 var formatter = null;
+var withOwn = false;
 var formatting = false;
 var seen = /* @__PURE__ */ new WeakMap();
 function positionsAt(positions, error, site) {
@@ -1573,17 +1593,20 @@ function positionsAt(positions, error, site) {
     return void 0;
   }
 }
+function record(positions, error, trace) {
+  if (typeof error === "object" && error !== null && trace.length > 0) {
+    const site = trace[0];
+    apply(mapSet, seen, [error, { site, at: positionsAt(positions, error, site) }]);
+  }
+}
 function stackDispatcher(fallback, positions) {
   return (error, trace) => {
-    if (typeof error === "object" && error !== null && trace.length > 0) {
-      const site = trace[0];
-      apply(mapSet, seen, [error, { site, at: positionsAt(positions, error, site) }]);
-    }
-    const fn = formatter;
-    if (fn === null || formatting) return apply(fallback, void 0, [error, trace]);
+    record(positions, error, trace);
+    const fn2 = formatter;
+    if (fn2 === null || formatting) return apply(fallback, void 0, [error, trace]);
     formatting = true;
     try {
-      const out = apply(fn, void 0, [error, keptFrames(trace)]);
+      const out = apply(fn2, void 0, [error, keptFrames(trace)]);
       if (typeof out === "string") return out;
     } catch {
     } finally {
@@ -1592,8 +1615,70 @@ function stackDispatcher(fallback, positions) {
     return apply(fallback, void 0, [error, trace]);
   };
 }
+function errorOf2(realm) {
+  return realm === null || realm === void 0 ? void 0 : realm.Error;
+}
+function prepareOf(holder) {
+  return holder === null || holder === void 0 ? void 0 : holder.prepareStackTrace;
+}
+function ownPrepare(realm, nodeDefault) {
+  let self2;
+  if (typeof prepareOf(errorOf2(realm)) === "function") self2 = errorOf2(realm);
+  else if (typeof prepareOf(MainError) === "function") self2 = MainError;
+  else return void 0;
+  const value = prepareOf(self2);
+  return value === nodeDefault ? void 0 : { fn: value, self: self2 };
+}
+function calling(run) {
+  formatting = true;
+  try {
+    return run();
+  } finally {
+    formatting = false;
+  }
+}
+function kernelCallback(internal, dispatch2) {
+  const { fallback, positions, overrides, nodeDefault } = internal;
+  return (realm, error, trace) => {
+    if (apply(mapHas, overrides, [error]) === true) {
+      const override = apply(mapGet, overrides, [error]);
+      apply(mapDelete, overrides, [error]);
+      return apply(override, void 0, [error, trace]);
+    }
+    const own = ownPrepare(realm, nodeDefault);
+    if (formatting) return apply(fallback, void 0, [error, keptFrames(trace)]);
+    const fmt = formatter;
+    if (fmt !== null && withOwn) {
+      record(positions, error, trace);
+      return calling(() => apply(fmt, void 0, [error, keptFrames(trace), own?.fn]));
+    }
+    if (own === void 0) return apply(dispatch2, void 0, [error, trace]);
+    record(positions, error, trace);
+    return apply(own.fn, own.self, [error, trace]);
+  };
+}
+function rawReader(overrides, fallback) {
+  return (error) => {
+    apply(mapSet, overrides, [
+      error,
+      (e, trace) => apply(fallback, void 0, [e, trace])
+    ]);
+    try {
+      return error.stack;
+    } finally {
+      apply(mapDelete, overrides, [error]);
+    }
+  };
+}
 var found = internals();
-if (found) found.setInternalPrepareStackTrace(stackDispatcher(found.fallback, found.positions));
+if (found) {
+  const dispatch2 = stackDispatcher(found.fallback, found.positions);
+  found.setInternalPrepareStackTrace(dispatch2);
+  if (found.setCallback) {
+    found.setCallback(kernelCallback(found, dispatch2));
+    setRawStack(rawReader(found.overrides, found.fallback));
+  }
+}
 function errorSourceOf(error) {
   if (typeof error !== "object" || error === null || !isNativeError(error)) return void 0;
   try {