@ai-ecoverse/slicc-kernel 1.142.2 → 1.142.3

package/README.md

@@ -202,10 +202,12 @@ const { status, stdout } = await kernel.run(['bash', '-c', 'echo hi'], { cwd: '/
 kernel.terminate();
 ```
 
-`createNodeKernel({ root, modules, commands, env, network, worker, facades, processMounts, fstabRetries, cdp, hostfs, hostfsOrigin, hostfsFetch, users, onDenial, approve, compileCache })` takes the options of `createKernel` except `metadata`, and `fstabRetries`, the delays in ms between tries of a failing `/etc/fstab` line (default `[1000, 4000, 16000]`). `root` is an in-memory directory by default (`memoryRoot()` makes another), which keeps each file in 1 MiB chunks, and POSIX metadata stays in memory. Processes and threads run on `worker_threads`. The kernel has `run`, `openTerminal`, `users`, `setRoutes`, `updateTransportTraits` and `terminate` as above, plus `integrity.revoke(path?)`, `root`, `writeFile(path, data, { mode }?)` (creating the parent directories; `mode` sets the permission bits, `0` to `0o7777`, before the data is written), `chmod(path, mode)` and `readFile(path)` to put files in place and read results; like the `fs` of an attached client, they go through the mounts, as the processes see them. `nodeTransport()` is `fetchTransport()` with Node's `fetch`, which no CORS binds (`crossOrigin: 'any'`). `connect({ user })` and `attachKernel` work as in the browser: the port is a `worker_threads` `MessagePort`, which a worker thread can attach with, and `terminate()` ends every attached client.
+`createNodeKernel({ root, modules, commands, env, network, worker, facades, processMounts, fstabRetries, cdp, hostfs, hostfsOrigin, hostfsFetch, users, onDenial, approve, compileCache, warmWorker })` takes the options of `createKernel` except `metadata`, and `fstabRetries`, the delays in ms between tries of a failing `/etc/fstab` line (default `[1000, 4000, 16000]`). `root` is an in-memory directory by default (`memoryRoot()` makes another), which keeps each file in 1 MiB chunks, and POSIX metadata stays in memory. Processes and threads run on `worker_threads`. The kernel has `run`, `openTerminal`, `users`, `setRoutes`, `updateTransportTraits` and `terminate` as above, plus `integrity.revoke(path?)`, `root`, `writeFile(path, data, { mode }?)` (creating the parent directories; `mode` sets the permission bits, `0` to `0o7777`, before the data is written), `chmod(path, mode)` and `readFile(path)` to put files in place and read results; like the `fs` of an attached client, they go through the mounts, as the processes see them. `nodeTransport()` is `fetchTransport()` with Node's `fetch`, which no CORS binds (`crossOrigin: 'any'`). `connect({ user })` and `attachKernel` work as in the browser: the port is a `worker_threads` `MessagePort`, which a worker thread can attach with, and `terminate()` ends every attached client.
 
 `compileCache` (opt-in, off by default; #1285, slicc-jsh#566) is an absolute host directory where each process worker keeps the compiled code of the JS programs it imports (`module.enableCompileCache`), so the next spawn of the same program skips V8's compile. It stores V8's code cache, keyed and checksummed by the module's source, one file per program (about 7 MB for a 2.4 MB bundle), shared by every kernel given the same directory; programs can't reach or write it (the worker hands it to Node before the lockdown, and `node:worker_threads` stays refused). Measured on a 2.4 MB bundle, a spawn went from about 54 to 39 ms; a trivial program costs about 1 ms more. **The directory must be private to the embedder:** V8's code cache is trusted bytecode that Node only checksums, so whoever can write it can plant code that runs inside a process worker past the lockdown. Never make it reachable from inside the kernel (no `hostfs` mount of it or of a parent), and don't share one between kernels of different trust. A host's own `NODE_COMPILE_CACHE` is never handed to the process workers, with or without the option, so programs never land in a host-wide cache. If a host preload (`--import` or `--require`) has already enabled another compile cache in the workers, a kernel given `compileCache` refuses to run programs there instead of caching them in the host's directory.
 
+`warmWorker` (on by default; `false` turns it off; #1341, slicc-jsh#566) keeps one process worker booted ahead of the next spawn, fork or thread on the Node entry, so the spawn skips the worker's boot: it has loaded the process worker module and nothing else, no pid, credentials, environment, cwd, descriptors, lockdown or program, all of which arrive with its init message, and every worker still serves exactly one process or thread and is then terminated. Its own `process.env` is a snapshot taken when the spare is created rather than at the spawn, but a program never sees it (`process` is withheld, and a program's environment is the one its spawn gives it). The spare never keeps the host alive, is replaced after each spawn off the critical path, is dropped if it errors or exits while idle, and is released after 30 s without a spawn; `terminate()` ends it. It costs about 11 MB of host RSS while it waits.
+
 By default `nodeTransport()` refuses destinations on the host itself, because Node can reach them and a page can't: local DevTools on 9222–9229, dev servers, local admin APIs, and the cloud metadata address.
 - **What it refuses:** loopback (`127.0.0.0/8`, `::1`, and their IPv4-mapped forms), unspecified addresses (`0.0.0.0/8`, `::`), `localhost` and `*.localhost`, and link-local addresses (`169.254.0.0/16`, `fe80::/10`), plus AWS's IPv6 metadata address `fd00:ec2::254`.
 - **How it checks:** it matches on the addresses the name resolves to, so a public name that resolves to `127.0.0.1` is refused too. It checks every request and WebSocket open, `host.slicc.internal` and each redirect hop included.

package/dist/kernel-worker.js

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

@@ -6725,7 +6725,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.142.2" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.142.3" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/node.js

@@ -7979,7 +7979,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.142.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.142.3" : "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
@@ -32110,7 +32110,66 @@ function nodeTransport(options = {}) {
 }
 var TERMINATED = "the kernel is terminated";
 var EXIT_GRACE_MS = 50;
-function nodeWorker(file, live, closed, workerData) {
+var WARM_IDLE_MS = 3e4;
+function warmPool(make, live, idleMs = WARM_IDLE_MS) {
+  let spare;
+  let idle2;
+  let closed = false;
+  const drop = (worker) => {
+    if (spare !== worker) return;
+    spare = void 0;
+    clearTimeout(idle2);
+    live.delete(kill);
+  };
+  const kill = () => {
+    const worker = spare;
+    if (!worker) return;
+    drop(worker);
+    void worker.terminate();
+  };
+  const fill2 = () => {
+    if (closed || spare) return;
+    let worker;
+    try {
+      worker = make();
+    } catch {
+      closed = true;
+      return;
+    }
+    worker.unref();
+    worker.once("error", () => drop(worker));
+    worker.once("exit", () => drop(worker));
+    spare = worker;
+    live.add(kill);
+    idle2 = setTimeout(kill, idleMs);
+    idle2.unref?.();
+  };
+  return {
+    take() {
+      const worker = spare;
+      if (worker) {
+        drop(worker);
+        worker.removeAllListeners("error");
+        worker.removeAllListeners("exit");
+        worker.ref();
+      }
+      setImmediate(fill2);
+      return worker ?? make();
+    },
+    close() {
+      closed = true;
+      kill();
+    }
+  };
+}
+function processWorker(file, workerData) {
+  return new Worker(file, { env: workerEnv(), ...workerData ? { workerData } : {} });
+}
+function warmPoolOf(options, file, workerData, live) {
+  if (options.warmWorker === false) return void 0;
+  return warmPool(() => processWorker(file, workerData), live);
+}
+function nodeWorker(file, live, closed, workerData, take) {
   const errors = /* @__PURE__ */ new Set();
   const messages = /* @__PURE__ */ new Map();
   const fail3 = (message3) => {
@@ -32119,7 +32178,7 @@ function nodeWorker(file, live, closed, workerData) {
       } });
     }
   };
-  const worker = closed ? void 0 : new Worker(file, { env: workerEnv(), ...workerData ? { workerData } : {} });
+  const worker = closed ? void 0 : take?.() ?? processWorker(file, workerData);
   let ending = false;
   if (worker) {
     const kill = () => {
@@ -32192,11 +32251,13 @@ async function createNodeKernel(options = {}) {
   let terminated = false;
   const file = options.worker ?? new URL("./node-process-worker.js", import.meta.url);
   const compileCache = cacheDirOf(options.compileCache);
+  const workerData = compileCache ? { compileCache } : void 0;
+  const warm = warmPoolOf(options, file, workerData, live);
   const transport = options.network?.transport;
   const launcher = new Launcher({
     fs,
     unlinkOwner: pidOwner(process),
-    createWorker: () => nodeWorker(file, live, terminated, compileCache ? { compileCache } : void 0),
+    createWorker: () => nodeWorker(file, live, terminated, workerData, warm ? () => warm.take() : void 0),
     createDriverWorker: () => nodeWorker(
       options.driverWorker ?? new URL("./node-driver-worker.js", import.meta.url),
       live,
@@ -32329,6 +32390,7 @@ async function createNodeKernel(options = {}) {
     },
     terminate() {
       terminated = true;
+      warm?.close();
       for (const client of [...clients]) client.detach();
       for (const reject of [...pending]) reject(new Error(TERMINATED));
       for (const kill of [...live]) kill();
@@ -32340,11 +32402,13 @@ async function createNodeKernel(options = {}) {
 export {
   KernelCallError,
   KernelGoneError,
+  WARM_IDLE_MS,
   attachKernel,
   createNodeKernel,
   fetchTransport,
   memoryRoot,
   nodeTransport,
-  serveHostfsPort
+  serveHostfsPort,
+  warmPool
 };
 //# sourceMappingURL=node.js.map