@ai-ecoverse/slicc-kernel 1.159.5 → 1.160.0

package/README.md

@@ -423,6 +423,7 @@ The module's default export (or its `main` export) is called with a context and
 - `sync.runScript(source, { filename })` (#1541, slicc-jsh#977) runs `source` as a classic script in the program's own global scope, synchronously, as Node's `vm.runInThisContext` does: `let`, `const` and `class` land in the global lexical scope, `var` (in strict code too) on the global object, and stack frames are named `filename` (default `[eval]`). On the Node entry it returns `{ value, completion: true }` with the completion value, and an error the script throws is thrown as it is. In a browser, where process workers are module workers with no synchronous classic-script path, it returns `undefined`, so a runtime feature-detects it with `ctx.sync.runScript('1') !== undefined`. A non-string `source` or `filename` is a `TypeError` everywhere. The script sees exactly the globals the program sees, `import()` inside it is refused, and a `var`, function or `let` declaration can't replace a global the program can't assign: a non-configurable one stays as it is, and the only configurable, non-assignable ones (`crypto`, `navigator`) are ones the program can already redefine with `Object.defineProperty`.
 - `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).
 - **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`.
 - **`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() }`.
   - **What a thread is:** a new process worker in the **same process**. It has the same pid, descriptor table, cwd, umask, credentials and lockdown, and a sync lane of its own, so `sync` calls in one thread don't hold another.

package/dist/kernel-worker.js

@@ -8236,7 +8236,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.159.5" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.160.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-process-worker.js

@@ -7352,7 +7352,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.159.5" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.160.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -12461,6 +12461,7 @@ function laneOf(lane, silence = SYNC_FS_REQUEST_TIMEOUT_MS, open = createSyncSab
 }
 function syncOps(kernel, shared) {
   const { infos, handles, resolve: resolve2 } = shared;
+  const clean = () => shared.clean?.() === true;
   const tryDevSync = (abs) => {
     try {
       const resolved2 = physicalPath(
@@ -12516,7 +12517,7 @@ function syncOps(kernel, shared) {
     const abs = resolve2(path);
     if (inDev(abs)) return devSync(kernel, devStat(abs, op === "stat"));
     try {
-      kernel.call({ op: "fd-path-flush", path: abs });
+      if (!clean()) kernel.call({ op: "fd-path-flush", path: abs });
       const s = parseSyncFsStat(kernel.json({ op, path: abs }));
       if (!s) throw new JsCallError("EIO", op);
       return s;
@@ -12593,7 +12594,7 @@ function syncOps(kernel, shared) {
     },
     pipe: () => kernel.json({ op: "fd-pipe" }),
     open: procOpenSync(open, kernel, { resolve: resolve2, pid: shared.pid }),
-    fs: procFsSync(syncPathOps(kernel, resolve2, statOf, open, tryDevSync), kernel, {
+    fs: procFsSync(syncPathOps(kernel, resolve2, statOf, open, tryDevSync, clean), kernel, {
       resolve: resolve2,
       pid: shared.pid
     })
@@ -12670,7 +12671,7 @@ function syncFile(kernel, fd, path, append, forget) {
     }
   };
 }
-function syncPathOps(kernel, resolve2, statOf, open, tryDev) {
+function syncPathOps(kernel, resolve2, statOf, open, tryDev, clean) {
   return {
     stat: (path) => statOf("stat", path),
     lstat: (path) => statOf("lstat", path),
@@ -12719,7 +12720,7 @@ function syncPathOps(kernel, resolve2, statOf, open, tryDev) {
       const abs = resolve2(path);
       if (inDev(abs)) return readWholeSync(open(abs));
       try {
-        kernel.call({ op: "fd-path-flush", path: abs });
+        if (!clean()) kernel.call({ op: "fd-path-flush", path: abs });
         return kernel.bytes({ op: "read", path: abs });
       } catch (err) {
         if (!(err instanceof JsCallError) || err.code !== "ENOENT") throw err;
@@ -15991,9 +15992,9 @@ async function resolveDevAsync(kernel, abs) {
     return void 0;
   }
 }
-async function vfsStat(kernel, abs, op, tryDev) {
+async function vfsStat(kernel, abs, op, tryDev, clean) {
   try {
-    await kernel.call({ op: "fd-path-flush", path: abs });
+    if (!clean()) await kernel.call({ op: "fd-path-flush", path: abs });
     const s = parseSyncFsStat(await kernel.json({ op, path: abs }));
     if (!s) throw new JsCallError("EIO", op);
     return s;
@@ -16178,11 +16179,18 @@ function scriptRunner(run) {
   };
 }
 function hostExtras(o) {
+  const path = o.modulePath;
+  const module = path === void 0 ? {} : { module: capturedObject.freeze({ path }) };
   return {
     memory: () => measured(o.memory),
-    ...o.asyncContext ? { asyncContext: o.asyncContext() } : {}
+    ...o.asyncContext ? { asyncContext: o.asyncContext() } : {},
+    ...module
   };
 }
+function cleanOf(sab) {
+  const changes = sab ? new ChangeView(sab) : void 0;
+  return () => changes?.clean() === true;
+}
 function createContext(o) {
   const { kernel } = o;
   const infos = new capturedMap();
@@ -16192,6 +16200,7 @@ function createContext(o) {
   let held2;
   const resolve2 = (path) => resolvePath(cwdFor(o.cwd, held2, path), path);
   const tryDev = (abs) => resolveDevAsync(kernel, abs);
+  const clean = cleanOf(o.changes);
   let exiting;
   const exit = (code2 = 0) => {
     exiting ??= code2;
@@ -16220,7 +16229,7 @@ function createContext(o) {
   const statOf = async (op, path) => {
     const abs = resolve2(path);
     if (inDev(abs)) return devAsync(kernel, devStat(abs, op === "stat"));
-    return vfsStat(kernel, abs, op, tryDev);
+    return vfsStat(kernel, abs, op, tryDev, clean);
   };
   const devIo = { infos, handles, read: read2, write: writeAll };
   const open = async (path, options = {}, whole = false) => {
@@ -16235,7 +16244,7 @@ function createContext(o) {
       return openDev(kernel, devPath, options, devIo);
     }
   };
-  const fs = procFsAsync(pathOps(kernel, resolve2, statOf, open, tryDev), kernel, {
+  const fs = procFsAsync(pathOps(kernel, resolve2, statOf, open, tryDev, clean), kernel, {
     resolve: resolve2,
     pid: o.pid
   });
@@ -16244,7 +16253,7 @@ function createContext(o) {
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
   held2 = heldOn(o.held, lane, syncKernel);
   const terminal = ttyOps(kernel, syncKernel);
-  const shared = { pid: o.pid, resolve: resolve2, random: random2, infos, handles, closing };
+  const shared = { pid: o.pid, resolve: resolve2, random: random2, infos, handles, closing, clean };
   const wasi = wasiFor({ lane, pid: o.pid, cwd: o.cwd, resolve: resolve2, fs: o.fs, owned: o.owned });
   const sync = {
     kernel: KERNEL_INFO,
@@ -16451,7 +16460,7 @@ async function sendSome(kernel, fd, body, signal) {
     await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
   }
 }
-function pathOps(kernel, resolve2, statOf, open, tryDev) {
+function pathOps(kernel, resolve2, statOf, open, tryDev, clean) {
   return {
     stat: (path) => statOf("stat", path),
     lstat: (path) => statOf("lstat", path),
@@ -16502,7 +16511,7 @@ function pathOps(kernel, resolve2, statOf, open, tryDev) {
       const abs = resolve2(path);
       if (inDev(abs)) return readWhole(await open(abs));
       try {
-        await kernel.call({ op: "fd-path-flush", path: abs });
+        if (!clean()) await kernel.call({ op: "fd-path-flush", path: abs });
         return await kernel.bytes({ op: "read", path: abs });
       } catch (err) {
         if (!(err instanceof JsCallError) || err.code !== "ENOENT") throw err;
@@ -16531,6 +16540,7 @@ var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
     init_captured_globals();
+    init_changes();
     init_physical_path();
     init_held_cwd();
     init_signals();
@@ -16742,12 +16752,14 @@ async function runJs(init, port3, deps, thread) {
     cwd: init.cwd,
     exit: (status3) => exited(statusOf(status3)),
     lane: laneOf(init.lane),
+    changes: init.changes,
     fs: { owners: init.owners === true, links: init.links === true },
     strays,
     thread: threadContext(port3, thread),
     memory: deps.memory,
     asyncContext: deps.asyncContext,
     runScript: deps.runScript,
+    modulePath: modulePathOf(init.program),
     promiseState: deps.promiseState,
     ...thread?.owned ? { owned: thread.owned } : {},
     held: init.held,
@@ -16793,6 +16805,10 @@ async function runJs(init, port3, deps, thread) {
   if (exitedWith !== void 0) return exitedWith;
   return status2;
 }
+function modulePathOf(program) {
+  if (program.glue !== "") return void 0;
+  return program.path;
+}
 var NOT_RUNNABLE;
 var init_js_runtime = __esm({
   "src/process/js/js-runtime.ts"() {