@ai-ecoverse/slicc-kernel 1.163.1 → 1.164.0

package/README.md

@@ -427,6 +427,10 @@ The module's default export (or its `main` export) is called with a context and
   - **What `fn` gets:** a fresh array of V8 CallSites holding only the program's own frames (its modules, `data:` imports, `sync.runScript` scripts and code they `eval`), `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.
   - **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 V8 raised in the program's own code. 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; an error V8 kept no position for (a `new Error()` the program constructs); a script that borrows the kernel worker's name; and an error an own `Error.prepareStackTrace` formats.
+  - **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.
 - `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`.

package/dist/kernel-worker.js

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

package/dist/node-driver-worker.js

@@ -1418,10 +1418,33 @@ async function hostDriver(start, load) {
 
 // src/node-lockdown.ts
 import { isBuiltin, registerHooks } from "node:module";
-import { types } from "node:util";
+import { types as types2 } from "node:util";
 
 // src/node-stack.ts
 import { createRequire } from "node:module";
+import { types } from "node:util";
+function quietly(target, run) {
+  const emit = target.emitWarning;
+  target.emitWarning = () => {
+  };
+  try {
+    return run();
+  } finally {
+    target.emitWarning = emit;
+  }
+}
+function positionsOf(load) {
+  try {
+    const { internalBinding } = quietly(
+      process,
+      () => load("internal/test/binding")
+    );
+    const get = internalBinding("errors").getErrorSourcePositions;
+    return typeof get === "function" ? get : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var apply = Reflect.apply;
 var push = Array.prototype.push;
 var startsWith = String.prototype.startsWith;
@@ -1430,6 +1453,9 @@ var lastIndexOf = String.prototype.lastIndexOf;
 var indexOf2 = String.prototype.indexOf;
 var setHas = Set.prototype.has;
 var setAdd = Set.prototype.add;
+var mapGet = WeakMap.prototype.get;
+var mapSet = WeakMap.prototype.set;
+var isNativeError = types.isNativeError;
 function internals() {
   try {
     const load = createRequire(import.meta.url);
@@ -1442,7 +1468,8 @@ function internals() {
     if (typeof set !== "function" || typeof fallback !== "function") return void 0;
     return {
       setInternalPrepareStackTrace: set,
-      fallback
+      fallback,
+      positions: positionsOf(load)
     };
   } catch {
     return void 0;
@@ -1468,6 +1495,11 @@ var fileOf = proto.getFileName;
 var hashOf = proto.getScriptHash;
 var isEval = proto.isEval;
 var originOf = proto.getEvalOrigin;
+var lineOf = proto.getLineNumber;
+var ownNames = /* @__PURE__ */ new Set([
+  apply(fileOf, self, []),
+  apply(proto.getScriptNameOrSourceURL, self, [])
+]);
 var ownHash = apply(hashOf, self, []);
 var programHashes = /* @__PURE__ */ new Set();
 var programNames = /* @__PURE__ */ new Set();
@@ -1519,8 +1551,12 @@ function keptFrames(trace) {
 }
 var formatter = null;
 var formatting = false;
+var tops = /* @__PURE__ */ new WeakMap();
 function stackDispatcher(fallback) {
   return (error, trace) => {
+    if (typeof error === "object" && error !== null && trace.length > 0) {
+      apply(mapSet, tops, [error, trace[0]]);
+    }
     const fn = formatter;
     if (fn === null || formatting) return apply(fallback, void 0, [error, trace]);
     formatting = true;
@@ -1536,6 +1572,7 @@ function stackDispatcher(fallback) {
 }
 var found = internals();
 if (found) found.setInternalPrepareStackTrace(stackDispatcher(found.fallback));
+var positions = found?.positions;
 
 // src/process/js/lockdown.ts
 var BLOCKED_GLOBALS = [
@@ -1694,7 +1731,7 @@ function nodeLockdown(scope = globalThis) {
   vacate(scope, NODE_SLOTS);
   refuseModules();
 }
-var isPromise = types.isPromise;
+var isPromise = types2.isPromise;
 var hasOwn = Object.hasOwn;
 var endsWith = String.prototype.endsWith;
 var sliceOf = String.prototype.slice;