@ai-ecoverse/slicc-kernel 1.178.2 → 1.178.4

package/dist/node-process-worker.cjs

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

package/dist/node-process-worker.js

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

package/dist/node.js

@@ -868,13 +868,6 @@ async function linkable(g, from, to, follow2) {
   }
   await inParent(g, "link", to);
 }
-async function ownerOnly(g, op, path, follow2) {
-  const walked = await need(g, op, path, 0, { follow: follow2 });
-  const perm = walked.perm;
-  if (!perm || g.cred.euid === 0 || perm.uid === g.cred.euid) return walked;
-  if (await present(g.fs, walked.path, false)) deny(g, op, path, "EPERM");
-  return walked;
-}
 async function chmodMode(g, path, mode) {
   const walked = await need(g, "chmod", path, 0, { follow: true });
   const perm = walked.perm;
@@ -896,17 +889,26 @@ function heldChmodMode(g, path, st, mode) {
 function heldRetimable(g, path, st, now) {
   const perm = permOf(st);
   if (g.cred.euid === 0 || perm.uid === g.cred.euid) return;
-  if (!now) deny(g, "futimens", path, "EPERM");
-  else if (!permits(g.cred, perm, W_OK, false)) deny(g, "futimens", path);
+  if (now || st.fat) {
+    if (!permits(g.cred, perm, W_OK, false)) deny(g, "futimens", path);
+    return;
+  }
+  deny(g, "futimens", path, "EPERM");
 }
 async function retimable(g, op, path, now = false) {
   const follow2 = op !== "lutimes";
-  if (!now) return void await ownerOnly(g, op, path, follow2);
   const walked = await need(g, op, path, 0, { follow: follow2 });
   const perm = walked.perm;
   if (!perm || g.cred.euid === 0 || perm.uid === g.cred.euid) return;
-  if (permits(g.cred, perm, W_OK, false)) return;
-  if (await present(g.fs, walked.path, false)) deny(g, op, path);
+  const look = follow2 ? g.fs.stat : g.fs.lstat;
+  const st = await look.call(g.fs, walked.path).catch(() => void 0);
+  if (now || st?.fat) {
+    if (!permits(g.cred, perm, W_OK, false) && await present(g.fs, walked.path, false)) {
+      deny(g, op, path);
+    }
+    return;
+  }
+  if (await present(g.fs, walked.path, false)) deny(g, op, path, "EPERM");
 }
 async function fileWritable(g, op, path) {
   await need(g, op, path, W_OK, { directory: false });
@@ -3709,7 +3711,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.178.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.178.4" : "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
@@ -12773,11 +12775,11 @@ function systemFile(name2, listing, now, memory) {
       listing.processes.reduce((sum2, p) => sum2 + p.memory, 0)
     );
   }
-  const live = listing.processes.filter((p) => p.state !== "Z");
+  const live2 = listing.processes.filter((p) => p.state !== "Z");
   if (name2 === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
     const [one, five, fifteen] = (listing.load ?? [0, 0, 0]).map((n) => n.toFixed(2));
-    return `${one} ${five} ${fifteen} 1/${live.length} ${last}
+    return `${one} ${five} ${fifteen} 1/${live2.length} ${last}
 `;
   }
   const sum = (key) => listing.cpu?.[key] ?? listing.processes.reduce((n, p) => n + (p[key] ?? 0), 0);
@@ -15266,30 +15268,49 @@ function timestampKey(owner, type) {
   }
   return parent ? JSON.stringify(["ppid", parent.pid, parent.started]) : void 0;
 }
+function boundKey(bound3) {
+  return JSON.stringify(
+    Object.keys(bound3).sort().map((path) => [path, bound3[path]])
+  );
+}
+function writable2(bound3) {
+  return bound3 !== void 0 && Object.keys(bound3).length > 0;
+}
+function live(stamp, policy, now) {
+  return stamp.at <= now && (policy.minutes < 0 || now - stamp.at < policy.minutes * MINUTE_MS2);
+}
 var Timestamps = class {
   users = /* @__PURE__ */ new Map();
   now;
   constructor(now) {
     this.now = now;
   }
-  current(owner, policy) {
+  current(owner, policy, bound3) {
     if (policy.minutes === 0) return false;
     const key = timestampKey(owner, policy.type);
-    const at = key === void 0 ? void 0 : this.users.get(owner.uid)?.get(key);
-    if (at === void 0) return false;
+    const stamp = key === void 0 ? void 0 : this.users.get(owner.uid)?.get(key);
+    if (stamp === void 0) return false;
     const now = this.now();
-    return at <= now && (policy.minutes < 0 || now - at < policy.minutes * MINUTE_MS2);
+    if (!live(stamp, policy, now)) {
+      this.drop(owner.uid, key);
+      return false;
+    }
+    if (!writable2(bound3)) return true;
+    return stamp.covered.has(boundKey(bound3));
   }
-  stamp(owner, policy) {
+  stamp(owner, policy, bound3) {
     const key = policy.minutes === 0 ? void 0 : timestampKey(owner, policy.type);
     if (key === void 0) return false;
     const now = this.now();
     const records = this.users.get(owner.uid) ?? /* @__PURE__ */ new Map();
     this.users.set(owner.uid, records);
+    const prior = records.get(key);
+    const covered = prior !== void 0 && live(prior, policy, now) ? prior.covered : /* @__PURE__ */ new Set();
+    if (writable2(bound3)) covered.add(boundKey(bound3));
     records.delete(key);
-    records.set(key, now);
-    for (const [old, at] of records) {
-      const stale = policy.minutes > 0 && (at > now || now - at >= policy.minutes * MINUTE_MS2);
+    records.set(key, { at: now, covered });
+    for (const [old, stamp] of records) {
+      const stale = policy.minutes > 0 && !live(stamp, policy, now);
       if (stale || records.size > TIMESTAMPS_MAX) records.delete(old);
     }
     return true;
@@ -15303,6 +15324,11 @@ var Timestamps = class {
   remove(uid) {
     this.users.delete(uid);
   }
+  drop(uid, key) {
+    const records = this.users.get(uid);
+    records?.delete(key);
+    if (records?.size === 0) this.users.delete(uid);
+  }
 };
 
 // src/sudoers.ts
@@ -16309,12 +16335,12 @@ function usable(parsed2) {
 function policyOf(settings) {
   return { type: settings.timestampType, minutes: settings.timestampTimeout };
 }
-function described(rule, writable2) {
+function described(rule, writable3) {
   const cmnd = rule.cmnd === "*" ? "ALL" : commandText(rule.cmnd);
   const cwd = rule.cwd === void 0 ? "" : `CWD=${quoteWord(rule.cwd)} `;
   const stdin = rule.stdin === void 0 ? "" : "STDIN=none ";
   const sums = Object.entries(rule.sha256 ?? {}).map(([path, hex4]) => `SHA256=${quoteWord(path)}:${hex4} `).join("");
-  const flag = writable2 ? "  # user-writable command" : "";
+  const flag = writable3 ? "  # user-writable command" : "";
   return `    (${rule.target}) ${cwd}${stdin}${sums}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}${flag}`;
 }
 var Sudo = class {
@@ -16607,8 +16633,8 @@ var Sudo = class {
         `sudo: ${self.name} is not allowed to run ${quoted} as ${target.name}`
       );
     }
-    if (!parsed2.reset && this.timestamps.current(s.owner, s.policy)) {
-      this.timestamps.stamp(s.owner, s.policy);
+    if (!parsed2.reset && this.timestamps.current(s.owner, s.policy, bound3)) {
+      this.timestamps.stamp(s.owner, s.policy, bound3);
       this.logged(s, cwd, argv);
       return grant();
     }
@@ -16623,7 +16649,7 @@ var Sudo = class {
       if (!now) return failed2("ENOENT", `sudo: ${word}: command not found`);
       const shown2 = recordable(cwd, [...parsed2.command, ...Object.keys(bound3)]);
       const result = answer2.answer === "once" ? grant() : await this.always(self, target, { cwd, argv, bound: bound3 }, now, shown2, grant);
-      if (!("error" in result)) this.stamped(s, answer2);
+      if (!("error" in result)) this.stamped(s, answer2, bound3);
       return result;
     });
   }
@@ -16657,8 +16683,8 @@ var Sudo = class {
       this.pending.delete(uid);
     }
   }
-  stamped(s, answer2) {
-    if (answer2.person && !s.parsed.reset) this.timestamps.stamp(s.owner, s.policy);
+  stamped(s, answer2, bound3 = {}) {
+    if (answer2.person && !s.parsed.reset) this.timestamps.stamp(s.owner, s.policy, bound3);
   }
   logged(s, cwd, argv) {
     const { caller, self, target, owner, policy } = s;
@@ -22858,18 +22884,18 @@ var VfsNodes = class {
     if (id2 !== void 0) this.know(node, id2);
     return node;
   }
-  open(path, pin, writable2 = false, id2, ino) {
+  open(path, pin, writable3 = false, id2, ino) {
     const found = this.named(path, id2);
     const same2 = !found || ino === void 0 || found.ino === void 0 || found.ino === ino;
     if (found && !same2) this.orphan(found);
     const node = (same2 ? found : void 0) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
     node.ino ??= ino;
     node.opens++;
-    if (writable2) node.writers++;
+    if (writable3) node.writers++;
     if (node.opens === 1) this.opened?.(node);
     return node;
   }
-  adopt(path, contents2, dirty, writable2 = false, id2) {
+  adopt(path, contents2, dirty, writable3 = false, id2) {
     let node = this.named(path, id2);
     if (!node) {
       node = this.create(path, id2, new VfsNode(this.fs, path, contents2, false, dirty));
@@ -22877,7 +22903,7 @@ var VfsNodes = class {
       node.replace(contents2);
     }
     node.opens++;
-    if (writable2) node.writers++;
+    if (writable3) node.writers++;
     if (node.opens === 1) this.opened?.(node);
     return node;
   }
@@ -22890,11 +22916,11 @@ var VfsNodes = class {
       if (node.writers > 0 && within7(path, prefix)) return true;
     return false;
   }
-  closed(node, writable2 = false) {
+  closed(node, writable3 = false) {
     node.opens--;
-    if (writable2) node.writers--;
+    if (writable3) node.writers--;
     if (node.opens > 0) {
-      if (writable2 && node.writers === 0) this.onClosed?.(node.path);
+      if (writable3 && node.writers === 0) this.onClosed?.(node.path);
       return;
     }
     this.forget(node);
@@ -23213,8 +23239,8 @@ function keepingOpen(fs, nodes, changed = () => {
 function vfsFile(fs, opts, nodes) {
   const access2 = opts.flags & O_ACCMODE;
   const readable2 = access2 !== O_WRONLY;
-  const writable2 = access2 === O_WRONLY || access2 === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id, opts.ino);
+  const writable3 = access2 === O_WRONLY || access2 === O_RDWR;
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable3, opts.id) : nodes.open(opts.path, opts.pin, writable3, opts.id, opts.ino);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -23241,7 +23267,7 @@ function vfsFile(fs, opts, nodes) {
       offset += out.length;
       return out;
     }) : void 0,
-    write: writable2 ? (bytes) => serial(async () => {
+    write: writable3 ? (bytes) => serial(async () => {
       if (opts.flags & O_APPEND) offset = await node.append(bytes);
       else offset += await node.pwrite(bytes, offset);
       return bytes.length;
@@ -23260,11 +23286,11 @@ function vfsFile(fs, opts, nodes) {
       return node.pread(max, at);
     }),
     pwrite: (bytes, at) => serial(() => {
-      if (!writable2) throw new KernelError("EBADF");
+      if (!writable3) throw new KernelError("EBADF");
       return node.pwrite(bytes, at);
     }),
     resize: (size) => serial(() => {
-      if (!writable2) throw new KernelError("EBADF");
+      if (!writable3) throw new KernelError("EBADF");
       return node.truncate(size);
     }),
     stat: () => serial(async () => ({
@@ -23280,7 +23306,7 @@ function vfsFile(fs, opts, nodes) {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node, writable2);
+        nodes?.closed(node, writable3);
       }
     })
   });
@@ -25009,8 +25035,8 @@ var WasmProcess = class {
   };
   withDl(state) {
     if (this.dlLog.length === 0) return state;
-    const { next: next3, handle, free, live } = this.closures;
-    const dl = { log: [...this.dlLog], next: next3, handle, free: [...free], live: [...live] };
+    const { next: next3, handle, free, live: live2 } = this.closures;
+    const dl = { log: [...this.dlLog], next: next3, handle, free: [...free], live: [...live2] };
     return { ...state, dl };
   }
   seedDl(dl) {
@@ -26228,8 +26254,8 @@ var RemoteWatch = class {
     const { held = [], pending = [] } = await this.locks.query();
     if (![...held, ...pending].some((lock) => lock.name === name2)) {
       this.mourned.delete(peer);
-      const live = this.peers.has(peer) || this.flushes.has(peer);
-      if (tries > 1 && live) {
+      const live2 = this.peers.has(peer) || this.flushes.has(peer);
+      if (tries > 1 && live2) {
         setTimeout(() => void this.mourn(peer, tries - 1), MOURN_RETRY_MS);
       } else this.flushedAt(peer);
       return;
@@ -28437,11 +28463,11 @@ async function positioned(handle, op) {
     }
     return;
   }
-  const writable2 = await handle.createWritable({ keepExistingData: true });
+  const writable3 = await handle.createWritable({ keepExistingData: true });
   try {
     await op({
       write: async (at, bytes) => {
-        await writable2.write({
+        await writable3.write({
           type: "write",
           position: at,
           data: bytes
@@ -28449,15 +28475,15 @@ async function positioned(handle, op) {
         extent.wrote(at + bytes.length);
       },
       truncate: async (n) => {
-        await writable2.truncate(n);
+        await writable3.truncate(n);
         extent.cut(n);
       }
     });
   } catch (err) {
-    await writable2.abort();
+    await writable3.abort();
     throw err;
   }
-  await writable2.close();
+  await writable3.close();
   if (extent.big()) extent.check((await handle.getFile()).size);
 }
 function isHandle(child) {
@@ -29539,21 +29565,21 @@ var OpfsFs = class {
   }
   async writeSession(path, truncate) {
     const [handle, , target] = await this.fileFor(path);
-    const writable2 = await this.retrying(
+    const writable3 = await this.retrying(
       path,
       () => this.io(handle.createWritable({ keepExistingData: !truncate })),
       true
     );
     return {
-      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }).catch((err) => {
+      write: (at, bytes) => writable3.write({ type: "write", position: at, data: bytes }).catch((err) => {
         throw translate(err, path, "write", false);
       }),
-      truncate: (size) => writable2.truncate(size).catch((err) => {
+      truncate: (size) => writable3.truncate(size).catch((err) => {
         throw translate(err, path, "write", false);
       }),
       close: async () => {
         this.wrote(handle);
-        await writable2.close().catch((err) => {
+        await writable3.close().catch((err) => {
           this.wrote(handle);
           throw translate(err, path, "commit", false);
         });
@@ -29605,19 +29631,19 @@ var OpfsFs = class {
     const [file, existed, target] = await this.fileFor(path, owner?.existing !== true);
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
-    let writable2;
+    let writable3;
     this.wrote(file);
     try {
-      writable2 = await this.io(file.createWritable());
-      await writable2.write(content);
-      await writable2.close();
+      writable3 = await this.io(file.createWritable());
+      await writable3.write(content);
+      await writable3.close();
       if (typeof content !== "string" && content.length >= CHECKED_BYTES) {
         const extent = new Extent();
         extent.cut(content.length);
         extent.check((await file.getFile()).size);
       }
     } catch (err) {
-      await writable2?.abort().catch(() => void 0);
+      await writable3?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
     } finally {
       this.wrote(file);
@@ -30342,7 +30368,7 @@ var OpfsFs = class {
       created4 = true;
     }
     let target = destination;
-    let writable2;
+    let writable3;
     let handle;
     try {
       const kept = created4 ? this.files.get(destination) : void 0;
@@ -30361,11 +30387,11 @@ var OpfsFs = class {
         if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
       }
       this.wrote(handle);
-      writable2 = await handle.createWritable();
-      await writable2.write(file);
-      await writable2.close();
+      writable3 = await handle.createWritable();
+      await writable3.write(file);
+      await writable3.close();
     } catch (err) {
-      await writable2?.abort().catch(() => void 0);
+      await writable3?.abort().catch(() => void 0);
       if (created4) await this.rm(target, { file: true }).catch(() => void 0);
       throw translate(err, to, "commit", false);
     } finally {
@@ -30454,10 +30480,10 @@ var OpfsFs = class {
     }
     if (handle.kind === "file") {
       const made2 = await this.io(dir.getFileHandle(name2, { create: true }));
-      const writable2 = await this.io(made2.createWritable());
+      const writable3 = await this.io(made2.createWritable());
       const file = await this.io(handle.getFile());
-      await writable2.write(file);
-      await writable2.close();
+      await writable3.write(file);
+      await writable3.close();
       copies?.set(rest2, { before: copies.get(rest2)?.before ?? file.lastModified, made: made2 });
       return;
     }
@@ -31169,7 +31195,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     if (remote.client.token === remote.token && !remote.client.gone) return remote;
     throw fsError2("ESTALE", "the folder was granted again, so this open file is gone");
   };
-  const live = (fh) => {
+  const live2 = (fh) => {
     const remote = handles.get(fh);
     if (!remote) throw fsError2("EBADF", `handle ${fh}`);
     return fresh3(remote);
@@ -31188,7 +31214,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     }, againMs);
     timer.unref?.();
   });
-  async function writable2(client, path, flags2) {
+  async function writable3(client, path, flags2) {
     const { ifMatch: _, ...asked } = flags2;
     const opening2 = () => client.call("open", { path: rel(path), ...asked });
     try {
@@ -31219,7 +31245,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     async open(path, flags2) {
       const client = current();
       const token = client.token;
-      const { opened: opened2, restore } = await writable2(client, path, flags2);
+      const { opened: opened2, restore } = await writable3(client, path, flags2);
       if (flags2.ifMatch !== void 0 && opened2.attr?.etag !== flags2.ifMatch) {
         await client.call("release", { fh: opened2.fh }, true);
         throw fsError2("ESTALE", `${path} changed on the host while it was being read`);
@@ -31234,7 +31260,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       return nextFh;
     },
     async read(fh, offset, size) {
-      const remote = live(fh);
+      const remote = live2(fh);
       return remote.client.read(
         remote.fh,
         offset,
@@ -31243,7 +31269,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       );
     },
     async write(fh, offset, bytes) {
-      const remote = live(fh);
+      const remote = live2(fh);
       const most = remote.client.maxIo;
       for (let at = 0; at < bytes.length; at += most) {
         await remote.client.write(remote.fh, offset + at, bytes.subarray(at, at + most));
@@ -37250,7 +37276,7 @@ function dialStream(port, onClose) {
     else finish(errorWithCode(data.error));
   });
   port.start?.();
-  const writable2 = new WritableStream({
+  const writable3 = new WritableStream({
     write(chunk2) {
       if (closed) throw errorWithCode("EPIPE: the connection is closed");
       const copy = fresh(chunk2);
@@ -37269,7 +37295,7 @@ function dialStream(port, onClose) {
     shut();
     finish(error);
   };
-  return { readable: readable2, writable: writable2, close, fail: fail3 };
+  return { readable: readable2, writable: writable3, close, fail: fail3 };
 }
 
 // src/client/loopback-fetch.ts
@@ -37695,10 +37721,10 @@ function endedOf(done4, signal) {
 async function runOn(channel, argv, opts) {
   const { onStdout, onStderr, ...rest2 } = opts;
   const chunks2 = { 1: [], 2: [] };
-  const live = { 1: new TextDecoder(), 2: new TextDecoder() };
+  const live2 = { 1: new TextDecoder(), 2: new TextDecoder() };
   const tee = (fd, on) => (bytes) => {
     chunks2[fd].push(bytes);
-    on?.(live[fd].decode(bytes, { stream: true }));
+    on?.(live2[fd].decode(bytes, { stream: true }));
   };
   const child = await spawnOn(channel, argv, {
     ...rest2,
@@ -37913,7 +37939,7 @@ var TERMINATED = "the kernel is terminated";
 var EXIT_GRACE_MS = 50;
 var WARM_IDLE_MS = 3e4;
 var MAX_WARM_WORKERS = 64;
-function warmPool(make, live, idleMs = WARM_IDLE_MS, size = 1) {
+function warmPool(make, live2, idleMs = WARM_IDLE_MS, size = 1) {
   const spares = [];
   let idle2;
   let closed = false;
@@ -37923,7 +37949,7 @@ function warmPool(make, live, idleMs = WARM_IDLE_MS, size = 1) {
     spares.splice(at, 1);
     if (spares.length > 0) return;
     clearTimeout(idle2);
-    live.delete(kill);
+    live2.delete(kill);
   };
   const kill = () => {
     for (const worker of [...spares]) {
@@ -37944,7 +37970,7 @@ function warmPool(make, live, idleMs = WARM_IDLE_MS, size = 1) {
       worker.once("error", () => drop(worker));
       worker.once("exit", () => drop(worker));
       spares.push(worker);
-      live.add(kill);
+      live2.add(kill);
     }
     clearTimeout(idle2);
     idle2 = setTimeout(kill, idleMs);
@@ -38017,12 +38043,12 @@ function sourceModule(source) {
   return { url, source, revoke: () => {
   } };
 }
-function warmPoolOf(options, file, workerData, live) {
+function warmPoolOf(options, file, workerData, live2) {
   const size = sparesOf(options);
   if (size === 0) return void 0;
-  return warmPool(() => processWorker(file, workerData, true), live, WARM_IDLE_MS, size);
+  return warmPool(() => processWorker(file, workerData, true), live2, WARM_IDLE_MS, size);
 }
-function nodeWorker(file, live, closed, workerData, take, internals = false) {
+function nodeWorker(file, live2, closed, workerData, take, internals = false) {
   const errors = /* @__PURE__ */ new Set();
   const messages = /* @__PURE__ */ new Map();
   const fail3 = (message3) => {
@@ -38039,9 +38065,9 @@ function nodeWorker(file, live, closed, workerData, take, internals = false) {
       void worker.terminate();
       fail3(TERMINATED);
     };
-    live.add(kill);
+    live2.add(kill);
     worker.once("exit", (code) => {
-      live.delete(kill);
+      live2.delete(kill);
       setTimeout(() => {
         if (!ending) fail3(`the process worker exited with ${code}`);
       }, EXIT_GRACE_MS);
@@ -38198,23 +38224,23 @@ async function createNodeKernel(options = {}) {
   const root = options.root ?? memoryRoot();
   const fs = new OpfsFs(root, void 0, void 0, { ranged: isMemoryRoot(root) });
   await fs.reconcile();
-  const live = /* @__PURE__ */ new Set();
+  const live2 = /* @__PURE__ */ new Set();
   const pending = /* @__PURE__ */ new Set();
   const clients = /* @__PURE__ */ new Set();
   let terminated = false;
   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);
+  const warm = warmPoolOf(options, file, workerData, live2);
   const transport = options.network?.transport;
   const launcher = new Launcher({
     fs,
     moduleUrl: sourceModule,
     unlinkOwner: pidOwner(process),
-    createWorker: () => nodeWorker(file, live, terminated, workerData, warm ? () => warm.take() : void 0, true),
+    createWorker: () => nodeWorker(file, live2, terminated, workerData, warm ? () => warm.take() : void 0, true),
     createDriverWorker: () => nodeWorker(
       options.driverWorker ?? new URL("./node-driver-worker.js", import.meta.url),
-      live,
+      live2,
       terminated
     ),
     ...options.modules ? { modules: options.modules } : {},
@@ -38345,7 +38371,7 @@ async function createNodeKernel(options = {}) {
       warm?.close();
       for (const client of [...clients]) client.detach();
       for (const reject of [...pending]) reject(new Error(TERMINATED));
-      for (const kill of [...live]) kill();
+      for (const kill of [...live2]) kill();
       launcher.cdp.close();
       launcher.endFills();
       launcher.unmountAll();