@ai-ecoverse/slicc-kernel 1.166.0 → 1.166.1

package/README.md

@@ -429,7 +429,7 @@ The module's default export (or its `main` export) is called with a context and
   - **`{ 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.
+- `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. For a `SyntaxError` from the native `JSON.parse`, called directly by the program's own code, it gives the parsed text's line (#1649); a `JSON.parse` called from Node's or the kernel's code gives `undefined`.
   - **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; 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.

package/dist/kernel-worker.js

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

@@ -1518,6 +1518,10 @@ var isEval = proto.isEval;
 var originOf = proto.getEvalOrigin;
 var lineOf = proto.getLineNumber;
 var nameOf = proto.getScriptNameOrSourceURL;
+var functionOf = proto.getFunctionName;
+var typeOf = proto.getTypeName;
+var syntaxProto = SyntaxError.prototype;
+var protoOf = Object.getPrototypeOf;
 var ownNames = /* @__PURE__ */ new Set([
   apply(fileOf, self, []),
   apply(proto.getScriptNameOrSourceURL, self, [])
@@ -1611,7 +1615,8 @@ function record(positions, error, trace) {
   if (typeof error === "object" && error !== null && trace.length > 0) {
     noteSourceUrls(trace);
     const site = trace[0];
-    apply(mapSet, seen, [error, { site, at: positionsAt(positions, error, site) }]);
+    const next = trace[1];
+    apply(mapSet, seen, [error, { site, next, at: positionsAt(positions, error, site) }]);
   }
 }
 function stackDispatcher(fallback, positions) {
@@ -1694,6 +1699,18 @@ if (found) {
     setRawStack(rawReader(found.overrides, found.fallback));
   }
 }
+function programFrame(site) {
+  if (site === void 0 || !keptFrame(site)) return false;
+  if (apply(isEval, site, []) === true) return true;
+  const file = apply(fileOf, site, []);
+  return typeof file === "string" && apply(startsWith, file, ["node:"]) !== true;
+}
+function jsonParseSite(error, got) {
+  const { site, next } = got;
+  if (protoOf(error) !== syntaxProto || apply(fileOf, site, []) !== null) return false;
+  if (apply(functionOf, site, []) !== "parse" || apply(typeOf, site, []) !== "JSON") return false;
+  return programFrame(next);
+}
 function errorSourceOf(error) {
   if (typeof error !== "object" || error === null || !isNativeError(error)) return void 0;
   try {
@@ -1707,8 +1724,13 @@ function errorSourceOf(error) {
   if (!at || typeof at.sourceLine !== "string" || typeof at.lineNumber !== "number")
     return void 0;
   if (apply(setHas, ownNames, [at.scriptResourceName]) === true) return void 0;
+  if (jsonParseSite(error, got))
+    return at.scriptResourceName === void 0 ? answer(at) : void 0;
   const file = scriptOf(site);
   if (at.scriptResourceName !== file || apply(lineOf, site, []) !== at.lineNumber) return void 0;
+  return answer(at);
+}
+function answer(at) {
   const out = blank(null);
   out.sourceLine = at.sourceLine;
   out.lineNumber = at.lineNumber;