@ai-ecoverse/slicc-kernel 1.160.2 → 1.161.0

package/dist/node-process-worker.js

@@ -2207,8 +2207,8 @@ function createSyncFsSabBridge(transport, opts = {}) {
   };
   const io = (id) => ({
     readFile: (path) => bytes({ op: "read", path, ...id }, path),
-    writeFile: (path, data, open) => {
-      changing({ op: "write", path, body: data, ...open ? { mode: 1 } : {}, ...id }, path);
+    writeFile: (path, data2, open) => {
+      changing({ op: "write", path, body: data2, ...open ? { mode: 1 } : {}, ...id }, path);
     },
     pread: (path, offset, length, version) => bytes({ op: "pread", path, offset, length, ...version ? { version } : {}, ...id }, path),
     pwrite: (path, offset, body, transfer) => {
@@ -3116,12 +3116,12 @@ function streamFile(fd, path, io, access) {
     },
     read: (position, length) => readAsync(position, length),
     readInto: readingIntoAsync((position, length) => readAsync(position, length)),
-    async write(position, data) {
+    async write(position, data2) {
       index2(position, "write");
       live();
       allowed(access.write, "write");
-      await io.write(fd, data);
-      return data.length;
+      await io.write(fd, data2);
+      return data2.length;
     },
     async truncate(size) {
       live();
@@ -3155,12 +3155,12 @@ function streamSyncFile(fd, path, io, access) {
     },
     read: (position, length) => readSync(position, length),
     readInto: readingInto((position, length) => readSync(position, length)),
-    write(position, data) {
+    write(position, data2) {
       index2(position, "write");
       live();
       allowed(access.write, "write");
-      io.write(fd, data);
-      return data.length;
+      io.write(fd, data2);
+      return data2.length;
     },
     truncate(size) {
       live();
@@ -4572,12 +4572,12 @@ var init_wasi_memory = __esm({
         }
         return out;
       }
-      scatter(ptr, count, data) {
+      scatter(ptr, count, data2) {
         let at = 0;
         for (const [base, len] of this.iovecs(ptr, count)) {
-          if (at >= data.length) break;
-          const n = capturedMath.min(len, data.length - at);
-          this.bytes(base, n).set(data.subarray(at, at + n));
+          if (at >= data2.length) break;
+          const n = capturedMath.min(len, data2.length - at);
+          this.bytes(base, n).set(data2.subarray(at, at + n));
           at += n;
         }
         return at;
@@ -4980,8 +4980,8 @@ function wasixEpollImports(host) {
       kernelFd(fd, "EPERM");
       if (how !== "del" && event === 0) throw new WasiError("EINVAL");
       const events = event === 0 ? 0 : mem.view().getUint32(event, true);
-      const data = event === 0 ? [] : [...mem.bytes(event + DATA_OFFSET, DATA_SIZE)];
-      call3({ op: "epoll-ctl", epfd, how, fd, events, data });
+      const data2 = event === 0 ? [] : [...mem.bytes(event + DATA_OFFSET, DATA_SIZE)];
+      call3({ op: "epoll-ctl", epfd, how, fd, events, data: data2 });
     },
     epoll_wait: (epfd, ptr, maxevents, timeout, out) => {
       mem.view().setUint32(out, 0, true);
@@ -6111,12 +6111,12 @@ var init_wasi_host = __esm({
         return {
           fd_write: (fd, iovs, n, out) => void mem.view().setUint32(out, this.write(fd, mem.gather(iovs, n)), true),
           fd_read: (fd, iovs, n, out) => {
-            const data = this.read(fd, mem.capacity(iovs, n));
-            mem.view().setUint32(out, mem.scatter(iovs, n, data), true);
+            const data2 = this.read(fd, mem.capacity(iovs, n));
+            mem.view().setUint32(out, mem.scatter(iovs, n, data2), true);
           },
           fd_pread: (fd, iovs, n, at, out) => {
-            const data = this.positional(fd, "read").pread(mem.capacity(iovs, n), capturedNumber(at));
-            mem.view().setUint32(out, mem.scatter(iovs, n, data), true);
+            const data2 = this.positional(fd, "read").pread(mem.capacity(iovs, n), capturedNumber(at));
+            mem.view().setUint32(out, mem.scatter(iovs, n, data2), true);
           },
           fd_pwrite: (fd, iovs, n, at, out) => void mem.view().setUint32(
             out,
@@ -6287,8 +6287,8 @@ var init_wasi_host = __esm({
             }
             const peek = (riflags & RIFLAGS.PEEK) !== 0;
             const want = mem.capacity(iovs, n);
-            const data = (riflags & RIFLAGS.WAITALL) !== 0 && !peek ? this.recvAll(fd, want, e.nonblock) : o.kernel.sys.read(fd, capturedMath.min(want, MAX_READ), { nonblock: e.nonblock, peek });
-            mem.view().setUint32(outLen, mem.scatter(iovs, n, data), true);
+            const data2 = (riflags & RIFLAGS.WAITALL) !== 0 && !peek ? this.recvAll(fd, want, e.nonblock) : o.kernel.sys.read(fd, capturedMath.min(want, MAX_READ), { nonblock: e.nonblock, peek });
+            mem.view().setUint32(outLen, mem.scatter(iovs, n, data2), true);
             mem.view().setUint16(outFlags, 0, true);
           },
           sock_send: (fd, iovs, n, _flags, out) => {
@@ -6399,12 +6399,12 @@ var init_wasi_host = __esm({
       kernelStat(fd) {
         return this.o.kernel.call({ op: "fd-vfs-stat", fd });
       }
-      write(fd, data) {
-        if (this.muted?.(fd, data)) return data.length;
+      write(fd, data2) {
+        if (this.muted?.(fd, data2)) return data2.length;
         const e = this.fds.get(fd);
         if (e.type === "kernel") {
           try {
-            const n = this.o.kernel.sys.write(fd, data, { nonblock: e.nonblock });
+            const n = this.o.kernel.sys.write(fd, data2, { nonblock: e.nonblock });
             return this.fds.kind(fd, e) === "file" ? this.changed(fd, e, n) : n;
           } catch (err) {
             const broken = err.code === "EPIPE";
@@ -6415,10 +6415,10 @@ var init_wasi_host = __esm({
         if (e.type === "device") {
           this.interrupted?.();
           if (e.access === "read") throw new WasiError("EBADF");
-          if (e.device === "full" && data.length > 0) throw new WasiError("ENOSPC");
-          return data.length;
+          if (e.device === "full" && data2.length > 0) throw new WasiError("ENOSPC");
+          return data2.length;
         }
-        return this.file(fd, "write").write(data);
+        return this.file(fd, "write").write(data2);
       }
       brokenPipe() {
         let action;
@@ -7365,7 +7365,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.160.2" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.161.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7589,10 +7589,10 @@ function restoreMode(lane, { terminal, fd, termios }) {
   lane({ op: "tty-set", fd: opened2, termios });
   lane({ op: "fd-close", fd: opened2 });
 }
-function writeOut(lane, fd, data) {
+function writeOut(lane, fd, data2) {
   let at = 0;
-  while (at < data.length) {
-    const body = data.subarray(at, at + MAX_IO);
+  while (at < data2.length) {
+    const body = data2.subarray(at, at + MAX_IO);
     const r = lane({ op: "fd-write", fd, body });
     if (!r.ok && r.errno === "EINTR") continue;
     if (!r.ok) return false;
@@ -10662,13 +10662,13 @@ function useFileMmap(Fs, deps) {
     if (stream.stream_ops.mmap && kfd === void 0 || !memalign || !memory || length <= 0 || shared || (stream.flags & O_ACCMODE3) === O_WRONLY5 || !Fs.isFile(stream.node.mode)) {
       return mmap.call(fs, stream, length, position, prot, flags);
     }
-    const data = staging(Fs, length);
+    const data2 = staging(Fs, length);
     let done = 0;
     try {
-      if (kfd !== void 0) done = readInto(deps.sys, kfd, data, position);
+      if (kfd !== void 0) done = readInto(deps.sys, kfd, data2, position);
       else {
         for (let got = 1; done < length && got > 0; done += got) {
-          got = Fs.read(stream, data, done, length - done, position + done);
+          got = Fs.read(stream, data2, done, length - done, position + done);
         }
       }
     } catch (err) {
@@ -10679,7 +10679,7 @@ function useFileMmap(Fs, deps) {
     if (!ptr) throw new Fs.ErrnoError(wasiErrno("ENOMEM"));
     const target = new capturedUint8Array(memory.buffer, ptr, size);
     target.fill(0);
-    target.set(data.subarray(0, done));
+    target.set(data2.subarray(0, done));
     return { ptr, allocated: true };
   };
 }
@@ -11476,8 +11476,8 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
         stream.sliccProc = new capturedTextEncoder().encode(content());
       },
       read: (stream, buffer, offset, length, at) => {
-        const data = stream.sliccProc ?? new capturedUint8Array(0);
-        const chunk = data.subarray(at, at + length);
+        const data2 = stream.sliccProc ?? new capturedUint8Array(0);
+        const chunk = data2.subarray(at, at + length);
         buffer.set(chunk, offset);
         return chunk.length;
       },
@@ -11655,6 +11655,10 @@ var init_procfs = __esm({
 `,
         slicc_file_ids: (listing2) => `${listing2.fileIds ?? 0}
 `,
+        slicc_peer_holds: ({ holds }) => `${holds?.mine ?? 0} ${holds?.peers ?? 0} ${holds?.sent ?? 0}
+`,
+        slicc_peer_held: ({ holds }) => (holds?.held ?? []).map((path) => `${path}
+`).join(""),
         slicc_rename_acks: (listing2) => {
           const samples = [...listing2.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
           const median = samples[capturedMath.floor(samples.length / 2)] ?? 0;
@@ -12319,11 +12323,11 @@ var init_js_proc = __esm({
 });
 
 // src/process/js/js-rights.ts
-function sendmsgRequest(fd, data, options = {}) {
+function sendmsgRequest(fd, data2, options = {}) {
   return {
     op: "sock-sendmsg",
     fd,
-    body: typeof data === "string" ? encoder2.encode(data) : data,
+    body: typeof data2 === "string" ? encoder2.encode(data2) : data2,
     fds: options.fds ?? [],
     nonblock: options.nonblock === true
   };
@@ -12360,7 +12364,7 @@ async function blocked(kernel, watch, req) {
 function rightsAsync(kernel, forget, watch) {
   return {
     socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
-    sendmsg: async (fd, data, options) => jsonOf(await blocked(kernel, watch, sendmsgRequest(fd, data, options))),
+    sendmsg: async (fd, data2, options) => jsonOf(await blocked(kernel, watch, sendmsgRequest(fd, data2, options))),
     async recvmsg(fd, max, options) {
       const got = decodeReceived2(
         bytesOf2(await blocked(kernel, watch, recvmsgRequest(fd, max, options)))
@@ -12507,8 +12511,8 @@ function syncOps(kernel, shared) {
     const r = kernel.blocking({ op: "fd-read", fd, max: capturedMath.min(max, MAX_IO) });
     return r.ok && r.kind === "bytes" ? r.bytes : new capturedUint8Array(0);
   };
-  const write2 = (fd, data, options) => {
-    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
+  const write2 = (fd, data2, options) => {
+    const bytes = typeof data2 === "string" ? encoder4.encode(data2) : data2;
     const i = info(fd);
     if (writeDevice(i)) return bytes.length;
     const nonblock = options?.nonblock === true;
@@ -12599,7 +12603,7 @@ function syncOps(kernel, shared) {
       kernel.call({ op: "fd-close", fd });
     },
     socketpair: () => kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
-    sendmsg: (fd, data, options) => kernel.json(sendmsgRequest(fd, data, options)),
+    sendmsg: (fd, data2, options) => kernel.json(sendmsgRequest(fd, data2, options)),
     recvmsg(fd, max, options) {
       const got = decodeReceived2(kernel.bytes(recvmsgRequest(fd, max, options)));
       for (const n of got.fds) infos.delete(n);
@@ -12648,17 +12652,17 @@ function syncFile(kernel, fd, path, append, forget) {
     read(position, length) {
       return pread(position, length);
     },
-    write(position, data) {
+    write(position, data2) {
       index2(position, "write");
       let at = 0;
       do {
         live();
-        if (at >= data.length) break;
-        const body = data.subarray(at, at + MAX_IO);
+        if (at >= data2.length) break;
+        const body = data2.subarray(at, at + MAX_IO);
         const n = kernel.json(fileWrite(fd, append, position + at, body));
         if (!(n > 0)) throw new JsCallError("EIO", "write");
         at += n;
-      } while (at < data.length);
+      } while (at < data2.length);
       return at;
     },
     truncate(size) {
@@ -12743,7 +12747,7 @@ function syncPathOps(kernel, resolve2, statOf, open, clean) {
         return readWholeSync(open(devPath));
       }
     },
-    writeFile(path, data, options) {
+    writeFile(path, data2, options) {
       const mode = options?.mode;
       const file = open(path, {
         write: true,
@@ -12752,7 +12756,7 @@ function syncPathOps(kernel, resolve2, statOf, open, clean) {
         ...mode !== void 0 ? { mode } : {}
       });
       try {
-        file.write(0, typeof data === "string" ? encoder4.encode(data) : data);
+        file.write(0, typeof data2 === "string" ? encoder4.encode(data2) : data2);
       } finally {
         file.close();
       }
@@ -14226,8 +14230,8 @@ function createProcessKernel(deps) {
     },
     pause: () => status(call3({ op: "sig-pause" }, "pause")),
     sigInherited: () => inheritedOf(call3({ op: "sig-inherited" }, "sig-inherited")),
-    mount(source, target, type, flags, data) {
-      const req = { op: "mount", source, target: at(target), type, flags, data };
+    mount(source, target, type, flags, data2) {
+      const req = { op: "mount", source, target: at(target), type, flags, data: data2 };
       return status(call3(req, `mount ${target}`));
     },
     umount2(target, flags) {
@@ -15933,9 +15937,9 @@ function includesSelf(kernel, self, pid) {
 }
 function writer(kernel, info, pid) {
   const writes = new capturedSet();
-  const sendAll = async (fd, data, i, w, signal) => {
-    while (w.at < data.length) {
-      const body = data.subarray(w.at, w.at + MAX_IO);
+  const sendAll = async (fd, data2, i, w, signal) => {
+    while (w.at < data2.length) {
+      const body = data2.subarray(w.at, w.at + MAX_IO);
       w.len = body.length;
       try {
         w.at += signal ? await sendSome(kernel, fd, body, signal) : written(
@@ -15953,21 +15957,21 @@ function writer(kernel, info, pid) {
       }
     }
   };
-  const writeAll = async (fd, data, signal) => {
-    const w = { fd, data, at: 0, len: 0 };
+  const writeAll = async (fd, data2, signal) => {
+    const w = { fd, data: data2, at: 0, len: 0 };
     if (!signal) writes.add(w);
     try {
       const i = await info(fd);
       if (writeDevice(i)) return;
-      await sendAll(fd, data, i, w, signal);
+      await sendAll(fd, data2, i, w, signal);
     } finally {
       writes.delete(w);
     }
   };
-  const writeSome = async (fd, data) => {
+  const writeSome = async (fd, data2) => {
     const i = await info(fd);
-    if (writeDevice(i)) return data.length;
-    const body = data.subarray(0, MAX_IO);
+    if (writeDevice(i)) return data2.length;
+    const body = data2.subarray(0, MAX_IO);
     const r = await kernel.raw({ op: "fd-write", fd, body, nonblock: true });
     if (r.ok) return written(r, body.length);
     if (brokenPipe(callError(r, "fd-write"), i))
@@ -16051,10 +16055,10 @@ async function fifoOpen(kernel, abs, options, io) {
       seekless(position, "read");
       return io.read(fd, length);
     }),
-    async write(position, data) {
+    async write(position, data2) {
       seekless(position, "write");
-      await io.write(fd, data);
-      return data.length;
+      await io.write(fd, data2);
+      return data2.length;
     },
     async truncate() {
       live();
@@ -16145,10 +16149,10 @@ function pendingReads(kernel, info, random2) {
   return { read: read2, closing, watch };
 }
 function tracked2(pending, writeAll, writeSome, failed5) {
-  return (fd, data, options) => {
+  return (fd, data2, options) => {
     const status2 = failed5?.();
     if (status2 !== void 0) return capturedPromise.reject(new JsExit(status2));
-    const bytes = typeof data === "string" ? encoder5.encode(data) : data;
+    const bytes = typeof data2 === "string" ? encoder5.encode(data2) : data2;
     let settle;
     const settled2 = new capturedPromise((resolve2) => settle = resolve2);
     pending.add(settled2);
@@ -16415,17 +16419,17 @@ function fileHandle(kernel, fd, path, append, forget) {
     async read(position, length) {
       return await pread(position, length);
     },
-    async write(position, data) {
+    async write(position, data2) {
       index2(position, "write");
       let at = 0;
       do {
         live();
-        if (at >= data.length) break;
-        const body = data.subarray(at, at + MAX_IO);
+        if (at >= data2.length) break;
+        const body = data2.subarray(at, at + MAX_IO);
         const n = await kernel.json(fileWrite(fd, append, position + at, body));
         if (!(n > 0)) throw new JsCallError("EIO", "write");
         at += n;
-      } while (at < data.length);
+      } while (at < data2.length);
       return at;
     },
     async truncate(size) {
@@ -16535,7 +16539,7 @@ function pathOps(kernel, resolve2, statOf, open, clean) {
         return readWhole(await open(devPath));
       }
     },
-    async writeFile(path, data, options) {
+    async writeFile(path, data2, options) {
       const mode = options?.mode;
       const file = await open(
         path,
@@ -16543,7 +16547,7 @@ function pathOps(kernel, resolve2, statOf, open, clean) {
         true
       );
       try {
-        await file.write(0, typeof data === "string" ? encoder5.encode(data) : data);
+        await file.write(0, typeof data2 === "string" ? encoder5.encode(data2) : data2);
       } finally {
         await file.close();
       }
@@ -17132,9 +17136,9 @@ var init_wasi_signals = __esm({
           this.libcDefault = outer.libc;
         }
       }
-      muted(fd, data) {
+      muted(fd, data2) {
         if (fd !== 2 || this.delivering === void 0) return false;
-        if (!WASIX_LIBC_DEFAULT_LINE.test(new capturedTextDecoder().decode(data))) return false;
+        if (!WASIX_LIBC_DEFAULT_LINE.test(new capturedTextDecoder().decode(data2))) return false;
         this.libcDefault = true;
         return true;
       }
@@ -17306,8 +17310,8 @@ var init_wasix_fork = __esm({
       fork(fork) {
         const sp = this.stackPointer();
         const globals = this.globals();
-        return this.unwind((data) => {
-          this.answer = fork(data, globals, sp);
+        return this.unwind((data2) => {
+          this.answer = fork(data2, globals, sp);
         });
       }
       checkpoint(snapPtr, retPtr) {
@@ -17317,9 +17321,9 @@ var init_wasix_fork = __esm({
         v.setBigUint64(snapPtr + 8, capturedBigInt(id), true);
         v.setBigUint64(snapPtr + 16, 0x51cc5117n, true);
         const globals = this.globals();
-        return this.unwind((data) => {
-          const end = this.mem.view().getUint32(data, true);
-          this.snapshots.set(id, { frames: this.mem.bytes(data + 8, end - data - 8).slice(), globals });
+        return this.unwind((data2) => {
+          const end = this.mem.view().getUint32(data2, true);
+          this.snapshots.set(id, { frames: this.mem.bytes(data2 + 8, end - data2 - 8).slice(), globals });
           this.answer = 0;
         });
       }
@@ -17327,9 +17331,9 @@ var init_wasix_fork = __esm({
         const id = capturedNumber(this.mem.view().getBigUint64(snapPtr + 8, true));
         const snap = this.snapshots.get(id);
         if (!snap) throw new capturedError(`WASIX: longjmp to an unknown setjmp (${id})`);
-        return this.unwind((data) => {
-          this.mem.bytes(data + 8, snap.frames.length).set(snap.frames);
-          this.mem.view().setUint32(data, data + 8 + snap.frames.length, true);
+        return this.unwind((data2) => {
+          this.mem.bytes(data2 + 8, snap.frames.length).set(snap.frames);
+          this.mem.view().setUint32(data2, data2 + 8 + snap.frames.length, true);
           this.restoreGlobals(snap.globals);
           this.answer = capturedNumber(val) || 1;
         });
@@ -17357,15 +17361,15 @@ var init_wasix_fork = __esm({
       }
       unwind(then) {
         if (!this.supported) return E.NOSYS;
-        const data = this.dataPointer();
+        const data2 = this.dataPointer();
         const v = this.mem.view();
-        v.setUint32(data, data + 8, true);
-        v.setUint32(data + 4, this.stackPointer() - 16, true);
+        v.setUint32(data2, data2 + 8, true);
+        v.setUint32(data2 + 4, this.stackPointer() - 16, true);
         this.pending = () => {
-          then(data);
-          return data;
+          then(data2);
+          return data2;
         };
-        this.exports.asyncify_start_unwind?.(data);
+        this.exports.asyncify_start_unwind?.(data2);
         return E.SUCCESS;
       }
       restoreGlobals(globals) {
@@ -19284,7 +19288,7 @@ async function runWasiProcess(init, port3) {
   host.signals = signals;
   wireSignals(host, gate);
   host.onRaise = (sig) => signals.raised(sig);
-  host.muted = (fd, data) => signals.muted(fd, data);
+  host.muted = (fd, data2) => signals.muted(fd, data2);
   const exports = instance.exports;
   driver.bind(instance.exports);
   const entry = fork?.entry;
@@ -19693,10 +19697,11 @@ function workerShaped(scope2, href) {
     location: slot2(capturedObject.freeze({ href }))
   });
 }
-function ownCache(dir, result) {
+function ownCache(dir, result, optional = false) {
   const active = result.directory;
   if (active === void 0) return false;
   if (!`${resolve(active)}${sep}`.startsWith(`${resolve(dir)}${sep}`)) {
+    if (optional) return false;
     throw new capturedError(
       `slicc-kernel: compileCache ${dir} was asked for, but this worker already caches in ${active} (a host preload enabled it): refusing to run programs`
     );
@@ -19951,30 +19956,30 @@ function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs,
     }
     return refused3;
   };
-  return (data) => {
-    const type = data?.type;
+  return (data2) => {
+    const type = data2?.type;
     if (type !== WASM_THREAD_INIT && type !== WASM_PROCESS_INIT && type !== JS_THREAD_INIT) return;
     const refusal2 = sealOnce();
     if (type === JS_THREAD_INIT) {
       if (refusal2) return failed5(refusal2.error);
       js().then((m) => {
         if (!m.runJsThread) throw new capturedError("this process worker runs no JS threads");
-        return m.runJsThread(data, port3);
+        return m.runJsThread(data2, port3);
       }).then(
         (code2) => port3.postMessage({ type: JS_THREAD_EXIT, code: code2 }),
         failed5
       );
       return;
     }
-    const init = data;
+    const init = data2;
     if (type === WASM_THREAD_INIT || init?.program?.abi !== "js") useLocalClock(init?.sab);
     if (type === WASM_THREAD_INIT) {
       if (refusal2) return failed5(refusal2.error);
-      wasi().then((m) => m.runWasiThread(data, port3)).catch(failed5);
+      wasi().then((m) => m.runWasiThread(data2, port3)).catch(failed5);
       return;
     }
     if (refusal2) return failed5(refusal2.error, NOT_RUNNABLE2);
-    started2(data, port3, run, wasi, js).then(
+    started2(data2, port3, run, wasi, js).then(
       (code2) => port3.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
       failed5
     );
@@ -19988,8 +19993,9 @@ var scope = capturedGlobalThis;
 scope.require ??= createRequire(import.meta.url);
 scope.__filename ??= new capturedURL(import.meta.url).pathname;
 scope.__dirname ??= new capturedURL(".", import.meta.url).pathname;
-var cacheDir = workerData?.compileCache;
-var cached = typeof cacheDir === "string" && ownCache(cacheDir, enableCompileCache(cacheDir));
+var data = workerData;
+var cacheDir = data?.compileCache;
+var cached = typeof cacheDir === "string" && ownCache(cacheDir, enableCompileCache(cacheDir), data?.ownedCache === true);
 var imported = cached ? () => flushCompileCache() : void 0;
 var port2 = parentPort;
 var post2 = {