@ai-ecoverse/slicc-kernel 1.41.0 → 1.41.1

package/dist/node.js

@@ -800,8 +800,8 @@ var KernelSocket = class _KernelSocket {
   async accept(signal, nonblock = false) {
     for (; ; ) {
       if (this.state !== "listening") throw new KernelError("EINVAL");
-      const next = this.queue.shift();
-      if (next) return next;
+      const next2 = this.queue.shift();
+      if (next2) return next2;
       if (nonblock) throw new KernelError("EAGAIN");
       await this.changes.wait(signal);
     }
@@ -982,8 +982,8 @@ var LoopbackNet = class {
     if (reserve) this.internal.add(port);
     return this.internal.has(port);
   }
-  activate(addr, start) {
-    this.activators.set(keyOf(addr), start);
+  activate(addr, start2) {
+    this.activators.set(keyOf(addr), start2);
   }
   socket(domain) {
     return new KernelSocket(this, domain);
@@ -1242,12 +1242,12 @@ var MessageQueue = class {
   }
   async *[Symbol.asyncIterator]() {
     for (; ; ) {
-      const next = this.items.shift();
-      if (next !== void 0) {
-        const n = payloadSize(next);
+      const next2 = this.items.shift();
+      if (next2 !== void 0) {
+        const n = payloadSize(next2);
         this.size -= n;
         this.taken?.(n);
-        yield next;
+        yield next2;
         continue;
       }
       if (this.ended) return;
@@ -1352,8 +1352,8 @@ async function* chunks(body, idleMs) {
   if (!body) return;
   const reader = body.getReader();
   try {
-    for (let next = await readWithin(reader, idleMs); !next.done; next = await readWithin(reader, idleMs)) {
-      if (next.value.byteLength > 0) yield next.value;
+    for (let next2 = await readWithin(reader, idleMs); !next2.done; next2 = await readWithin(reader, idleMs)) {
+      if (next2.value.byteLength > 0) yield next2.value;
     }
   } finally {
     await reader.cancel().catch(() => void 0);
@@ -1424,7 +1424,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
       ...typeof code === "string" ? { code } : {}
     });
   };
-  const start = async (call) => {
+  const start2 = async (call) => {
     const abort = new AbortController();
     const entry = { abort };
     open.set(call.nid, entry);
@@ -1503,9 +1503,9 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
     try {
       const messages = socket.messages[Symbol.asyncIterator]();
       for (; ; ) {
-        const next = await Promise.race([messages.next(), unanswered]);
-        if (next === "late" || next.done) break;
-        const data = next.value;
+        const next2 = await Promise.race([messages.next(), unanswered]);
+        if (next2 === "late" || next2.done) break;
+        const data = next2.value;
         if (flow.closing) continue;
         if (payloadSize(data) > MESSAGE_LIMIT) {
           oversize = true;
@@ -1546,12 +1546,12 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
     const body = open.get(nid)?.body;
     if (!body) return;
     try {
-      const next = await body.next();
-      if (next.done) {
+      const next2 = await body.next();
+      if (next2.done) {
         open.delete(nid);
         peer.postMessage({ net: "end", nid });
       } else {
-        const bytes = next.value.slice();
+        const bytes = next2.value.slice();
         peer.postMessage({ net: "chunk", nid, bytes }, [bytes.buffer]);
       }
     } catch (e) {
@@ -1568,7 +1568,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   };
   return {
     answer(call) {
-      if (call.net === "fetch") void start(call);
+      if (call.net === "fetch") void start2(call);
       else if (call.net === "read") void read(call.nid);
       else if (call.net === "ws-open") void openSocket(call);
       else if (call.net === "ws-send") void sendOn(call);
@@ -1623,17 +1623,17 @@ async function realpath(fs, path) {
   let parts = fs.resolvePath("/", path).split("/").filter(Boolean);
   let resolved = "";
   for (let hops = 0; parts.length > 0; ) {
-    const [name2, ...rest] = parts;
-    const next = `${resolved}/${name2}`;
-    if (!(await fs.lstat(next)).isSymbolicLink) {
-      resolved = next;
-      parts = rest;
+    const [name2, ...rest2] = parts;
+    const next2 = `${resolved}/${name2}`;
+    if (!(await fs.lstat(next2)).isSymbolicLink) {
+      resolved = next2;
+      parts = rest2;
       continue;
     }
     if (++hops > MAX_LINKS) throw fsError("ELOOP", path);
-    const target = await fs.readlink(next);
+    const target = await fs.readlink(next2);
     const base = target.startsWith("/") ? "/" : resolved || "/";
-    parts = [...fs.resolvePath(base, target).split("/").filter(Boolean), ...rest];
+    parts = [...fs.resolvePath(base, target).split("/").filter(Boolean), ...rest2];
     resolved = "";
   }
   return resolved || "/";
@@ -2079,8 +2079,8 @@ var OpfsFs = class {
   resolvePath(base, path) {
     return resolvePath(base, path);
   }
-  async walk(parts, from, start) {
-    let dir = start;
+  async walk(parts, from, start2) {
+    let dir = start2;
     for (let at = from; at < parts.length; at++) {
       dir = await dir.getDirectoryHandle(parts[at]);
       this.dirs.set(`/${parts.slice(0, at + 1).join("/")}`, dir);
@@ -2166,7 +2166,7 @@ var OpfsFs = class {
     }
     return void 0;
   }
-  async locate(path, follow) {
+  async locate(path, follow2) {
     let current = path;
     for (let hops = 0; hops <= MAX_LINKS2; hops++) {
       try {
@@ -2175,9 +2175,9 @@ var OpfsFs = class {
         if (!missing(err)) throw err;
         const link2 = await this.linkAlong(current);
         if (!link2) throw err;
-        if (link2.path === current && !follow) return { path: current, link: link2 };
-        const rest = current.slice(link2.path.length);
-        current = resolvePath(parentOf2(link2.path), `${link2.link}${rest}`);
+        if (link2.path === current && !follow2) return { path: current, link: link2 };
+        const rest2 = current.slice(link2.path.length);
+        current = resolvePath(parentOf2(link2.path), `${link2.link}${rest2}`);
       }
     }
     throw fsError("ELOOP", path);
@@ -2493,9 +2493,9 @@ var OpfsFs = class {
     return timed;
   }
   async restamp(path, timed) {
-    for (const rest of timed) {
-      const mtimeFor = await this.modified(path + rest);
-      await this.meta.update(path + rest, (entry) => entry && { ...entry, mtimeFor });
+    for (const rest2 of timed) {
+      const mtimeFor = await this.modified(path + rest2);
+      await this.meta.update(path + rest2, (entry) => entry && { ...entry, mtimeFor });
     }
   }
   async place(handle, dir, name2) {
@@ -2543,8 +2543,8 @@ var OpfsFs = class {
     }));
     this.touch(parent.path);
   }
-  async realpath(path, follow) {
-    return (await this.locate(path, follow)).path;
+  async realpath(path, follow2) {
+    return (await this.locate(path, follow2)).path;
   }
   async readlink(path) {
     const found = await this.locate(path, false);
@@ -2674,9 +2674,9 @@ var UnlinkedKeeper = class {
     void locks?.request(lockName(this.instance), () => new Promise(() => void 0));
   }
   serial(op) {
-    const next = this.queue.then(op);
-    this.queue = next.catch(() => void 0);
-    return next;
+    const next2 = this.queue.then(op);
+    this.queue = next2.catch(() => void 0);
+    return next2;
   }
   wrap(fs = this.fs) {
     const keeper = this;
@@ -2858,10 +2858,10 @@ var Incoming = class {
       this.eof = true;
       return false;
     }
-    const next = new Uint8Array(this.buf.length + chunk2.length);
-    next.set(this.buf);
-    next.set(chunk2, this.buf.length);
-    this.buf = next;
+    const next2 = new Uint8Array(this.buf.length + chunk2.length);
+    next2.set(this.buf);
+    next2.set(chunk2, this.buf.length);
+    this.buf = next2;
     return true;
   }
   take(n) {
@@ -3889,6 +3889,53 @@ function withCommandDirs(fs, names) {
   };
 }
 
+// src/fs/physical-path.ts
+var MAX_HOPS = 40;
+function start(path) {
+  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
+}
+function next(walk) {
+  while (walk.todo.length > 0) {
+    const part = walk.todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      walk.done.pop();
+      continue;
+    }
+    return part;
+  }
+  return void 0;
+}
+function lexical(path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
+  return `/${walk.done.join("/")}`;
+}
+function rest(walk, part) {
+  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
+}
+function follow(walk, target) {
+  if (++walk.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk.done.length = 0;
+  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+  return true;
+}
+async function physicalPathAsync(fs, path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) {
+    const at = `/${[...walk.done, part].join("/")}`;
+    let target;
+    try {
+      target = (await fs.lstat(at)).isSymbolicLink ? await fs.readlink(at) : void 0;
+    } catch {
+      return rest(walk, part);
+    }
+    if (target === void 0) walk.done.push(part);
+    else if (!follow(walk, target)) return lexical(path);
+  }
+  return `/${walk.done.join("/")}`;
+}
+
 // src/fs/watch.ts
 var WATCH_BATCH_LIMIT = 1e3;
 var under2 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
@@ -4052,10 +4099,10 @@ var ChildTable = class {
     }
     return this.track(req, fds, captured, this.spawner);
   }
-  async track(req, fds, captured, start) {
+  async track(req, fds, captured, start2) {
     let handle;
     try {
-      handle = await start(req, fds);
+      handle = await start2(req, fds);
     } catch (e) {
       await fds.closeAll();
       throw e;
@@ -5054,9 +5101,9 @@ var MountFs = class {
     this.table.forget(found.mount, normalizePath(path));
     await found.mount.conn.call({ op: "symlink", target, path: found.rel });
   }
-  async realpath(path, follow) {
+  async realpath(path, follow2) {
     if (this.at(path) || !this.base.realpath) throw errnoError("ENOSYS", path);
-    const real = await this.base.realpath(path, follow);
+    const real = await this.base.realpath(path, follow2);
     if (this.at(real)) throw errnoError("ENOSYS", path);
     return real;
   }
@@ -6204,15 +6251,15 @@ var octets = (bytes) => tlv(4, bytes);
 var bits = (bytes, unused = 0) => tlv(3, Uint8Array.of(unused), bytes);
 var TRUE = tlv(1, Uint8Array.of(255));
 function integer(magnitude) {
-  let start = 0;
-  while (start < magnitude.length - 1 && magnitude[start] === 0) start++;
-  const trimmed = magnitude.subarray(start);
+  let start2 = 0;
+  while (start2 < magnitude.length - 1 && magnitude[start2] === 0) start2++;
+  const trimmed = magnitude.subarray(start2);
   return tlv(2, trimmed[0] & 128 ? concat4([Uint8Array.of(0), trimmed]) : trimmed);
 }
 function oid(dotted) {
-  const [a, b, ...rest] = dotted.split(".").map(Number);
+  const [a, b, ...rest2] = dotted.split(".").map(Number);
   const out = [40 * a + b];
-  for (const arc of rest) {
+  for (const arc of rest2) {
     const groups = [];
     for (let v = arc; ; v = Math.floor(v / 128)) {
       groups.unshift(v & 127);
@@ -6252,19 +6299,19 @@ function children(der) {
 function header(der, at) {
   const tag = der[at];
   let len = der[at + 1];
-  let start = at + 2;
+  let start2 = at + 2;
   if (len & 128) {
     const count = len & 127;
     len = 0;
-    for (let i = 0; i < count; i++) len = len * 256 + der[start + i];
-    start += count;
+    for (let i = 0; i < count; i++) len = len * 256 + der[start2 + i];
+    start2 += count;
   }
-  if (start + len > der.length) throw new Error("truncated DER");
-  return [tag, start, start + len];
+  if (start2 + len > der.length) throw new Error("truncated DER");
+  return [tag, start2, start2 + len];
 }
 function contents(element) {
-  const [, start, end] = header(element, 0);
-  return element.subarray(start, end);
+  const [, start2, end] = header(element, 0);
+  return element.subarray(start2, end);
 }
 function publicKeyBits(spki) {
   const key = children(spki)[1];
@@ -6865,9 +6912,9 @@ var HttpHandles = class {
     return this.close(req.handle);
   }
   traits() {
-    const { unavailable, crossOrigin = "any", ...rest } = this.transport.traits;
+    const { unavailable, crossOrigin = "any", ...rest2 } = this.transport.traits;
     if (unavailable) return { ok: false, errno: "ENETUNREACH", message: NO_TRANSPORT };
-    return { ok: true, kind: "json", json: { ...rest, crossOrigin } };
+    return { ok: true, kind: "json", json: { ...rest2, crossOrigin } };
   }
   add(abort, body, cancel) {
     const handle = ++this.nextHandle;
@@ -6929,9 +6976,9 @@ var HttpHandles = class {
   async take(entry, max) {
     if (entry.left.length === 0 && !entry.done) {
       try {
-        const next = await entry.body.next();
-        if (next.done) entry.done = true;
-        else entry.left = next.value;
+        const next2 = await entry.body.next();
+        if (next2.done) entry.done = true;
+        else entry.left = next2.value;
       } catch (e) {
         entry.done = true;
         const timedOut = e?.code === "ETIMEDOUT";
@@ -7393,12 +7440,12 @@ var KernelTty = class {
     const chunks2 = [];
     let n = 0;
     while (this.readable.length > 0 && n < max) {
-      const next = this.readable[0];
-      if (next === null || next === void 0) break;
-      const take = next.subarray(0, max - n);
+      const next2 = this.readable[0];
+      if (next2 === null || next2 === void 0) break;
+      const take = next2.subarray(0, max - n);
       chunks2.push(take);
       n += take.length;
-      if (take.length < next.length) this.readable[0] = next.subarray(take.length);
+      if (take.length < next2.length) this.readable[0] = next2.subarray(take.length);
       else this.readable.shift();
       if (this.canonical) break;
     }
@@ -7495,11 +7542,11 @@ var PtyPair = class {
     const chunks2 = [];
     let n = 0;
     while (this.queue.length > 0 && n < max - status) {
-      const next = this.queue[0];
-      const take = next.subarray(0, max - status - n);
+      const next2 = this.queue[0];
+      const take = next2.subarray(0, max - status - n);
       chunks2.push(take);
       n += take.length;
-      if (take.length < next.length) this.queue[0] = next.subarray(take.length);
+      if (take.length < next2.length) this.queue[0] = next2.subarray(take.length);
       else this.queue.shift();
     }
     const out = new Uint8Array(status + n);
@@ -7805,7 +7852,7 @@ var Pages = class {
     }
     const last = runs[runs.length - 1];
     if (last) last[1] = Math.max(last[1], Math.min(READAHEAD, this.stored - last[0]));
-    return runs.map(([start, n]) => [start, Math.min(n, this.stored - start)]);
+    return runs.map(([start2, n]) => [start2, Math.min(n, this.stored - start2)]);
   }
   partial(at, length2) {
     if (length2 === 0) return [];
@@ -7813,16 +7860,16 @@ var Pages = class {
     const edges = /* @__PURE__ */ new Set([Math.floor(at / PAGE), Math.floor((at + length2 - 1) / PAGE)]);
     const runs = [];
     for (const page of edges) {
-      const start = page * PAGE;
-      const covered = at <= start && at + length2 >= start + PAGE;
-      if (covered || this.pages.has(page) || start >= this.stored) continue;
-      runs.push([start, Math.min(PAGE, this.stored - start)]);
+      const start2 = page * PAGE;
+      const covered = at <= start2 && at + length2 >= start2 + PAGE;
+      if (covered || this.pages.has(page) || start2 >= this.stored) continue;
+      runs.push([start2, Math.min(PAGE, this.stored - start2)]);
     }
     return runs;
   }
-  fill(start, bytes) {
+  fill(start2, bytes) {
     for (let at = 0; at < bytes.length; at += PAGE) {
-      const page = (start + at) / PAGE;
+      const page = (start2 + at) / PAGE;
       if (this.pages.has(page)) continue;
       const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
       const fresh = this.take(part.length);
@@ -7888,14 +7935,14 @@ var Pages = class {
       while (j < sorted.length && sorted[j] === first + (j - i) && sorted[j] * PAGE % RUN !== 0) {
         j++;
       }
-      const start = first * PAGE;
+      const start2 = first * PAGE;
       const end = Math.min(this.length, (first + (j - i)) * PAGE);
-      const bytes = new Uint8Array(end - start);
+      const bytes = new Uint8Array(end - start2);
       for (let k = i; k < j; k++) {
         const page = this.pages.get(sorted[k]);
-        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start)), (k - i) * PAGE);
+        bytes.set(page.subarray(0, Math.min(PAGE, end - (k - i) * PAGE - start2)), (k - i) * PAGE);
       }
-      runs.push({ offset: start, bytes });
+      runs.push({ offset: start2, bytes });
       i = j;
     }
     const written2 = Math.max(this.stored, ...runs.map((r) => r.offset + r.bytes.length));
@@ -7962,8 +8009,8 @@ var AsyncRangedFile = class {
     return this.pages.length;
   }
   async fetch(runs) {
-    for (const [start, n] of runs) {
-      this.pages.fill(start, await this.io.pread(this.path, start, n, this.version));
+    for (const [start2, n] of runs) {
+      this.pages.fill(start2, await this.io.pread(this.path, start2, n, this.version));
     }
   }
   async read(at, length2) {
@@ -8038,9 +8085,9 @@ var VfsNode = class {
     if (dirty && contents2 !== void 0) this.markDirty();
   }
   serial(op) {
-    const next = this.queue.then(op);
-    this.queue = next.catch(() => void 0);
-    return next;
+    const next2 = this.queue.then(op);
+    this.queue = next2.catch(() => void 0);
+    return next2;
   }
   revoke() {
     this.revoked = true;
@@ -8222,10 +8269,10 @@ var VfsNodes = class {
   targetKey(path) {
     return this.real(path, true, () => realTarget(this.fs, path));
   }
-  async real(path, follow, walk) {
+  async real(path, follow2, walk) {
     if (this.fs.realpath) {
       try {
-        return await this.fs.realpath(path, follow);
+        return await this.fs.realpath(path, follow2);
       } catch (err) {
         if (errCode(err) === "ELOOP") throw err;
       }
@@ -8353,8 +8400,8 @@ var VfsNodes = class {
     }
   }
 };
-async function present(fs, path, follow = false) {
-  const look = (follow ? void 0 : fs.lstat) ?? fs.stat;
+async function present(fs, path, follow2 = false) {
+  const look = (follow2 ? void 0 : fs.lstat) ?? fs.stat;
   try {
     await (look ? look.call(fs, path) : fs.readFileBuffer(path));
     return true;
@@ -8380,10 +8427,10 @@ async function realDir(fs, dir, budget = { hops: 0 }) {
       at = parentOf6(at);
       continue;
     }
-    const next = at === "/" ? `/${part}` : `${at}/${part}`;
-    const link2 = await linkOf(fs, next);
+    const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
+    const link2 = await linkOf(fs, next2);
     if (link2 === void 0) {
-      at = next;
+      at = next2;
       continue;
     }
     if (budget.hops >= MAX_LINKS5) throw fsError("ELOOP", dir);
@@ -10644,9 +10691,9 @@ function tmpfs() {
     let node = root;
     for (const name2 of parts(path)) {
       if (node.kind !== "directory") throw fsError2("ENOTDIR", path);
-      const next = node.children.get(name2);
-      if (!next) throw fsError2("ENOENT", path);
-      node = next;
+      const next2 = node.children.get(name2);
+      if (!next2) throw fsError2("ENOENT", path);
+      node = next2;
     }
     return node;
   }
@@ -11210,8 +11257,8 @@ var Launcher = class {
     const words = shebang(head) ?? (binfmt ? [binfmt] : void 0);
     if (!words) return void 0;
     if (baseName(words[0]) === "env") words.shift();
-    const [interp, ...rest] = words;
-    const arg = rest.join(" ");
+    const [interp, ...rest2] = words;
+    const arg = rest2.join(" ");
     const passed = [...arg ? [arg] : [], command ? script : file, ...argv.slice(1)];
     const found = interp ? await this.resolve(interp, interp, cwd) : void 0;
     if (!found) {
@@ -11292,7 +11339,8 @@ var Launcher = class {
   }
   async launch(planned, req) {
     const { target, args } = planned;
-    const seen = { ...req.env, HOSTNAME: this.hostname, cwd: req.cwd };
+    const cwd = await physicalPathAsync(this.base, req.cwd);
+    const seen = { ...req.env, HOSTNAME: this.hostname, cwd };
     const env = { ...expandDefaults(target.env, seen), ...req.env };
     for (const key of target.unset ?? []) delete env[key];
     env.HOSTNAME = this.hostname;
@@ -11303,7 +11351,7 @@ var Launcher = class {
       await req.fds.closeAll();
       throw err;
     }
-    return this.start({ ...req, program, argv0: target.argv0, args, env });
+    return this.start({ ...req, cwd, program, argv0: target.argv0, args, env });
   }
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
@@ -11710,7 +11758,8 @@ var Launcher = class {
   async starting(argv, dir) {
     this.catalog = void 0;
     this.binfmts = void 0;
-    const cwd = this.fs.resolvePath("/", dir ?? "/");
+    const start2 = dir ?? "/";
+    const cwd = await physicalPathAsync(this.base, start2.startsWith("/") ? start2 : `/${start2}`);
     const [file = ""] = argv;
     await this.base.mkdir(cwd, { recursive: true });
     return { cwd, file, planned: await this.plan(file, argv, cwd) };
@@ -11869,26 +11918,26 @@ var MemoryFile = class {
     return new File(this.data.blobs, this.name, { lastModified: this.lastModified });
   }
   async createWritable({ keepExistingData = false } = {}) {
-    const next = keepExistingData ? new Chunks([...this.data.blobs], this.data.size) : new Chunks();
+    const next2 = keepExistingData ? new Chunks([...this.data.blobs], this.data.size) : new Chunks();
     let position = 0;
     const put = async (data) => {
       const bytes = await bytesOf(data);
-      await next.write(position, bytes);
+      await next2.write(position, bytes);
       position += bytes.length;
     };
     return {
       write: async (data) => {
         if (!isParams(data)) return put(data);
-        if (data.type === "truncate") return next.truncate(data.size ?? 0);
+        if (data.type === "truncate") return next2.truncate(data.size ?? 0);
         position = data.position ?? position;
         if (data.type === "write") await put(data.data);
       },
       seek: async (at) => {
         position = at;
       },
-      truncate: async (size) => next.truncate(size),
+      truncate: async (size) => next2.truncate(size),
       close: async () => {
-        this.data = next;
+        this.data = next2;
         this.lastModified = Date.now();
       },
       abort: async () => {
@@ -12339,11 +12388,11 @@ function stream(chunks2, socket, signal) {
     },
     async pull(controller) {
       try {
-        const next = await chunks2.next();
-        if (next.done) {
+        const next2 = await chunks2.next();
+        if (next2.done) {
           controller.close();
           socket.close();
-        } else controller.enqueue(next.value);
+        } else controller.enqueue(next2.value);
       } catch (err) {
         controller.error(err);
         socket.close();
@@ -12571,12 +12620,12 @@ async function dialOn(channel, { port, host }) {
   return dialStream(await since(channel, 4, "dial", () => channel.call(req)));
 }
 async function spawnOn(channel, argv, opts) {
-  const { onStdout, onStderr, stdin, group: _, ...rest } = opts;
+  const { onStdout, onStderr, stdin, group: _, ...rest2 } = opts;
   if (opts.pgid !== void 0)
     await since(channel, 3, "spawn into a process group", async () => {
     });
   const started = Promise.withResolvers();
-  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf2(stdin) } : {} };
+  const options = { ...rest2, ...stdin !== void 0 ? { stdin: bytesOf2(stdin) } : {} };
   const { done: done4 } = channel.request(
     { op: "spawn", argv, options },
     {
@@ -12595,7 +12644,7 @@ async function spawnOn(channel, argv, opts) {
   };
 }
 async function runOn(channel, argv, opts) {
-  const { onStdout, onStderr, ...rest } = opts;
+  const { onStdout, onStderr, ...rest2 } = opts;
   const chunks2 = { 1: [], 2: [] };
   const live = { 1: new TextDecoder(), 2: new TextDecoder() };
   const tee = (fd, on) => (bytes) => {
@@ -12603,7 +12652,7 @@ async function runOn(channel, argv, opts) {
     on?.(live[fd].decode(bytes, { stream: true }));
   };
   const child = await spawnOn(channel, argv, {
-    ...rest,
+    ...rest2,
     onStdout: tee(1, onStdout),
     onStderr: tee(2, onStderr)
   });
@@ -12632,9 +12681,9 @@ async function terminalOn(channel, argv, opts) {
     get onData() {
       return listener;
     },
-    set onData(next) {
-      listener = next;
-      if (next) for (const bytes of backlog.splice(0)) next(bytes);
+    set onData(next2) {
+      listener = next2;
+      if (next2) for (const bytes of backlog.splice(0)) next2(bytes);
     },
     write: (data) => send({ action: "write", bytes: bytesOf2(data) }),
     resize: (cols, rows) => send({ action: "resize", cols, rows }),
@@ -12745,8 +12794,8 @@ async function attachKernel(port, options = {}) {
     mounts: () => since(channel, 2, "mounts", () => channel.call({ op: "mounts" })),
     kill: async (pid, signal = "SIGTERM") => void await channel.call({ op: "kill", pid, signal }),
     fetch: (req) => {
-      const { signal, ...rest } = req;
-      return transport.fetch({ ...rest, signal: signal ?? new AbortController().signal });
+      const { signal, ...rest2 } = req;
+      return transport.fetch({ ...rest2, signal: signal ?? new AbortController().signal });
     },
     dial: (options2) => dialOn(channel, options2),
     loopbackFetch: (input, options2) => loopbackFetch((o) => dialOn(channel, o), input, options2),
@@ -12863,12 +12912,12 @@ async function createNodeKernel(options = {}) {
   return {
     root,
     async run(argv, opts = {}) {
-      const { stdin, onStdout, onStderr, ...rest } = opts;
+      const { stdin, onStdout, onStderr, ...rest2 } = opts;
       const onOut = textOf(onStdout);
       const onErr = textOf(onStderr);
       const result = await guard(
         () => launcher.run(argv, {
-          ...rest,
+          ...rest2,
           ...stdin !== void 0 ? { stdin: typeof stdin === "string" ? new TextEncoder().encode(stdin) : stdin } : {},
           ...onOut ? { onStdout: onOut } : {},
           ...onErr ? { onStderr: onErr } : {}
@@ -12881,12 +12930,12 @@ async function createNodeKernel(options = {}) {
       };
     },
     async openTerminal(argv, opts = {}) {
-      const { onData, ...rest } = opts;
+      const { onData, ...rest2 } = opts;
       let listener = onData ?? null;
       const backlog = [];
       const session = await guard(
         () => launcher.openTerminal(argv, {
-          ...rest,
+          ...rest2,
           onData: (bytes) => listener ? listener(bytes) : backlog.push(bytes)
         })
       );
@@ -12896,9 +12945,9 @@ async function createNodeKernel(options = {}) {
         get onData() {
           return listener;
         },
-        set onData(next) {
-          listener = next;
-          if (next) for (const bytes of backlog.splice(0)) next(bytes);
+        set onData(next2) {
+          listener = next2;
+          if (next2) for (const bytes of backlog.splice(0)) next2(bytes);
         },
         write: (data) => session.write(typeof data === "string" ? new TextEncoder().encode(data) : data),
         resize: (cols, rows) => session.resize(cols, rows),