@ai-ecoverse/slicc-kernel 1.141.3 → 1.142.0

package/dist/node-process-worker.js

@@ -906,7 +906,7 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
     if ("until" in hit) return live(hit, path) ? hit : void 0;
     return young2(hit) && !seen.changed(map, path) ? hit : void 0;
   };
-  const cached = (map, path, get) => {
+  const cached2 = (map, path, get) => {
     if (blind) return get();
     cache.fresh();
     let hit = usable(map, path);
@@ -984,11 +984,11 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
       }
       return bridge.readlink(p);
     },
-    stat: (p) => cached(stats, p, () => bridge.stat(p)),
-    lstat: (p) => cached(lstats, p, () => bridge.lstat(p)),
+    stat: (p) => cached2(stats, p, () => bridge.stat(p)),
+    lstat: (p) => cached2(lstats, p, () => bridge.lstat(p)),
     exists: (p) => {
       try {
-        cached(stats, p, () => bridge.stat(p));
+        cached2(stats, p, () => bridge.stat(p));
         return true;
       } catch {
         return false;
@@ -2019,10 +2019,10 @@ function callError(result, op) {
 }
 function untilAborted(work, signal) {
   if (!signal) return work;
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const done = () => {
       signal.removeEventListener("abort", done);
-      resolve();
+      resolve2();
     };
     signal.addEventListener("abort", done, { once: true });
     work.then(done, done);
@@ -6725,7 +6725,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.141.3" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.142.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7673,7 +7673,7 @@ function netOps(kernel, io) {
     });
     return { fd, local: local3, remote, readable: readable3, writable: writable2, close };
   };
