@ai-ecoverse/slicc-kernel 1.41.0 → 1.41.2

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;
@@ -4292,8 +4339,7 @@ var HeldSet = class extends Set {
   delete(holds) {
     const removed = super.delete(holds);
     for (const path of /* @__PURE__ */ new Set([...holds.keys(), ...holds.opens.keys()])) this.idle(path);
-    for (const kept of holds.unlinked.values()) kept.release();
-    holds.unlinked.clear();
+    holds.releaseAll();
     return removed;
   }
 };
@@ -4306,6 +4352,10 @@ var HeldPaths = class extends Map {
   opens = /* @__PURE__ */ new Map();
   unlinked = /* @__PURE__ */ new Map();
   aliases = /* @__PURE__ */ new Map();
+  handles = /* @__PURE__ */ new Map();
+  keptHandles = /* @__PURE__ */ new Map();
+  uses = /* @__PURE__ */ new Map();
+  lastHandle = 0;
   owning;
   onIdle;
   keyOf(path) {
@@ -4321,29 +4371,70 @@ var HeldPaths = class extends Map {
     return this.opens.keys();
   }
   isKept(path) {
-    return this.unlinked.has(path);
+    const ids = this.handlesAt(path);
+    return ids.length === 0 ? this.unlinked.has(path) : ids.every((id) => this.keptHandles.has(id));
+  }
+  handlesAt(path) {
+    return [...this.handles].filter(([, key]) => key === path).map(([id]) => id);
+  }
+  keptFor(handle) {
+    return this.keptHandles.get(handle);
   }
   keep(path, file) {
+    const fresh = this.handlesAt(path).filter((id) => !this.keptHandles.has(id));
+    for (const id of fresh) this.keptHandles.set(id, file);
+    this.uses.set(file, Math.max(fresh.length, 1));
     this.unlinked.set(path, file);
   }
-  unkeep(path) {
-    this.unlinked.delete(path);
-  }
-  hold(path, on, open = false, real) {
-    if (open) {
-      const key = real ?? this.keyOf(path);
-      if (key !== path) this.aliases.set(path, key);
-      const count2 = (this.opens.get(key) ?? 0) + (on ? 1 : -1);
-      if (count2 > 0) this.opens.set(key, count2);
-      else {
-        this.opens.delete(key);
-        this.unlinked.get(key)?.release();
-        this.unlinked.delete(key);
-        for (const [alias, target] of this.aliases) if (target === key) this.aliases.delete(alias);
-        this.onIdle?.(key);
-      }
+  unkeep(path, file) {
+    for (const [id, kept] of this.keptHandles) if (kept === file) this.keptHandles.delete(id);
+    this.uses.delete(file);
+    if (this.unlinked.get(path) === file) this.unlinked.delete(path);
+  }
+  letGo(file, all = false) {
+    const left = all ? 0 : (this.uses.get(file) ?? 0) - 1;
+    if (left > 0) {
+      this.uses.set(file, left);
       return;
     }
+    if (!this.uses.delete(file)) return;
+    file.release();
+    for (const [path, kept] of this.unlinked) if (kept === file) this.unlinked.delete(path);
+  }
+  releaseAll() {
+    for (const file of [...this.uses.keys()]) this.letGo(file, true);
+    this.keptHandles.clear();
+  }
+  hold(path, on, open = false, real, handle) {
+    if (open) return this.holdOpen(path, on, real, handle);
+    this.holdWrite(path, on);
+    return void 0;
+  }
+  holdOpen(path, on, real, handle) {
+    const known = handle === void 0 ? void 0 : this.handles.get(handle);
+    const key = known ?? real ?? this.keyOf(path);
+    if (key !== path) this.aliases.set(path, key);
+    if (handle !== void 0) {
+      const kept = this.keptHandles.get(handle);
+      this.handles.delete(handle);
+      this.keptHandles.delete(handle);
+      if (kept) this.letGo(kept);
+    }
+    const count = (this.opens.get(key) ?? 0) + (on ? 1 : -1);
+    if (count > 0) this.opens.set(key, count);
+    else {
+      this.opens.delete(key);
+      for (const id of this.handlesAt(key)) this.handles.delete(id);
+      const kept = this.unlinked.get(key);
+      if (kept) this.letGo(kept, true);
+      for (const [alias, target] of this.aliases) if (target === key) this.aliases.delete(alias);
+      this.onIdle?.(key);
+    }
+    if (!on) return void 0;
+    this.handles.set(++this.lastHandle, key);
+    return this.lastHandle;
+  }
+  holdWrite(path, on) {
     const count = (this.get(path) ?? 0) + (on ? 1 : -1);
     if (count > 0) this.set(path, count);
     else {
@@ -4380,6 +4471,9 @@ var HeldPaths = class extends Map {
       this.opens.delete(path);
       this.opens.set(moved2, (this.opens.get(moved2) ?? 0) + count);
     }
+    for (const [id, key] of this.handles) {
+      if (within3(key, from)) this.handles.set(id, to + key.slice(from.length));
+    }
   }
   isRevoked(path) {
     return this.revoked.has(path);
@@ -5054,9 +5148,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;
   }
@@ -5243,25 +5337,31 @@ async function ranged(fs, path, req) {
 }
 var UNLINKED_OPS = /* @__PURE__ */ new Set(["read", "pread", "pwrite", "truncate"]);
 var OWN_OPS = /* @__PURE__ */ new Set(["rm", "unlink", "rmdir", "rename"]);
+async function keptOr(entry, path, handle) {
+  if (handle !== void 0) return entry.keptFor?.(handle)?.hidden ?? path;
+  const kept = entry.unlinked?.(path);
+  return kept && !await entry.fs.exists(path) ? kept.hidden : path;
+}
 async function dispatchSyncFs(req) {
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
   const { fs, cwd } = entry;
   try {
     const path = fs.resolvePath(cwd, req.path);
+    if (req.op === "kept") return json2(entry.keptFor?.(req.handle ?? -1) !== void 0);
     if (req.op === "statfs") return json2(await entry.statfs?.(path) ?? await storageUsage());
     if (req.op === "hold") {
       const [on, open] = [((req.mode ?? 0) & 1) === 1, ((req.mode ?? 0) & 2) === 2];
-      const real = on && open ? await fs.realpath?.(path, true).catch(() => path) : void 0;
-      entry.hold?.(path, on, open, real);
+      if (on && open) {
+        const real = await fs.realpath?.(path, true).catch(() => path);
+        return json2(entry.hold?.(path, on, open, real) ?? null);
+      }
+      entry.hold?.(path, on, open, void 0, req.handle);
       return done;
     }
     if (entry.revoked?.(path)) return { ok: false, errno: "EIO", message: `${path} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
-      const serve = async () => {
-        const kept = entry.unlinked?.(path);
-        return run(entry, kept && !await fs.exists(path) ? kept.hidden : path, req);
-      };
+      const serve = async () => run(entry, await keptOr(entry, path, req.handle), req);
       return await (entry.gate ? entry.gate(path, serve) : serve());
     }
     if (!entry.own || !OWN_OPS.has(req.op)) return await run(entry, path, req);
@@ -6204,15 +6304,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 +6352,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 +6965,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 +7029,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 +7493,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 +7595,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 +7905,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 +7913,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 +7988,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 +8062,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 +8138,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 +8322,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 +8453,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 +8480,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);
@@ -9378,7 +9478,8 @@ function holdingToken(opts, holds) {
     fs: opts.fs,
     cwd: opts.cwd,
     ...opts.statfs ? { statfs: opts.statfs } : {},
-    hold: (path, on, open, real) => holds.hold(path, on, open, real),
+    hold: (path, on, open, real, handle) => holds.hold(path, on, open, real, handle),
+    keptFor: (handle) => holds.keptFor(handle),
     unlinked: (path) => holds.keptAt(path),
     gate: (path, op) => opts.unlinkGate && holds.holding(path) ? opts.unlinkGate.run(holds.keyOf(path), op) : op(),
     own: (path, op) => holds.own(path, op),
@@ -10644,9 +10745,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 +11311,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 +11393,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 +11405,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 +11812,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 +11972,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 +12442,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 +12674,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 +12698,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 +12706,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 +12735,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 +12848,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 +12966,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 +12984,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 +12999,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),