@ai-ecoverse/slicc-kernel 1.166.1 → 1.166.3

package/dist/node.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { lstatSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
-import { MessageChannel as MessageChannel2, Worker } from "node:worker_threads";
+import { MessageChannel as MessageChannel3 } from "node:worker_threads";
 
 // src/bytes.ts
 function fresh(bytes, start2 = 0, end = bytes.length) {
@@ -3684,7 +3684,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.166.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.166.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
@@ -34284,6 +34284,89 @@ function isMemoryRoot(handle) {
   return handle instanceof MemoryDirectory;
 }
 
+// src/node/worker-boot.ts
+import { readFileSync } from "node:fs";
+import { MessageChannel as MessageChannel2, Worker } from "node:worker_threads";
+var PROCESS_BOOT = `(async () => {
+  'use strict';
+  const { workerData } = require('node:worker_threads');
+  const { compileFunction, constants } = require('node:vm');
+  const { createRequire } = require('node:module');
+  const loader = constants.USE_MAIN_CONTEXT_DEFAULT_LOADER;
+  const prime = () => {
+    const emit = process.emitWarning;
+    process.emitWarning = function (message, ...args) {
+      if (message === 'vm.USE_MAIN_CONTEXT_DEFAULT_LOADER is an experimental feature and might change at any time' && args[0] === 'ExperimentalWarning') return;
+      return Reflect.apply(emit, this, [message, ...args]);
+    };
+    try {
+      return compileFunction('return import("node:vm")', [], { importModuleDynamically: loader })();
+    } finally {
+      process.emitWarning = emit;
+    }
+  };
+  const { runEntryPointWithESMLoader } = require('internal/modules/run_main');
+  await runEntryPointWithESMLoader(async () => { await prime(); });
+  const { source: bytes, cachedData, port } = workerData.boot;
+  delete workerData.boot;
+  const source = new TextDecoder().decode(bytes);
+  const run = compileFunction(source, ['require', 'importMetaUrl'], {
+    filename: 'slicc-kernel:/node-process-worker.js',
+    importModuleDynamically: loader,
+    cachedData,
+    produceCachedData: cachedData === undefined,
+  });
+  port.postMessage({ cachedData: run.cachedData, rejected: run.cachedDataRejected === true });
+  port.close();
+  run(createRequire('/slicc-kernel/node-process-worker.js'), '/slicc-kernel/node-process-worker.js');
+})();`;
+var bundles = /* @__PURE__ */ new Map();
+function bootCache(file, read = readFileSync) {
+  let cache = bundles.get(file.href);
+  if (!cache) {
+    cache = {
+      source: new TextEncoder().encode(read(file, "utf8")),
+      attempts: 0,
+      rejected: 0
+    };
+    bundles.set(file.href, cache);
+  }
+  return cache;
+}
+function cachedBoot(cache, data) {
+  if (data.rejected) cache.rejected++;
+  if (data.cachedData) cache.cachedData = data.cachedData;
+  else if (data.rejected) cache.cachedData = void 0;
+}
+function bootWorker(file, options, bundle, make = (entry, init) => new Worker(entry, init), read = readFileSync) {
+  if (!(file instanceof URL) || file.href !== bundle.href) return make(file, options);
+  const cache = bootCache(file, read);
+  const { port1, port2 } = new MessageChannel2();
+  port1.once("message", (data) => {
+    cachedBoot(cache, data);
+    port1.close();
+  });
+  port1.unref();
+  if (cache.cachedData) cache.attempts++;
+  try {
+    const worker = make(PROCESS_BOOT, {
+      ...options,
+      eval: true,
+      workerData: {
+        ...options.workerData,
+        boot: { source: cache.source, cachedData: cache.cachedData, port: port2 }
+      },
+      transferList: [port2]
+    });
+    worker.once("exit", () => port1.close());
+    return worker;
+  } catch (err) {
+    port1.close();
+    port2.close();
+    throw err;
+  }
+}
+
 // src/node/ws-diagnose.ts
 import { lookup as lookup3 } from "node:dns/promises";
 import { isIP as isIP4, connect as tcp } from "node:net";
@@ -35383,7 +35466,11 @@ function resetInternalArgv() {
   internalArgv = void 0;
 }
 function processWorker(file, workerData, internals = false) {
-  const make = (execArgv) => new Worker(file, { env: workerEnv(), ...workerData ? { workerData } : {}, execArgv });
+  const make = (execArgv) => bootWorker(
+    file,
+    { env: workerEnv(), ...workerData ? { workerData } : {}, execArgv },
+    new URL("./node-process-worker.cjs", import.meta.url)
+  );
   return internals ? internalsWorker(make) : make();
 }
 function sourceModule(source) {
@@ -35544,7 +35631,7 @@ function pidAlive(pid) {
 var nodeSessions = 0;
 function nodeClient(launcher, clients, { user, tag, requests }) {
   tagOption(tag);
-  const { port1, port2 } = new MessageChannel2();
+  const { port1, port2 } = new MessageChannel3();
   const session = ++nodeSessions;
   const served2 = serveClient(port1, {
     launcher: async () => launcher,
@@ -35574,7 +35661,7 @@ async function createNodeKernel(options = {}) {
   const pending = /* @__PURE__ */ new Set();
   const clients = /* @__PURE__ */ new Set();
   let terminated = false;
-  const file = options.worker ?? new URL("./node-process-worker.js", import.meta.url);
+  const file = options.worker ?? new URL("./node-process-worker.cjs", import.meta.url);
   const cache = cacheDirOf(options.compileCache);
   const workerData = cacheData(cache);
   const warm = warmPoolOf(options, file, workerData, live);