-  const resolve = async (host, signal) => {
+  const resolve2 = async (host, signal) => {
     if (IPV4.test(host)) return host;
     const r = await kernel.blocking({ op: "sock-resolve", name: host, family: 4 }, signal);
     return (r.ok && r.kind === "json" ? r.json : [])[0];
@@ -7773,7 +7773,7 @@ function netOps(kernel, io) {
       if (host.includes(":")) throw new JsCallError("EADDRNOTAVAIL", host);
       const addr = {
         family: "inet",
-        host: await resolve(host, signal),
+        host: await resolve2(host, signal),
         port: port(options.port)
       };
       return opened2(async (fd) => {
@@ -8568,9 +8568,9 @@ function createNodeOps(h) {
       const owned = bridgeOf(node).owners === true;
       if (owned && Fs.isLink(node.mode) && statOf(node).uid === void 0)
         node.live.stat = void 0;
-      const cached = owned && cachedStat(node, Fs.isDir(node.mode), bridgeOf(node).changes);
+      const cached2 = owned && cachedStat(node, Fs.isDir(node.mode), bridgeOf(node).changes);
       const st = statOf(node);
-      if (cached) searchParents(Fs, node, bridgeOf(node), call2);
+      if (cached2) searchParents(Fs, node, bridgeOf(node), call2);
       const s = node.live;
       const size = Fs.isDir(node.mode) ? 4096 : s.ranged?.size() ?? (s.loaded ? s.len : st.size);
       const mtime = new Date(st.mtimeMs ?? 0);
@@ -9181,7 +9181,7 @@ function guardVanished(Fs) {
   const drop = forget;
   const lookupPath = Fs.lookupPath.bind(Fs);
   const ops = Fs;
-  const cached = (path, follow3) => {
+  const cached2 = (path, follow3) => {
     try {
       const node = lookupPath(path, { follow: follow3 }).node;
       return node.live && node.live.openCount === 0 && !node.live.dirty ? node : void 0;
@@ -9204,7 +9204,7 @@ function guardVanished(Fs) {
         const code2 = err.errno;
         const taken = code2 === wasiErrno("EEXIST") && op === open;
         if (code2 !== wasiErrno("ENOENT") && !taken || typeof path !== "string") throw err;
-        const node = cached(path, follows(args));
+        const node = cached2(path, follows(args));
         if (!node) throw err;
         drop(node);
         return op(...args);
@@ -11444,7 +11444,7 @@ function promised(file) {
   const out = { ...file };
   for (const [name2, value2] of Object.entries(file)) {
     if (typeof value2 === "function") {
-      out[name2] = (...args) => new Promise((resolve) => resolve(value2(...args)));
+      out[name2] = (...args) => new Promise((resolve2) => resolve2(value2(...args)));
     }
   }
   return out;
@@ -11625,7 +11625,7 @@ function laneOf(lane, silence = SYNC_FS_REQUEST_TIMEOUT_MS, open = createSyncSab
   };
 }
 function syncOps(kernel, shared) {
-  const { infos, handles, resolve } = shared;
+  const { infos, handles, resolve: resolve2 } = shared;
   const tryDevSync = (abs) => {
     try {
       const resolved2 = physicalPath(
@@ -11678,7 +11678,7 @@ function syncOps(kernel, shared) {
     return at;
   };
   const statOf = (op, path) => {
-    const abs = resolve(path);
+    const abs = resolve2(path);
     if (inDev(abs)) return devSync(kernel, devStat(abs, op === "stat"));
     try {
       kernel.call({ op: "fd-path-flush", path: abs });
@@ -11708,7 +11708,7 @@ function syncOps(kernel, shared) {
     return handle.file;
   };
   const open = (path, options = {}) => {
-    const abs = resolve(path);
+    const abs = resolve2(path);
     if (inDev(abs)) return openDev2(abs, options);
     try {
       let existing;
@@ -11751,9 +11751,9 @@ function syncOps(kernel, shared) {
     },
     socketpair: () => kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
     pipe: () => kernel.json({ op: "fd-pipe" }),
-    open: procOpenSync(open, kernel, { resolve, pid: shared.pid }),
-    fs: procFsSync(syncPathOps(kernel, resolve, statOf, open, tryDevSync), kernel, {
-      resolve,
+    open: procOpenSync(open, kernel, { resolve: resolve2, pid: shared.pid }),
+    fs: procFsSync(syncPathOps(kernel, resolve2, statOf, open, tryDevSync), kernel, {
+      resolve: resolve2,
       pid: shared.pid
     })
   };
@@ -11822,41 +11822,41 @@ function syncFile(kernel, fd, path, append, forget) {
     }
   };
 }
-function syncPathOps(kernel, resolve, statOf, open, tryDev) {
+function syncPathOps(kernel, resolve2, statOf, open, tryDev) {
   return {
     stat: (path) => statOf("stat", path),
     lstat: (path) => statOf("lstat", path),
     exists(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return devSync(kernel, devExists(abs));
       if (kernel.json({ op: "exists", path: abs }) === true) return true;
       const devPath = tryDev(abs);
       return devPath ? devSync(kernel, devExists(devPath)) : false;
     },
     readdir(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return devSync(kernel, devReaddir(abs));
       return kernel.json({ op: "readdir", path: abs });
     },
     mkdir: (path, options) => void kernel.call({
       op: "mkdir",
-      path: resolve(path),
+      path: resolve2(path),
       ...options?.recursive === false ? { exclusive: true } : {},
       mode: options?.mode === void 0 ? 511 : modeOf(options.mode)
     }),
-    rm: (path) => void kernel.call({ op: "rm", path: resolve(path) }),
-    unlink: (path) => void kernel.call({ op: "unlink", path: resolve(path) }),
-    rename: (from, to) => void kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
-    chmod: (path, mode) => void kernel.call({ op: "chmod", path: resolve(path), mode: modeOf(mode) }),
-    link: (from, to) => void kernel.call({ op: "link", path: resolve(from), arg2: resolve(to) }),
-    symlink: (target, path) => void kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
+    rm: (path) => void kernel.call({ op: "rm", path: resolve2(path) }),
+    unlink: (path) => void kernel.call({ op: "unlink", path: resolve2(path) }),
+    rename: (from, to) => void kernel.call({ op: "rename", path: resolve2(from), arg2: resolve2(to) }),
+    chmod: (path, mode) => void kernel.call({ op: "chmod", path: resolve2(path), mode: modeOf(mode) }),
+    link: (from, to) => void kernel.call({ op: "link", path: resolve2(from), arg2: resolve2(to) }),
+    symlink: (target, path) => void kernel.call({ op: "symlink", path: resolve2(path), arg2: target }),
     readlink(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return devSync(kernel, devReadlink(abs));
       return String(kernel.json({ op: "readlink", path: abs }));
     },
     statfs(path) {
-      let abs = resolve(path);
+      let abs = resolve2(path);
       if (inDev(abs)) {
         try {
           const target = devSync(kernel, devResolveTarget(abs));
@@ -11868,7 +11868,7 @@ function syncPathOps(kernel, resolve, statOf, open, tryDev) {
       return statFsOf(kernel.json({ op: "statfs", path: abs }));
     },
     readFile(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return readWholeSync(open(abs));
       try {
         kernel.call({ op: "fd-path-flush", path: abs });
@@ -14126,8 +14126,8 @@ async function runWasmProcess(init, port3, deps = {}) {
   let exports;
   let atExit = () => () => {
   };
-  const initialized = new Promise((resolve, reject) => {
-    ready = resolve;
+  const initialized = new Promise((resolve2, reject) => {
+    ready = resolve2;
     failed5 = reject;
   });
   const id = identify(transport, init);
@@ -14513,12 +14513,12 @@ function within2(root, dir, path) {
   }
   return true;
 }
-function preopensOf(given, resolve) {
+function preopensOf(given, resolve2) {
   if (given === void 0) return [];
   if (typeof given !== "object" || given === null) throw new JsCallError("EINVAL", "wasi preopens");
   return Object.entries(given).map(([name2, path]) => {
     if (typeof path !== "string" || path === "") throw new JsCallError("EINVAL", "wasi preopens");
-    return [name2, normalize(resolve(path))];
+    return [name2, normalize(resolve2(path))];
   });
 }
 function createJsWasi(deps, o = {}) {
@@ -14847,8 +14847,8 @@ function websocketOp(kernel) {
     }
     let settle;
     let lose;
-    const closed = new Promise((resolve, reject) => {
-      settle = resolve;
+    const closed = new Promise((resolve2, reject) => {
+      settle = resolve2;
       lose = reject;
     });
     closed.catch(() => void 0);
@@ -14947,7 +14947,7 @@ var init_js_websocket = __esm({
     SEND_BUFFER = 1024 * 1024;
     MAX_REASON = 123;
     NEVER2 = new AbortController().signal;
-    wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    wait = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 });
 
@@ -15225,7 +15225,7 @@ function tracked2(pending, writeAll, writeSome, failed5) {
     if (status2 !== void 0) return Promise.reject(new JsExit(status2));
     const bytes = typeof data === "string" ? encoder4.encode(data) : data;
     let settle;
-    const settled2 = new Promise((resolve) => settle = resolve);
+    const settled2 = new Promise((resolve2) => settle = resolve2);
     pending.add(settled2);
     return (async () => {
       try {
@@ -15260,7 +15260,7 @@ function createContext(o) {
   const pending = /* @__PURE__ */ new Set();
   const random = o.random ?? cryptoRandom;
   let held2;
-  const resolve = (path) => resolvePath(cwdFor(o.cwd, held2, path), path);
+  const resolve2 = (path) => resolvePath(cwdFor(o.cwd, held2, path), path);
   const tryDev = (abs) => resolveDevAsync(kernel, abs);
   let exiting;
   const exit = (code2 = 0) => {
@@ -15288,13 +15288,13 @@ function createContext(o) {
     }
   });
   const statOf = async (op, path) => {
-    const abs = resolve(path);
+    const abs = resolve2(path);
     if (inDev(abs)) return devAsync(kernel, devStat(abs, op === "stat"));
     return vfsStat(kernel, abs, op, tryDev);
   };
   const devIo = { infos, handles, read: read2, write: writeAll };
   const open = async (path, options = {}, whole = false) => {
-    const abs = resolve(path);
+    const abs = resolve2(path);
     if (inDev(abs)) return openDev(kernel, abs, options, devIo);
     try {
       return await vfsOpen(kernel, abs, options, statOf, devIo, whole);
@@ -15305,8 +15305,8 @@ function createContext(o) {
       return openDev(kernel, devPath, options, devIo);
     }
   };
-  const fs = procFsAsync(pathOps(kernel, resolve, statOf, open, tryDev), kernel, {
-    resolve,
+  const fs = procFsAsync(pathOps(kernel, resolve2, statOf, open, tryDev), kernel, {
+    resolve: resolve2,
     pid: o.pid
   });
   const lane = o.lane ?? laneOf(void 0);
@@ -15314,13 +15314,13 @@ 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, random, infos, handles, closing };
-  const wasi = wasiFor({ lane, pid: o.pid, cwd: o.cwd, resolve, fs: o.fs, owned: o.owned });
+  const shared = { pid: o.pid, resolve: resolve2, random, infos, handles, closing };
+  const wasi = wasiFor({ lane, pid: o.pid, cwd: o.cwd, resolve: resolve2, fs: o.fs, owned: o.owned });
   const sync = {
     kernel: KERNEL_INFO,
     tty: terminal.syncTty,
     ...watchingSyncOps(kernel, syncKernel, shared),
-    run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve, signal: signalNumber }, options),
+    run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve: resolve2, signal: signalNumber }, options),
     spawn: (options) => spawnSync(options),
     wasi: { create: wasi.create },
     exit: (status2 = 0) => {
@@ -15369,8 +15369,8 @@ function createContext(o) {
       return { type, tty: type === "tty", seekable: type === "file" };
     },
     isatty: async (fd) => typeOf(await info(fd)) === "tty",
-    open: procOpenAsync(open, kernel, { resolve, pid: o.pid }),
-    resolve,
+    open: procOpenAsync(open, kernel, { resolve: resolve2, pid: o.pid }),
+    resolve: resolve2,
     fs,
     signals: {
       on: async (signal, handler) => kernel.setHandler(signalNumber(signal), handler),
@@ -15401,7 +15401,7 @@ function createContext(o) {
     wasi.closeAll();
     for (; ; ) {
       await Promise.all([...pending]);
-      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
       if (pending.size === 0) break;
     }
     await terminal.restore();
@@ -15516,41 +15516,41 @@ async function sendSome(kernel, fd, body, signal) {
     await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
   }
 }
-function pathOps(kernel, resolve, statOf, open, tryDev) {
+function pathOps(kernel, resolve2, statOf, open, tryDev) {
   return {
     stat: (path) => statOf("stat", path),
     lstat: (path) => statOf("lstat", path),
     async exists(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return devAsync(kernel, devExists(abs));
       if (await kernel.json({ op: "exists", path: abs }) === true) return true;
       const devPath = await tryDev(abs);
       return devPath ? devAsync(kernel, devExists(devPath)) : false;
     },
     async readdir(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return devAsync(kernel, devReaddir(abs));
       return await kernel.json({ op: "readdir", path: abs });
     },
     mkdir: async (path, options) => void await kernel.call({
       op: "mkdir",
-      path: resolve(path),
+      path: resolve2(path),
       ...options?.recursive === false ? { exclusive: true } : {},
       mode: options?.mode === void 0 ? 511 : modeOf(options.mode)
     }),
-    rm: async (path) => void await kernel.call({ op: "rm", path: resolve(path) }),
-    unlink: async (path) => void await kernel.call({ op: "unlink", path: resolve(path) }),
-    rename: async (from, to) => void await kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
-    chmod: async (path, mode) => void await kernel.call({ op: "chmod", path: resolve(path), mode: modeOf(mode) }),
-    link: async (from, to) => void await kernel.call({ op: "link", path: resolve(from), arg2: resolve(to) }),
-    symlink: async (target, path) => void await kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
+    rm: async (path) => void await kernel.call({ op: "rm", path: resolve2(path) }),
+    unlink: async (path) => void await kernel.call({ op: "unlink", path: resolve2(path) }),
+    rename: async (from, to) => void await kernel.call({ op: "rename", path: resolve2(from), arg2: resolve2(to) }),
+    chmod: async (path, mode) => void await kernel.call({ op: "chmod", path: resolve2(path), mode: modeOf(mode) }),
+    link: async (from, to) => void await kernel.call({ op: "link", path: resolve2(from), arg2: resolve2(to) }),
+    symlink: async (target, path) => void await kernel.call({ op: "symlink", path: resolve2(path), arg2: target }),
     async readlink(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return devAsync(kernel, devReadlink(abs));
       return String(await kernel.json({ op: "readlink", path: abs }));
     },
     async statfs(path) {
-      let abs = resolve(path);
+      let abs = resolve2(path);
       if (inDev(abs)) {
         const target = await devAsync(kernel, devResolveTarget(abs)).catch(() => void 0);
         if (target?.startsWith("/")) abs = target;
@@ -15560,11 +15560,11 @@ function pathOps(kernel, resolve, statOf, open, tryDev) {
     },
     async watch(path, options, listener) {
       const [given, onNote] = watchArgs(options, listener);
-      const id = await kernel.json(watchRequest(resolve(path), given));
+      const id = await kernel.json(watchRequest(resolve2(path), given));
       return follow2(kernel, id, onNote);
     },
     async readFile(path) {
-      const abs = resolve(path);
+      const abs = resolve2(path);
       if (inDev(abs)) return readWhole(await open(abs));
       try {
         await kernel.call({ op: "fd-path-flush", path: abs });
@@ -15647,7 +15647,7 @@ function optionsOf(options) {
 }
 function started(port3, control) {
   const exited = Promise.withResolvers();
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const thread = (tid) => Object.freeze({
       tid,
       port: port3,
@@ -15659,7 +15659,7 @@ function started(port3, control) {
     });
     control.onmessage = (event) => {
       const said = event.data;
-      if ("tid" in said) resolve(thread(said.tid));
+      if ("tid" in said) resolve2(thread(said.tid));
       else if ("errno" in said) {
         control.close();
         port3.close();
@@ -15742,7 +15742,7 @@ function trapStrays(scope2, stray) {
   });
 }
 async function settledStrays() {
-  for (let turn = 0; turn < 2; turn++) await new Promise((resolve) => setTimeout(resolve, 0));
+  for (let turn = 0; turn < 2; turn++) await new Promise((resolve2) => setTimeout(resolve2, 0));
 }
 function message(err) {
   return err instanceof Error ? err.message : String(err);
@@ -15765,7 +15765,7 @@ async function runJs(init, port3, deps, thread) {
   const failed5 = (err) => thread && outOfMemory(err) ? JS_THREAD_NO_MEMORY : 1;
   const transport = createAsyncSabTransport(init.sab, port3, deps.waitAsync);
   let resolveExit;
-  const exit = new Promise((resolve) => resolveExit = resolve);
+  const exit = new Promise((resolve2) => resolveExit = resolve2);
   let exitedWith;
   const exited = (status3) => {
     exitedWith ??= status3;
@@ -15823,6 +15823,7 @@ async function runJs(init, port3, deps, thread) {
     (deps.lockdown ?? lockdown)();
     const { url, glue } = init.program;
     main = mainOf(await (url ? import(url) : (deps.load ?? importSource)(glue)));
+    deps.imported?.();
   } catch (err) {
     await say(message(err));
     return NOT_RUNNABLE;
@@ -16954,7 +16955,7 @@ var init_wasix_linker = __esm({
         return { env, "GOT.mem": gotMem, "GOT.func": gotFunc };
       }
       bindMainGot() {
-        for (const resolve of this.mainGot) resolve();
+        for (const resolve2 of this.mainGot) resolve2();
       }
       bindMain(instance, relocate) {
         this.main = instance;
@@ -17086,8 +17087,8 @@ var init_wasix_linker = __esm({
         this.slots.set(value2, record.index);
       }
       moduleAt(path) {
-        const cached = this.cache?.[path];
-        if (cached) return cached;
+        const cached2 = this.cache?.[path];
+        if (cached2) return cached2;
         const bytes = this.host.read(path);
         if (!bytes) throw new DlError(`${path}: gone`);
         return new WebAssembly.Module(bytes);
@@ -17192,7 +17193,7 @@ var init_wasix_linker = __esm({
         this.modules.set(at.handle, linked);
         const first = this.byPath.get(path);
         if (!first || at.handle < first.handle) this.byPath.set(path, linked);
-        for (const resolve of pending) resolve();
+        for (const resolve2 of pending) resolve2();
         if (init) {
           call(linked.instance, "__wasm_apply_data_relocs");
           call(linked.instance, "__wasm_call_ctors");
@@ -17967,8 +17968,8 @@ function createImportedMemory(spec, copy2) {
   if (copy2) fillMemory(memory, copy2);
   return memory;
 }
-function restoreExportedMemory(instance, imported, init) {
-  if (imported || !init.fork?.wasi) return;
+function restoreExportedMemory(instance, imported2, init) {
+  if (imported2 || !init.fork?.wasi) return;
   fillMemory(instance.exports.memory, init.fork.memory);
 }
 function fillMemory(memory, copy2) {
@@ -17979,8 +17980,8 @@ function fillMemory(memory, copy2) {
 function sizeOf2(main) {
   return () => main.memory?.buffer.byteLength ?? 0;
 }
-function memoryOf(instance, imported) {
-  return imported ?? instance.exports.memory;
+function memoryOf(instance, imported2) {
+  return imported2 ?? instance.exports.memory;
 }
 function kernelOf(init, port3, hooks = { masks: () => null, raise: () => {
 } }, memory) {
@@ -18321,9 +18322,9 @@ function programNames(host, program, warned) {
   const path = program.names;
   if (path === void 0) return void 0;
   const read2 = (p) => host.o.fs.readFile(p);
-  const imported = WebAssembly.Module.imports(program.module).filter((i) => i.kind === "function");
+  const imported2 = WebAssembly.Module.imports(program.module).filter((i) => i.kind === "function");
   return sidecarNames(read2, path, {
-    functions: () => imported.length + definedFunctions(read2(program.path)),
+    functions: () => imported2.length + definedFunctions(read2(program.path)),
     warn: (line) => warned.push(line)
   });
 }
@@ -18567,12 +18568,13 @@ var init_wasi_runtime = __esm({
 });
 
 // src/node-process-worker.ts
-import { createRequire } from "node:module";
-import { parentPort } from "node:worker_threads";
+import { createRequire, enableCompileCache, flushCompileCache } from "node:module";
+import { parentPort, workerData } from "node:worker_threads";
 
 // src/node-lockdown.ts
 init_lockdown();
 import { isBuiltin, registerHooks } from "node:module";
+import { resolve, sep } from "node:path";
 import { getHeapStatistics } from "node:v8";
 var NODE_GLOBALS = ["localStorage", "sessionStorage"];
 var NODE_SLOTS = [
@@ -18665,6 +18667,16 @@ function workerShaped(scope2, href) {
     location: slot2(Object.freeze({ href }))
   });
 }
+function ownCache(dir, result) {
+  const active = result.directory;
+  if (active === void 0) return false;
+  if (!`${resolve(active)}${sep}`.startsWith(`${resolve(dir)}${sep}`)) {
+    throw new Error(
+      `slicc-kernel: compileCache ${dir} was asked for, but this worker already caches in ${active} (a host preload enabled it): refusing to run programs`
+    );
+  }
+  return true;
+}
 
 // src/node-process-worker.ts
 init_js_runtime();
@@ -18741,6 +18753,9 @@ var scope = globalThis;
 scope.require ??= createRequire(import.meta.url);
 scope.__filename ??= new URL(import.meta.url).pathname;
 scope.__dirname ??= new URL(".", import.meta.url).pathname;
+var cacheDir = workerData?.compileCache;
+var cached = typeof cacheDir === "string" && ownCache(cacheDir, enableCompileCache(cacheDir));
+var imported = cached ? () => flushCompileCache() : void 0;
 var port2 = parentPort;
 var post = {
   postMessage: (message2, transfer) => port2.postMessage(message2, transfer)
@@ -18757,12 +18772,14 @@ var onMessage = processEntry(
     runJsProcess: (init, at) => runJsProcess(init, at, {
       lockdown: () => nodeLockdown(),
       scope: strayScope,
-      memory: nodeMemory
+      memory: nodeMemory,
+      imported
     }),
     runJsThread: (init, at) => runJsThread(init, at, {
       lockdown: () => nodeLockdown(),
       scope: strayScope,
-      memory: nodeMemory
+      memory: nodeMemory,
+      imported
     })
   }),
   () => nodeLockdown()