@ai-ecoverse/slicc-kernel 1.40.1 → 1.41.2

package/dist/kernel-worker.js

@@ -106,15 +106,15 @@ var IndexedDbMeta = class {
   async update(path, change) {
     const [transaction, store] = this.transaction("readwrite");
     const request2 = store.get(path);
-    let next;
+    let next2;
     request2.onsuccess = () => {
-      next = change(request2.result);
-      if (next) store.put(next);
+      next2 = change(request2.result);
+      if (next2) store.put(next2);
       else store.delete(path);
     };
     await settle(transaction, () => void 0);
     this.changed({ paths: [path] });
-    this.cache.set(path, next ?? null);
+    this.cache.set(path, next2 ?? null);
   }
   async move(from, to, root) {
     const [transaction, store] = this.transaction("readwrite");
@@ -341,8 +341,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);
@@ -428,7 +428,7 @@ var OpfsFs = class {
     }
     return void 0;
   }
-  async locate(path, follow) {
+  async locate(path, follow2) {
     let current = path;
     for (let hops = 0; hops <= MAX_LINKS; hops++) {
       try {
@@ -437,9 +437,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);
@@ -755,9 +755,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) {
@@ -805,8 +805,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);
@@ -1659,8 +1659,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);
     }
@@ -1841,8 +1841,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);
@@ -2084,12 +2084,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;
@@ -2118,7 +2118,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);
@@ -2197,9 +2197,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;
@@ -2240,12 +2240,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) {
@@ -2262,7 +2262,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);
@@ -2290,17 +2290,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_LINKS2) 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 || "/";
@@ -2652,10 +2652,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) {
@@ -3629,15 +3629,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 ? concat2([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);
@@ -3677,19 +3677,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];
@@ -5288,6 +5288,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/unlinked.ts
 var UNLINKED_DIR = ".slicc-unlinked";
 function webLocks() {
@@ -5343,9 +5390,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;
@@ -5642,10 +5689,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;
@@ -5882,8 +5929,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;
   }
 };
@@ -5896,6 +5942,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) {
@@ -5911,29 +5961,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 {
@@ -5970,6 +6061,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 (within4(key, from)) this.handles.set(id, to + key.slice(from.length));
+    }
   }
   isRevoked(path) {
     return this.revoked.has(path);
@@ -6644,9 +6738,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;
   }
@@ -6833,25 +6927,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);
@@ -7210,9 +7310,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;
@@ -7274,9 +7374,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";
@@ -7638,12 +7738,12 @@ var KernelTty = class {
     const chunks = [];
     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);
       chunks.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;
     }
@@ -7740,11 +7840,11 @@ var PtyPair = class {
     const chunks = [];
     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);
       chunks.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);
@@ -8050,7 +8150,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 [];
@@ -8058,16 +8158,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);
@@ -8133,14 +8233,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));
@@ -8207,8 +8307,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) {
@@ -8283,9 +8383,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;
@@ -8467,10 +8567,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;
       }
@@ -8598,8 +8698,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;
@@ -8625,10 +8725,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);
@@ -9623,7 +9723,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),
@@ -10880,9 +10981,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;
   }
@@ -11446,8 +11547,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) {
@@ -11528,7 +11629,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;
@@ -11539,7 +11641,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);
@@ -11946,7 +12048,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) };