@ai-ecoverse/slicc-kernel 1.164.4 → 1.164.5

package/README.md

@@ -424,10 +424,10 @@ 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 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`.
+  - **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.
   - **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`. 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.
   - **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.
   - **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

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

@@ -1498,6 +1498,7 @@ var hashOf = proto.getScriptHash;
 var isEval = proto.isEval;
 var originOf = proto.getEvalOrigin;
 var lineOf = proto.getLineNumber;
+var nameOf = proto.getScriptNameOrSourceURL;
 var ownNames = /* @__PURE__ */ new Set([
   apply(fileOf, self, []),
   apply(proto.getScriptNameOrSourceURL, self, [])
@@ -1531,12 +1532,22 @@ function rootOrigin(origin) {
   }
   return apply(slice, at, [0, end]);
 }
+function evalAt(origin) {
+  return apply(startsWith, origin, ["eval at "]) === true;
+}
+function scriptOf(site) {
+  if (apply(isEval, site, []) !== true) return apply(fileOf, site, []);
+  const origin = apply(originOf, site, []);
+  if (typeof origin !== "string" || evalAt(origin)) return void 0;
+  return apply(nameOf, site, []);
+}
 function keptFrame(site) {
   const hash = apply(hashOf, site, []);
   if (hash === ownHash) return false;
   if (apply(isEval, site, []) === true) {
     const origin = apply(originOf, site, []);
-    return typeof origin === "string" && programName(rootOrigin(origin));
+    if (typeof origin !== "string") return false;
+    return !evalAt(origin) || programName(rootOrigin(origin));
   }
   const file = apply(fileOf, site, []);
   if (typeof file !== "string") return true;
@@ -1596,7 +1607,7 @@ 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;
-  const file = apply(isEval, site, []) === true ? void 0 : apply(fileOf, site, []);
+  const file = scriptOf(site);
   if (at.scriptResourceName !== file || apply(lineOf, site, []) !== at.lineNumber) return void 0;
   const out = blank(null);
   out.sourceLine = at.sourceLine;