@ai-ecoverse/slicc-kernel 1.92.0 → 1.93.1

package/dist/node.js

@@ -451,6 +451,9 @@ async function present(fs, path, directory) {
 }
 async function finalOf(fs, walked, want, options) {
   const perm = walked.perm;
+  if (options.follow === false && perm.link !== void 0) {
+    return [{ ...perm, mode: 511 }, false];
+  }
   if ((want & X_OK) === 0 || options.directory !== void 0) {
     return [perm, options.directory !== false];
   }
@@ -622,6 +625,18 @@ async function chmodMode(g, path, mode) {
   if (!g.dac.enforcing || !perm || g.cred.euid === 0 || inGroup(g.cred, perm.gid)) return mode;
   return mode & ~S_ISGID2;
 }
+function heldChmodMode(g, path, st, mode) {
+  const perm = permOf(st);
+  if (g.cred.euid !== 0 && perm.uid !== g.cred.euid) deny(g, "fchmod", path, "EPERM");
+  if (!g.dac.enforcing || g.cred.euid === 0 || inGroup(g.cred, perm.gid)) return mode;
+  return mode & ~S_ISGID2;
+}
+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);
+}
 async function retimable(g, op, path, now = false) {
   const follow2 = op !== "lutimes";
   if (!now) return void await ownerOnly(g, op, path, follow2);
@@ -1073,6 +1088,17 @@ var FdTable = class _FdTable {
     this.status.delete(fd);
     void Promise.resolve(previous?.release()).catch(() => void 0);
   }
+  async replaceAt(fd, file) {
+    if (fd < 0 || fd >= _FdTable.MAX_FDS) {
+      void Promise.resolve(file.release()).catch(() => void 0);
+      throw new KernelError("EBADF");
+    }
+    const previous = this.fds.get(fd);
+    this.fds.set(fd, file);
+    this.cloexec.delete(fd);
+    this.status.delete(fd);
+    await Promise.resolve(previous?.release()).catch(() => void 0);
+  }
   dup(fd, min = 0) {
     return this.install(this.get(fd).retain(), min);
   }
@@ -1081,6 +1107,11 @@ var FdTable = class _FdTable {
     if (oldFd !== newFd) this.installAt(newFd, file.retain());
     return newFd;
   }
+  async dup2Clipboard(oldFd, newFd) {
+    const file = this.get(oldFd);
+    if (oldFd !== newFd) await this.replaceAt(newFd, file.retain());
+    return newFd;
+  }
   close(fd) {
     const file = this.get(fd);
     this.fds.delete(fd);
@@ -2020,17 +2051,21 @@ function openWebSocket(Socket, request, withHeaders) {
       } catch {
       }
     });
-    socket.addEventListener("close", (event) => {
-      queue.end({ code: event.code, reason: event.reason });
-      if (open) return;
-      fail3(unopened(url, event.code));
-    });
+    socket.addEventListener(
+      "close",
+      (event) => {
+        queue.end({ code: event.code, reason: event.reason, wasClean: event.wasClean === true });
+        if (open) return;
+        fail3(unopened(url, event.code));
+      }
+    );
   });
 }
 
 // src/transport.ts
 var SEND_BUFFER = 1024 * 1024;
 var CLOSE_WAIT_MS = 5e3;
+var DNS_CODES = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN", "EAI_NONAME", "EAI_FAIL", "ENODATA"]);
 var NO_WEBSOCKET = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
 var MAX_REQUEST_BODY = 64 * 1024 * 1024;
 function joinHeaders(headers) {
@@ -2082,11 +2117,14 @@ function fetchTransport(options = {}) {
         });
       } catch (e) {
         if (request.signal.aborted) throw e;
+        const causeCode = e?.cause?.code;
+        const dns = typeof causeCode === "string" && DNS_CODES.has(causeCode);
         throw Object.assign(
           new Error(
             `fetch ${request.url} failed (unreachable, or not allowed by CORS)${options.hint ? `: ${options.hint}` : ""}`
           ),
-          { status: 502 }
+          { status: 502 },
+          dns ? { code: causeCode } : {}
         );
       }
       const headers2 = [];
@@ -2329,7 +2367,7 @@ function homeOf(home) {
   if (typeof home !== "string" || !home.startsWith("/") || /[:\r\n]/.test(home)) {
     throw fsError("EINVAL", `not a home directory: ${String(home)}`);
   }
-  return home;
+  return normalizePath(home);
 }
 function freeId(users, groups) {
   const taken = /* @__PURE__ */ new Set([...users.map((r) => r.uid), ...groups.map((r) => r.gid)]);
@@ -3220,12 +3258,36 @@ var MemoryMeta = class {
 };
 
 // src/fs/integrity.ts
+var SOURCE_SUFFIXES = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".py",
+  ".pyc",
+  ".pth",
+  ".zip",
+  ".so",
+  ".wasm",
+  ".sh"
+];
+var EXEC_OPS = { failed: "exec-integrity", unknown: "exec-unverified" };
+var READ_OPS = { failed: "read-integrity", unknown: "read-unverified" };
 var KERNEL_CALLER = { pid: 0, uid: 0 };
 function integrityOptions(options) {
   if (options && typeof options.lookup !== "function") {
     throw new TypeError("protect.integrity.lookup must be a function");
   }
   integrityUnknown(options);
+  integritySources(options);
+}
+function integritySources(options) {
+  const sources = options?.sources ?? SOURCE_SUFFIXES;
+  const suffix = (s) => typeof s === "string" && /^\.[^/]+$/.test(s);
+  if (!Array.isArray(sources) || !sources.every(suffix)) {
+    throw new TypeError("protect.integrity.sources must be a list of suffixes such as .js");
+  }
+  return [...sources];
 }
 function integrityUnknown(options) {
   const unknown = options?.unknown ?? "allow";
@@ -3247,16 +3309,21 @@ var Integrity = class {
   unknown;
   report;
   unverified = /* @__PURE__ */ new Set();
+  unread = /* @__PURE__ */ new Set();
+  sources;
+  passed = /* @__PURE__ */ new Set();
+  generation = 0;
   constructor(prefixes2, root, options, report) {
     this.prefixes = prefixes2;
     this.root = root;
     this.lookup = options.lookup;
     this.unknown = integrityUnknown(options);
+    this.sources = integritySources(options);
     this.report = report;
   }
-  async real(path, asked) {
+  async real(path, asked, known) {
     const at = normalizePath(path);
-    const real = await this.root.realpath?.(at, true).catch(() => void 0) ?? at;
+    const real = known ?? await this.root.realpath?.(at, true).catch(() => void 0) ?? at;
     if (isProtected(this.prefixes, real)) return { real, name: real };
     const names = asked === void 0 ? [] : await namesOf(this.root, asked);
     if (real !== at) names.push(...await namesOf(this.root, at));
@@ -3281,6 +3348,51 @@ var Integrity = class {
     const read = name2 !== real ? { bytes: await plain(), version: void 0 } : this.root.readVersioned ? await this.root.readVersioned(real) : { bytes: await this.root.readFileBuffer(real), version: void 0 };
     const { bytes } = read;
     const keyed = read.version === void 0 ? { bytes } : { bytes, key: `${real}\0${read.version}` };
+    await this.verify(name2, bytes, caller, EXEC_OPS);
+    return keyed;
+  }
+  get readsChecked() {
+    return this.sources.length > 0;
+  }
+  async readSource(path, caller, plain) {
+    const found = await this.source(path);
+    return found === void 0 ? plain() : this.checked(found, caller, plain);
+  }
+  async openSource(path, caller, real) {
+    const found = await this.source(path, real);
+    if (found === void 0) return;
+    if (found.name === found.real && this.root.version) {
+      if (this.passed.has(`${found.real}\0${await this.root.version(found.real, true)}`)) return;
+    }
+    await this.checked(found, caller, () => this.root.readFileBuffer(found.real));
+  }
+  async checked(found, caller, plain) {
+    const { real, name: name2 } = found;
+    if (name2 !== real || !this.root.readVersioned) {
+      const bytes2 = await plain();
+      await this.verify(name2, bytes2, caller, READ_OPS);
+      return bytes2;
+    }
+    const { bytes, version } = await this.root.readVersioned(real, true);
+    await this.pass(`${real}\0${version}`, () => this.verify(name2, bytes, caller, READ_OPS));
+    return bytes;
+  }
+  async pass(key, check) {
+    if (this.passed.has(key)) return;
+    const generation = this.generation;
+    await check();
+    if (generation === this.generation) this.passed.add(key);
+  }
+  async source(path, known) {
+    if (this.sources.length === 0) return void 0;
+    const found = await this.real(path, void 0, known);
+    if (found === void 0) return void 0;
+    const suffixed = (p) => this.sources.some((s) => p.endsWith(s));
+    if (suffixed(found.real) || suffixed(found.name) || suffixed(normalizePath(path))) return found;
+    const st = await this.root.stat(found.real).catch(() => void 0);
+    return st?.isFile && ((st.mode ?? 0) & 73) !== 0 ? found : void 0;
+  }
+  async verify(name2, bytes, caller, ops) {
     const actual = await sha256(bytes);
     const denial = { pid: caller.pid, uid: caller.uid, path: name2, actual };
     const tagged = caller.tag !== void 0 ? { tag: caller.tag } : {};
@@ -3288,27 +3400,33 @@ var Integrity = class {
     try {
       expected = await this.expected(name2);
     } catch {
-      this.say({ ...denial, ...tagged, op: "exec-integrity", errno: "EACCES" });
+      this.say({ ...denial, ...tagged, op: ops.failed, errno: "EACCES" });
       throw fsError("EACCES", `integrity lookup failed: ${name2}`);
     }
-    if (expected === void 0) {
-      if (this.unknown === "allow") {
-        if (!this.unverified.has(name2)) {
-          this.unverified.add(name2);
-          this.say({ ...denial, ...tagged, op: "exec-unverified", errno: "ENODATA" });
-        }
-        return keyed;
+    if (expected === actual) return;
+    if (expected === void 0 && this.unknown === "allow") {
+      const seen = ops === EXEC_OPS ? this.unverified : this.unread;
+      if (!seen.has(name2)) {
+        seen.add(name2);
+        this.say({ ...denial, ...tagged, op: ops.unknown, errno: "ENODATA" });
       }
-    } else if (expected === actual) {
-      return keyed;
+      return;
     }
     const known = expected !== void 0 ? { expected } : {};
-    this.say({ ...denial, ...tagged, ...known, op: "exec-integrity", errno: "EACCES" });
+    this.say({ ...denial, ...tagged, ...known, op: ops.failed, errno: "EACCES" });
     throw fsError("EACCES", `integrity check failed: ${name2}`);
   }
   forget(path) {
-    for (const name2 of [...this.unverified]) {
-      if (path === void 0 || isProtected([path], name2)) this.unverified.delete(name2);
+    this.generation++;
+    for (const seen of [this.unverified, this.unread]) {
+      for (const name2 of [...seen]) {
+        if (path === void 0 || isProtected([path], name2)) seen.delete(name2);
+      }
+    }
+    for (const key of [...this.passed]) {
+      if (path === void 0 || isProtected([path], key.slice(0, key.indexOf("\0")))) {
+        this.passed.delete(key);
+      }
     }
   }
   async expected(path) {
@@ -3507,15 +3625,15 @@ var ProtectedFs = class {
         }
       } : {}
     };
-    const view = {};
+    const view2 = {};
     for (let at = fs; at && at !== Object.prototype; at = Object.getPrototypeOf(at)) {
       for (const name2 of Object.getOwnPropertyNames(at)) {
-        if (name2 === "constructor" || Object.hasOwn(view, name2)) continue;
+        if (name2 === "constructor" || Object.hasOwn(view2, name2)) continue;
         const value = fs[name2];
-        view[name2] = typeof value === "function" ? value.bind(fs) : value;
+        view2[name2] = typeof value === "function" ? value.bind(fs) : value;
       }
     }
-    return Object.assign(view, own);
+    return Object.assign(view2, own);
   }
 };
 
@@ -3634,6 +3752,23 @@ var RemoteWatch = class {
   }
 };
 
+// src/fs/view.ts
+function view(target, overrides) {
+  const keys = new Set(Object.keys(overrides));
+  return new Proxy(target, {
+    get(t, prop, receiver) {
+      if (keys.has(prop)) return overrides[prop];
+      return Reflect.get(t, prop, receiver);
+    },
+    set(t, prop, value) {
+      return Reflect.set(t, prop, value);
+    },
+    getPrototypeOf(t) {
+      return Reflect.getPrototypeOf(t);
+    }
+  });
+}
+
 // src/fs/opfs.ts
 var S_IFDIR = 16384;
 var S_IFREG = 32768;
@@ -3769,11 +3904,16 @@ var OpfsFs = class {
   remote;
   ranged;
   owners = false;
+  rejectLinks = false;
   mounts = {};
+  locks;
+  lockPrefix;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
     this.root = root;
     this.meta = sidecar(meta);
     this.ranged = options.ranged === true;
+    this.locks = options.locks === void 0 ? lockManager() : options.locks ?? void 0;
+    this.lockPrefix = `slicc-excl:${channel ?? ""}:`;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
     this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`);
     if (this.channel) {
@@ -3800,12 +3940,13 @@ var OpfsFs = class {
     return this.remote?.announce(paths) ?? Promise.resolve();
   }
   committed(target) {
+    this.fileTimes.delete(target);
     if (this.remote?.watched()) this.remote.wrote(target);
   }
   counted = [];
-  async stamp(path) {
+  async stamp(path, cached = false) {
     const paths = [path, "/"];
-    const [entry, root] = this.meta.fresh ? await this.meta.fresh(paths) : await this.meta.get(paths);
+    const [entry, root] = this.meta.fresh && !cached ? await this.meta.fresh(paths) : await this.meta.get(paths);
     return `${entry?.writes ?? 0}:${root?.epoch ?? 0}`;
   }
   async epoch() {
@@ -3904,13 +4045,25 @@ var OpfsFs = class {
     this.counted = versions ? prefixes2 : [];
   }
   unguarded() {
-    return Object.create(this, { guarded: { value: [] } });
+    return view(this, { guarded: [] });
+  }
+  noLinks() {
+    return view(this, { rejectLinks: true });
   }
   refuse(path, holding = false) {
     if (isProtected(this.guarded, path) || holding && holdsProtected(this.guarded, path)) {
       throw fsError("EROFS", path);
     }
   }
+  async locked(physicalPath, op) {
+    if (!this.locks) return op();
+    const key = `${this.lockPrefix}${physicalPath}`;
+    let result;
+    await this.locks.request(key, async () => {
+      result = await op();
+    });
+    return result;
+  }
   async chown(path, change) {
     if (!this.owners) return;
     if (change.kind === "new") {
@@ -4042,8 +4195,15 @@ var OpfsFs = class {
         const link2 = await this.linkAlong(current);
         if (!link2) throw err;
         if (link2.path === current && !follow2) return { path: current, link: link2 };
+        if (this.rejectLinks) throw fsError("ELOOP", path);
         const target = `${link2.link}${current.slice(link2.path.length)}`;
-        current = target.split("/").includes("..") ? await this.physical(parentOf4(link2.path), target, hops + 1, path) : resolvePath(parentOf4(link2.path), target);
+        if (target.split("/").includes("..")) {
+          const resolved2 = await this.physical(parentOf4(link2.path), target, hops + 1, path);
+          current = resolved2.path;
+          hops = resolved2.hops;
+        } else {
+          current = resolvePath(parentOf4(link2.path), target);
+        }
         this.crossing(path, current);
       }
     }
@@ -4052,7 +4212,8 @@ var OpfsFs = class {
   async physical(base, path, used, of) {
     let done4 = [];
     let todo = (path.startsWith("/") ? path : `${base}/${path}`).split("/").filter((p) => p !== "" && p !== ".");
-    for (let hops = used; todo.length > 0; ) {
+    let hops = used;
+    while (todo.length > 0) {
       const part = todo.shift();
       if (part === "..") done4.pop();
       else if (!todo.includes("..")) done4.push(part);
@@ -4062,6 +4223,7 @@ var OpfsFs = class {
         const st = await this.lstat(at);
         if (!st.isSymbolicLink && !st.isDirectory) throw fsError("ENOTDIR", at);
         if (!st.isSymbolicLink) done4.push(part);
+        else if (this.rejectLinks) throw fsError("ELOOP", of);
         else if (++hops > MAX_LINKS5) throw fsError("ELOOP", path);
         else {
           const link2 = await this.readlink(at);
@@ -4070,7 +4232,7 @@ var OpfsFs = class {
         }
       }
     }
-    return `/${done4.join("/")}`;
+    return { path: `/${done4.join("/")}`, hops };
   }
   mode(path, directory, meta) {
     const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
@@ -4114,6 +4276,11 @@ var OpfsFs = class {
     return entry.timesAt >= ms;
   }
   movePending(from, to) {
+    if (to !== void 0) {
+      for (const path of [...this.fileTimes.keys()]) {
+        if (within2(path, to)) this.fileTimes.delete(path);
+      }
+    }
     for (const [path, ms] of [...this.fileTimes]) {
       if (!within2(path, from)) continue;
       this.fileTimes.delete(path);
@@ -4121,8 +4288,7 @@ var OpfsFs = class {
     }
   }
   flushing = {};
-  touch(...dirs) {
-    const now = Date.now();
+  touch(now, ...dirs) {
     for (const dir of dirs) {
       this.dirTimes.set(dir, now);
       this.dirDirty.add(dir);
@@ -4235,12 +4401,12 @@ var OpfsFs = class {
       false
     );
   }
-  async readVersioned(path) {
+  async readVersioned(path, cached = false) {
     const handle = await this.existing(path);
     return this.retrying(
       path,
       async () => {
-        const stamp = await this.stamp(path);
+        const stamp = await this.stamp(path, cached);
         const file = await handle.getFile();
         const bytes = new Uint8Array(await file.arrayBuffer());
         return { bytes, version: `${file.lastModified}:${file.size}:${stamp}` };
@@ -4248,12 +4414,12 @@ var OpfsFs = class {
       false
     );
   }
-  async version(path) {
+  async version(path, cached = false) {
     const handle = await this.existing(path);
     return this.retrying(
       path,
       async () => {
-        const stamp = await this.stamp(path);
+        const stamp = await this.stamp(path, cached);
         const file = await handle.getFile();
         return `${file.lastModified}:${file.size}:${stamp}`;
       },
@@ -4338,7 +4504,7 @@ var OpfsFs = class {
         dir,
         (parent) => parent.getFileHandle(name2, { create: true })
       );
-      if (!existed) this.touch(parentOf4(target));
+      if (!existed) this.touch(Date.now(), parentOf4(target));
       return [handle, existed, target];
     } catch (err) {
       const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
@@ -4393,6 +4559,7 @@ var OpfsFs = class {
     );
   }
   async mkdir(path, options = {}) {
+    if (!options.recursive) return this.mkdirExcl(path, options.owner);
     let found;
     try {
       found = await this.locate(path, true);
@@ -4401,28 +4568,75 @@ var OpfsFs = class {
     }
     if (found) {
       const directory = found.handle?.kind === "directory";
-      if (options.recursive && directory) return;
-      throw fsError(options.recursive ? "ENOTDIR" : "EEXIST", path);
+      if (directory) return;
+      throw fsError("ENOTDIR", path);
     }
     const [entry] = await this.meta.get([path]);
     if (entry?.link !== void 0) throw fsError("EEXIST", path);
     const { owner } = options;
-    if (options.recursive) {
-      const mode = owner?.parents;
-      const above = owner && {
-        uid: owner.uid,
-        gid: owner.gid,
-        ...mode !== void 0 ? { mode, parents: mode } : {}
-      };
-      await this.mkdir(parentOf4(path), { recursive: true, ...above ? { owner: above } : {} });
-    }
+    const mode = owner?.parents;
+    const above = owner && {
+      uid: owner.uid,
+      gid: owner.gid,
+      ...mode !== void 0 ? { mode, parents: mode } : {}
+    };
+    await this.mkdir(parentOf4(path), { recursive: true, ...above ? { owner: above } : {} });
     const parent = await this.locate(parentOf4(path), true);
     if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
     this.refuse(resolvePath(parent.path, baseOf(path)));
     await parent.handle.getDirectoryHandle(baseOf(path), { create: true });
+    const now = Date.now();
     const made2 = `${parent.path === "/" ? "" : parent.path}/${baseOf(path)}`;
     await this.stampNew(made2, owner, true);
-    this.touch(parent.path, made2);
+    this.touch(now, parent.path, made2);
+  }
+  async mkdirExcl(path, owner) {
+    const parent = await this.locate(parentOf4(path), true);
+    if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
+    const dir = parent.handle;
+    const name2 = baseOf(path);
+    const physical = resolvePath(parent.path, name2);
+    await this.locked(physical, async () => {
+      if (await this.handleExists(dir, name2)) throw fsError("EEXIST", path);
+      const freshMeta = this.meta.fresh ? await this.meta.fresh([path]) : await this.meta.get([path]);
+      if (freshMeta[0]?.link !== void 0) throw fsError("EEXIST", path);
+      this.forget(physical);
+      this.refuse(physical);
+      await dir.getDirectoryHandle(name2, { create: true });
+      const now = Date.now();
+      const made2 = `${parent.path === "/" ? "" : parent.path}/${name2}`;
+      await this.stampNew(made2, owner, true);
+      this.touch(now, parent.path, made2);
+    });
+  }
+  async createExclusive(path, owner) {
+    const parent = await this.locate(parentOf4(path), true);
+    if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
+    const dir = parent.handle;
+    const name2 = baseOf(path);
+    const physical = resolvePath(parent.path, name2);
+    await this.locked(physical, async () => {
+      if (await this.handleExists(dir, name2)) throw fsError("EEXIST", path);
+      const freshMeta = this.meta.fresh ? await this.meta.fresh([path]) : await this.meta.get([path]);
+      if (freshMeta[0] !== void 0) throw fsError("EEXIST", path);
+      this.forget(physical);
+      this.refuse(physical);
+      await dir.getFileHandle(name2, { create: true });
+      const now = Date.now();
+      const made2 = `${parent.path === "/" ? "" : parent.path}/${name2}`;
+      await this.stampNew(made2, owner, false);
+      this.touch(now, parent.path, made2);
+    });
+  }
+  async handleExists(dir, name2) {
+    try {
+      await dir.getDirectoryHandle(name2);
+      return true;
+    } catch (err) {
+      if (err?.name === "TypeMismatchError") return true;
+      if (err?.name === "NotFoundError") return false;
+      throw err;
+    }
   }
   async rm(path, options = {}) {
     let found;
@@ -4433,8 +4647,8 @@ var OpfsFs = class {
       if (options.force && error.code === "ENOENT") return;
       throw error;
     }
-    this.refuse(found.path, true);
     if (options.file && found.handle?.kind === "directory") throw fsError("EISDIR", path);
+    this.refuse(found.path, true);
     if (found.handle) {
       const [dir, name2] = await this.parent(found.path);
       try {
@@ -4445,22 +4659,23 @@ var OpfsFs = class {
       } catch (err) {
         throw translate(err, path);
       }
+      const now = Date.now();
       const file = found.handle.kind === "file";
       if (!file || this.remote?.watched()) this.changed(found.path);
       else this.forget(found.path);
       this.movePending(found.path);
       if (file && this.meta.absent?.(found.path)) {
-        this.touch(parentOf4(found.path));
+        this.touch(now, parentOf4(found.path));
         return;
       }
       if (file && this.meta.removeFile) {
         await this.meta.removeFile(found.path);
-        this.touch(parentOf4(found.path));
+        this.touch(now, parentOf4(found.path));
         return;
       }
     }
     await this.meta.remove([found.path]);
-    this.touch(parentOf4(found.path));
+    this.touch(Date.now(), parentOf4(found.path));
   }
   links() {
     return false;
@@ -4468,11 +4683,14 @@ var OpfsFs = class {
   async link(from, to, follow2) {
     await (follow2 ? this.stat(from) : this.lstat(from));
     if (!(await this.stat(parentOf4(to))).isDirectory) throw fsError("ENOTDIR", to);
-    if (await this.lstat(to).then(
+    const taken = await this.lstat(to).then(
       () => true,
-      () => false
-    ))
-      throw fsError("EEXIST", to);
+      (err) => {
+        if (missing2(err)) return false;
+        throw err;
+      }
+    );
+    if (taken) throw fsError("EEXIST", to);
     throw fsError("EPERM", `${from}: this file system has no hard links`);
   }
   async rename(from, to) {
@@ -4512,7 +4730,7 @@ var OpfsFs = class {
     if (source.link) {
       if (target?.handle) await this.rm(destination);
       await this.meta.move(source.path, destination, carry);
-      this.touch(parentOf4(source.path), parent.path);
+      this.touch(Date.now(), parentOf4(source.path), parent.path);
       return;
     }
     const dir = parent.handle;
@@ -4535,7 +4753,7 @@ var OpfsFs = class {
     }
     if (copied) await this.restamp(destination, timed2);
     this.changed(source.path, destination);
-    this.touch(parentOf4(source.path), parent.path);
+    this.touch(Date.now(), parentOf4(source.path), parent.path);
   }
   async modified(path) {
     const handle = await this.handle(path);
@@ -4605,7 +4823,7 @@ var OpfsFs = class {
         ...fields
       }))
     );
-    this.touch(parent.path);
+    this.touch(Date.now(), parent.path);
   }
   async realpath(path, follow2) {
     return (await this.locate(path, follow2)).path;
@@ -5259,15 +5477,15 @@ function frame(opcode, payload) {
   const n = payload.length;
   const size = n < 126 ? 2 : n < 65536 ? 4 : 10;
   const out = new Uint8Array(size + n);
-  const view = new DataView(out.buffer);
+  const view2 = new DataView(out.buffer);
   out[0] = 128 | opcode;
   if (n < 126) out[1] = n;
   else if (n < 65536) {
     out[1] = 126;
-    view.setUint16(2, n);
+    view2.setUint16(2, n);
   } else {
     out[1] = 127;
-    view.setBigUint64(2, BigInt(n));
+    view2.setBigUint64(2, BigInt(n));
   }
   out.set(payload, size);
   return out;
@@ -5389,9 +5607,9 @@ var WsReader = class {
     if (short < 126) return short;
     const ext = new Uint8Array(short === 126 ? 2 : 8);
     await fill(this.incoming, ext, signal);
-    const view = new DataView(ext.buffer);
-    if (short === 126) return view.getUint16(0);
-    const long = view.getBigUint64(0);
+    const view2 = new DataView(ext.buffer);
+    if (short === 126) return view2.getUint16(0);
+    const long = view2.getBigUint64(0);
     return long > BigInt(this.max) ? this.max + 1 : Number(long);
   }
   take(opcode, fin, payload) {
@@ -7571,6 +7789,7 @@ var ClipboardChannel = class {
   size = 0;
   wrote = false;
   failed = false;
+  aborted = false;
   constructor(broker, access2, stamp) {
     this.broker = broker;
     this.access = access2;
@@ -7625,11 +7844,14 @@ var ClipboardChannel = class {
   poll() {
     return READY;
   }
+  abort() {
+    this.aborted = true;
+  }
   async close() {
     this.snapshot = void 0;
     this.taken = void 0;
     const commits = this.access === "write" || this.access === "both" && this.wrote;
-    if (!commits || this.failed) return;
+    if (!commits || this.failed || this.aborted) return;
     const bytes = joined2(this.chunks, this.size);
     this.chunks = [];
     this.size = 0;
@@ -7872,6 +8094,15 @@ function parseSize(text) {
   if (!match) throw errnoError("EINVAL", `not a size: ${text}`);
   return Math.floor(Number(match[1]) * UNITS[match[2].toLowerCase()]);
 }
+function linkedTo(mount, path) {
+  const own = mount.attrs.get(path)?.value;
+  const ino = own?.kind === "directory" ? void 0 : own?.ino;
+  return (attr2) => {
+    if (!attr2 || attr2.kind === "directory") return false;
+    if (ino !== void 0) return attr2.ino === ino;
+    return own?.kind !== "directory" && (attr2.nlink ?? 1) > 1;
+  };
+}
 var within5 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var HeldSet = class extends Set {
   idle;
@@ -8313,10 +8544,13 @@ var MountTable = class {
   }
   forget(mount, path) {
     mount.epoch++;
-    for (const key of [...mount.attrs.keys()]) if (within5(key, path)) mount.attrs.delete(key);
+    const linked2 = mount.caps.links ? linkedTo(mount, path) : () => false;
+    for (const [key, cached] of [...mount.attrs])
+      if (within5(key, path) || linked2(cached.value)) mount.attrs.delete(key);
     mount.lists.delete(path);
     mount.lists.delete(parentOf7(path));
-    for (const key of [...mount.lists.keys()]) if (within5(key, path)) mount.lists.delete(key);
+    for (const [key, cached] of [...mount.lists])
+      if (within5(key, path) || cached.value.some((e) => linked2(e.attr))) mount.lists.delete(key);
   }
   async getattr(mount, path, rel2, settled = false) {
     for (let round = 1; ; round++) {
@@ -8365,12 +8599,64 @@ function noteExtent(extents, from, to) {
     last[1] = Math.max(last[1], to);
   } else extents.push([from, to]);
 }
-var MountFs = class {
+var RELINKED = [
+  ["readFileBuffer", [0]],
+  ["writeFile", [0]],
+  ["pread", [0]],
+  ["pwrite", [0]],
+  ["truncate", [0]],
+  ["lstat", [0]],
+  ["stat", [0]],
+  ["readdir", [0]],
+  ["readdirStat", [0]],
+  ["mkdir", [0]],
+  ["rm", [0]],
+  ["rename", [0, 1]],
+  ["symlink", [1]],
+  ["readlink", [0]],
+  ["chown", [0]],
+  ["chmod", [0]],
+  ["utimes", [0]],
+  ["lutimes", [0]]
+];
+var MountFs = class _MountFs {
   table;
   base;
-  constructor(table, base) {
+  rejectLinks;
+  constructor(table, base, rejectLinks = false) {
     this.table = table;
     this.base = base;
+    this.rejectLinks = rejectLinks;
+  }
+  static {
+    const proto = _MountFs.prototype;
+    for (const [name2, at] of RELINKED) {
+      const run2 = proto[name2];
+      proto[name2] = async function(...args) {
+        try {
+          return await run2.apply(this, args);
+        } catch (err) {
+          const moved2 = await this.relinked(err, args, at);
+          if (!moved2) throw err;
+          return this[name2](...moved2);
+        }
+      };
+    }
+  }
+  async relinked(err, args, at) {
+    if (err?.code !== "ENOTDIR") return void 0;
+    const moved2 = [...args];
+    let changed = false;
+    for (const i of at) {
+      const path = args[i];
+      if (typeof path !== "string" || !this.at(path)) continue;
+      const named = await this.named(path).catch(() => void 0);
+      if (named === void 0 || named === normalizePath(path)) continue;
+      if (this.rejectLinks) throw errnoError("ELOOP", path);
+      moved2[i] = named;
+      changed = true;
+    }
+    return changed ? moved2 : void 0;
   }
   at(path) {
     return this.table.locate(normalizePath(path));
@@ -8421,6 +8707,7 @@ var MountFs = class {
       throw err;
     }
     if (attr2.kind !== "symlink") return real;
+    if (this.rejectLinks) throw errnoError("ELOOP", path);
     if (hops >= MAX_LINKS7) throw errnoError("ELOOP", path);
     const target = await found.mount.conn.call({ op: "readlink", path: found.rel });
     return this.follow(this.base.resolvePath(parentOf7(real), target), hops + 1, create);
@@ -8825,6 +9112,7 @@ var MountFs = class {
     }
     const { mount, rel: rel2 } = found;
     const real = normalizePath(path);
+    if (options.file && rel2 === "/") throw errnoError("EISDIR", real);
     if (rel2 === "/" && options.recursive) await this.rmEach(real, mount, rel2, options);
     if (rel2 === "/") throw errnoError("EBUSY", `${real} is a mount point`);
     this.writable(mount, real);
@@ -9060,8 +9348,22 @@ var MountFs = class {
     this.table.forget(found.mount, real);
     await found.mount.conn.call({ op: "setattr", path: found.rel, mtime: mtime.getTime() });
   }
+  noLinks() {
+    const noLinkBase = this.base.noLinks.call(this.base);
+    return view(this, { rejectLinks: true, base: noLinkBase });
+  }
 };
 
+// src/fs/dev-removal.ts
+function inDevTree(path) {
+  return path === "/dev" || path.startsWith("/dev/");
+}
+function devRemoval(path, cred) {
+  if (!inDevTree(path)) return void 0;
+  if (cred && cred.euid !== 0) return "EACCES";
+  return path === "/dev" ? "EBUSY" : "EPERM";
+}
+
 // src/realm/sync-fs-token-registry.ts
 var registry = /* @__PURE__ */ new Map();
 function mintSyncFsToken(entry) {
@@ -9174,6 +9476,22 @@ function plainDirMode(entry, mode) {
   const wanted = mode & 4095 & ~(entry.umask?.() ?? 18);
   return wanted === PLAIN_DIR_MODE ? void 0 : wanted;
 }
+function plainParentsMode(entry) {
+  if (entry.cred) return void 0;
+  const wanted = 511 & ~(entry.umask?.() ?? 18) | 192;
+  return wanted === PLAIN_DIR_MODE ? void 0 : wanted;
+}
+async function missingParents(fs, path, mode) {
+  const parts2 = path.split("/").filter(Boolean);
+  const dirs = [];
+  for (let i = 1; i < parts2.length; i++) {
+    const p = `/${parts2.slice(0, i).join("/")}`;
+    if (!await fs.exists(p)) dirs.push(p);
+  }
+  return async () => {
+    for (const p of dirs) await fs.chmod(p, mode);
+  };
+}
 function mkdirOptions(entry, mode = 511) {
   const owner = ownerFor2(entry, mode);
   if (!owner) return { recursive: true };
@@ -9185,23 +9503,39 @@ async function mkdirExclusive(entry, path, mode) {
   await entry.fs.mkdir(path, owner ? { owner } : {});
 }
 async function chown(entry, path, req) {
+  const real = req.handle !== void 0 ? await keptOr(entry, path, req.handle) : path;
   const cred = entry.cred?.();
   if (!cred) {
-    await (req.op === "chown" ? entry.fs.stat(path) : entry.fs.lstat(path));
+    await (req.op === "chown" ? entry.fs.stat(real) : entry.fs.lstat(real));
     return done;
   }
-  await chownAs(entry.fs, cred, path, {
+  await chownAs(entry.fs, cred, real, {
     ...req.uid !== void 0 ? { uid: req.uid } : {},
     ...req.gid !== void 0 ? { gid: req.gid } : {},
     follow: req.op === "chown"
   });
   return done;
 }
+async function runMkdir(entry, path, req) {
+  const { fs } = entry;
+  const plain = plainDirMode(entry, req.mode);
+  const parentsMode = !req.exclusive ? plainParentsMode(entry) : void 0;
+  const fixParents = parentsMode !== void 0 ? await missingParents(fs, path, parentsMode) : void 0;
+  const fresh2 = plain !== void 0 && !await fs.exists(path);
+  await (req.exclusive ? mkdirExclusive(entry, path, req.mode) : fs.mkdir(path, mkdirOptions(entry, req.mode)));
+  await fixParents?.();
+  if (fresh2) await fs.chmod(path, plain);
+  return done;
+}
+function readSource(entry, path) {
+  const plain = () => entry.fs.readFileBuffer(path);
+  return entry.source ? entry.source.read(path, plain) : plain();
+}
 async function run(entry, path, req) {
   const { fs, cwd } = entry;
   switch (req.op) {
     case "read":
-      return { ok: true, kind: "bytes", bytes: await fs.readFileBuffer(path) };
+      return { ok: true, kind: "bytes", bytes: await readSource(entry, path) };
     case "write":
       await fs.writeFile(path, req.body ?? new Uint8Array(0), ownerFor2(entry, 438));
       return done;
@@ -9215,13 +9549,8 @@ async function run(entry, path, req) {
       return json2(await fs.readdir(path));
     case "readdir-stat":
       return json2(await readdirStat(fs, path));
-    case "mkdir": {
-      const plain = plainDirMode(entry, req.mode);
-      const fresh2 = plain !== void 0 && !await fs.exists(path);
-      await (req.exclusive ? mkdirExclusive(entry, path, req.mode) : fs.mkdir(path, mkdirOptions(entry, req.mode)));
-      if (fresh2) await fs.chmod(path, plain);
-      return done;
-    }
+    case "mkdir":
+      return runMkdir(entry, path, req);
     case "rm":
       await fs.rm(path, { recursive: true });
       return done;
@@ -9247,7 +9576,7 @@ async function run(entry, path, req) {
       return done;
     case "create":
       await createExclusive(fs, path, ownerFor2(entry, req.mode ?? 438));
-      entry.created?.add(path);
+      if (req.opening) entry.created?.add(path);
       entry.fresh?.(path);
       return done;
     case "readlink":
@@ -9258,10 +9587,10 @@ async function run(entry, path, req) {
       return done;
     }
     case "utimes":
-      await fs.utimes(path, new Date(req.atimeMs ?? 0), new Date(req.mtimeMs ?? 0));
+      await fs.utimes(path, ...await timesOf(entry, path, req));
       return done;
     case "lutimes":
-      await lutimesOf(fs, path, new Date(req.atimeMs ?? 0), new Date(req.mtimeMs ?? 0));
+      await lutimesOf(fs, path, ...await timesOf(entry, path, req));
       return done;
     case "chown":
     case "lchown":
@@ -9274,6 +9603,17 @@ async function run(entry, path, req) {
       return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
   }
 }
+async function timesOf(entry, path, req) {
+  const given = [new Date(req.atimeMs ?? 0), new Date(req.mtimeMs ?? 0)];
+  const g = req.now === true ? guardOf(entry) : void 0;
+  if (!g || g.cred.euid === 0) return given;
+  const look = req.op === "lutimes" ? entry.fs.lstat : entry.fs.stat;
+  const st = await look.call(entry.fs, path).catch(() => void 0);
+  if (!st || (st.uid ?? 0) === g.cred.euid) return given;
+  const now = /* @__PURE__ */ new Date();
+  const kept = (ms, stored) => ms === stored.getTime() ? stored : now;
+  return [kept(req.atimeMs, st.atime), kept(req.mtimeMs, st.mtime)];
+}
 function guardOf(entry) {
   const cred = entry.dac && entry.cred?.();
   if (!cred || !entry.dac) return void 0;
@@ -9283,41 +9623,82 @@ function guardOf(entry) {
 var FOLLOWING = /* @__PURE__ */ new Set(["exists", "stat", "chown", "statfs"]);
 var LOOKS = /* @__PURE__ */ new Set(["exists", "stat", "lstat"]);
 var NOT_FOLLOWING = /* @__PURE__ */ new Set(["lstat", "readlink", "lchown"]);
+async function walkSafe(g, path, follow2) {
+  try {
+    const walked = await walk(g.fs, g.cred, path, follow2, g.links);
+    return walked.path;
+  } catch {
+    return path;
+  }
+}
 async function guard(g, path, req, cwd) {
   const { op } = req;
-  if (FOLLOWING.has(op) || NOT_FOLLOWING.has(op)) return searchable(g, op, path, FOLLOWING.has(op));
+  if (FOLLOWING.has(op) || NOT_FOLLOWING.has(op)) {
+    const walked = await need(g, op, path, 0, { follow: FOLLOWING.has(op) });
+    return { path: walked.path };
+  }
   const other = () => g.fs.resolvePath(cwd, req.arg2 ?? "");
   switch (op) {
     case "readdir":
-    case "readdir-stat":
-      return listable(g, op, path);
-    case "mkdir":
-      return makeIn(g, op, path);
+    case "readdir-stat": {
+      await listable(g, op, path);
+      const w = await walkSafe(g, path, true);
+      return { path: w };
+    }
+    case "mkdir": {
+      await makeIn(g, op, path);
+      return { path: await walkSafe(g, path, false) };
+    }
     case "create":
     case "symlink":
-      return inParent(g, op, path);
+      await inParent(g, op, path);
+      return { path: await walkSafe(g, path, op === "create") };
     case "unlink":
-    case "rmdir":
-      return inParent(g, op, path, true);
-    case "rm":
-      return removable(g, op, path);
-    case "rename":
-      return renamable(g, path, other());
-    case "link":
-      return linkable(g, path, other(), req.mode === 1);
+    case "rmdir": {
+      await inParent(g, op, path, true);
+      const w = await walkSafe(g, path, false);
+      return { path: w };
+    }
+    case "rm": {
+      await removable(g, op, path);
+      const w = await walkSafe(g, path, false);
+      return { path: w };
+    }
+    case "rename": {
+      const to = other();
+      await renamable(g, path, to);
+      const fromWalked = await walkSafe(g, path, false);
+      const toWalked = await walkSafe(g, to, false);
+      return { path: fromWalked, arg2: toWalked };
+    }
+    case "link": {
+      const to = other();
+      const follow2 = req.mode === 1;
+      await linkable(g, path, to, follow2);
+      const fromWalked = await walkSafe(g, path, follow2);
+      const toWalked = await walkSafe(g, to, false);
+      return { path: fromWalked, arg2: toWalked };
+    }
     case "utimes":
-    case "lutimes":
-      return retimable(g, op, path, req.now === true);
+    case "lutimes": {
+      await retimable(g, op, path, req.now === true);
+      const follow2 = op === "utimes";
+      const w = await walkSafe(g, path, follow2);
+      return { path: w };
+    }
     case "read":
     case "pread":
-      return req.handle === void 0 ? readable(g, op, path) : void 0;
+      if (req.handle === void 0) await readable(g, op, path);
+      return { path: await walkSafe(g, path, true) };
     case "pwrite":
     case "truncate":
-      return req.handle === void 0 ? fileWritable(g, op, path) : void 0;
+      if (req.handle === void 0) await fileWritable(g, op, path);
+      return { path: await walkSafe(g, path, true) };
     case "write":
-      return req.handle === void 0 && req.mode !== 1 ? writable(g, op, path) : void 0;
+      if (req.handle === void 0 && req.mode !== 1) await writable(g, op, path);
+      return { path: await walkSafe(g, path, true) };
     default:
-      return void 0;
+      return { path: await walkSafe(g, path, true) };
   }
 }
 async function opening(entry, path, mode) {
@@ -9334,6 +9715,7 @@ async function holdOp(entry, path, req) {
   if (on && open) {
     await opening(entry, path, mode);
     const real = await entry.fs.realpath?.(path, true).catch(() => path);
+    await entry.source?.open(path, real);
     return json2(entry.hold?.(path, on, open, real) ?? null);
   }
   entry.hold?.(path, on, open, void 0, req.handle);
@@ -9386,15 +9768,16 @@ async function mayChange(entry, path, req) {
 }
 async function guarded(entry, path, req) {
   const g = guardOf(entry);
-  if (!g) return void 0;
-  if (LOOKS.has(req.op) && await entry.holdsKept?.(path)) return void 0;
+  if (!g) return {};
+  if (LOOKS.has(req.op) && await entry.holdsKept?.(path)) return {};
   try {
     await mayChange(entry, path, req);
-    await guard(g, path, req, entry.cwd);
-    return void 0;
+    const paths = await guard(g, path, req, entry.cwd);
+    return { paths };
   } catch (err) {
     const refusal2 = err.code === "EACCES";
-    return req.op === "exists" && refusal2 ? json2(false) : toErrno(err);
+    const refused2 = req.op === "exists" && refusal2 ? json2(false) : toErrno(err);
+    return { refused: refused2 };
   }
 }
 async function createExclusive(fs, path, owner) {
@@ -9420,6 +9803,7 @@ async function ranged(fs, path, req) {
   else await ops.truncate(path, req.length ?? 0);
   return done;
 }
+var CHOWN_OPS = /* @__PURE__ */ new Set(["chown", "lchown"]);
 var UNLINKED_OPS = /* @__PURE__ */ new Set(["read", "pread", "pwrite", "truncate"]);
 var OWN_OPS = /* @__PURE__ */ new Set(["rm", "unlink", "rmdir", "rename", "link"]);
 var TWO_PATHS = /* @__PURE__ */ new Set(["rename", "link"]);
@@ -9484,7 +9868,7 @@ async function rmPermitted(entry, path, req, refused2) {
   const st = await entry.fs.lstat(path).catch(() => void 0);
   if (!st?.isDirectory) return refused2;
   const unlisted = await guarded(entry, path, { ...req, op: "readdir" });
-  if (unlisted) return unlisted;
+  if ("refused" in unlisted) return unlisted.refused;
   const names = await entry.fs.readdir(path).catch(() => void 0);
   if (!names) return refused2;
   let first;
@@ -9496,31 +9880,64 @@ async function rmPermitted(entry, path, req, refused2) {
     if (!child.ok) first ??= child;
   }
   if (first) return first;
-  const again = await guarded(entry, path, req);
-  return again ?? await run(entry, path, req);
+  const g = guardOf(entry);
+  if (g) {
+    try {
+      await inParent(g, "rm", path, true);
+    } catch (err) {
+      return toErrno(err);
+    }
+  }
+  return await run(entry, path, req);
+}
+async function byHandle(entry, path, req) {
+  if (req.op === "kept") return json2(entry.keptFor?.(req.handle ?? -1) !== void 0);
+  if (req.op === "stat" && req.handle !== void 0) return keptStat(entry, req);
+  if (CHOWN_OPS.has(req.op) && entry.keptFor?.(req.handle ?? -1)) return chown(entry, path, req);
+  return void 0;
+}
+async function guardAndResolve(entry, path, req) {
+  const result = await guarded(entry, path, req);
+  if ("refused" in result) return result.refused;
+  const { noLinks } = entry;
+  const { paths } = result;
+  if (entry.links === void 0 || !noLinks || !paths) return { path, entry };
+  return {
+    path: paths.path,
+    ...paths.arg2 ? { arg2: paths.arg2 } : {},
+    entry: { ...entry, fs: noLinks }
+  };
 }
+var REMOVALS = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm"]);
 async function dispatchOne(entry, req) {
   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 === "stat" && req.handle !== void 0) return await keptStat(entry, req);
+    const device = REMOVALS.has(req.op) ? devRemoval(path, entry.cred?.()) : void 0;
+    if (device) return { ok: false, errno: device, message: `${path}: a device entry stays` };
+    const held = await byHandle(entry, path, req);
+    if (held) return held;
     if (req.op === "access") return await accessOp(entry, path, req);
     if (req.op === "hold") return await holdOp(entry, path, req);
-    const refused2 = await guarded(entry, path, req);
-    if (refused2 && req.op === "rm" && !refused2.ok && DENIED.has(refused2.errno)) {
-      return await rmPermitted(entry, path, req, refused2);
-    }
-    if (refused2) return refused2;
-    if (req.op === "statfs") return json2(await usageAt(entry, path) ?? await storageUsage());
-    if (entry.revoked?.(path)) return { ok: false, errno: "EIO", message: `${path} was unmounted` };
+    const resolved2 = await guardAndResolve(entry, path, req);
+    if (!("entry" in resolved2)) {
+      if (req.op === "rm" && !resolved2.ok && DENIED.has(resolved2.errno))
+        return await rmPermitted(entry, path, req, resolved2);
+      return resolved2;
+    }
+    const { path: resolvedPath, arg2: resolvedArg2, entry: opEntry } = resolved2;
+    const opReq = resolvedArg2 ? { ...req, arg2: resolvedArg2 } : req;
+    if (req.op === "statfs")
+      return json2(await usageAt(entry, resolvedPath) ?? await storageUsage());
+    if (entry.revoked?.(resolvedPath))
+      return { ok: false, errno: "EIO", message: `${resolvedPath} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
-      const serve = async () => run(entry, await keptOr(entry, path, req.handle), req);
-      return await (entry.gate ? entry.gate(path, serve) : serve());
+      const serve = async () => run(opEntry, await keptOr(opEntry, resolvedPath, req.handle), opReq);
+      return await (entry.gate ? entry.gate(resolvedPath, serve) : serve());
     }
-    if (!entry.own || !OWN_OPS.has(req.op)) return await run(entry, path, req);
-    const target = TWO_PATHS.has(req.op) ? fs.resolvePath(cwd, req.arg2 ?? "") : path;
-    return await owned2(entry, entry.own, req, path, target);
+    if (!entry.own || !OWN_OPS.has(req.op)) return await run(opEntry, resolvedPath, opReq);
+    const target = resolvedArg2 ?? (TWO_PATHS.has(req.op) ? fs.resolvePath(cwd, req.arg2 ?? "") : resolvedPath);
+    return await owned2(opEntry, entry.own, opReq, resolvedPath, target);
   } catch (err) {
     return toErrno(err);
   }
@@ -9548,6 +9965,15 @@ var SAB_I_KILLED = 13;
 var SAB_I_ASYNC = 14;
 var SAB_I_STOP = 15;
 var SAB_I_BLOCKED = 16;
+var SAB_I_BLOCKED_HI = 17;
+function loadBlocked(header4) {
+  return [Atomics.load(header4, SAB_I_BLOCKED), Atomics.load(header4, SAB_I_BLOCKED_HI)];
+}
+function storeBlocked(header4, [low, high]) {
+  Atomics.store(header4, SAB_I_BLOCKED_HI, high);
+  Atomics.store(header4, SAB_I_BLOCKED, low);
+}
+var anyBlocked = (mask) => mask !== void 0 && (mask[0] !== 0 || mask[1] !== 0);
 var U32 = 2 ** 32;
 function storeU53(header4, lo, hi, value) {
   Atomics.store(header4, hi, Math.floor(value / U32));
@@ -10074,7 +10500,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.92.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.93.1" : "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
@@ -10774,21 +11200,28 @@ function bodyOf(incoming, head, method, signal) {
 var KernelLoopback = class {
   net;
   cred;
-  constructor(net, cred) {
+  stamp;
+  constructor(net, cred, stamp) {
     this.net = net;
     this.cred = cred;
+    this.stamp = stamp;
   }
   port(url) {
     return kernelLoopbackPort(url);
   }
-  connect(url, port, signal) {
+  async connect(url, port, signal) {
     if (url.protocol === "https:" || url.protocol === "wss:") {
       throw errno("ENOTSUP", `TLS to the kernel's loopback is not supported: ${url.origin}`);
     }
     signal.throwIfAborted();
     const socket = this.net.socket("inet");
     try {
-      void socket.connect({ family: "inet", host: "127.0.0.1", port }, false, this.cred());
+      void socket.connect(
+        { family: "inet", host: "127.0.0.1", port },
+        false,
+        this.cred(),
+        this.stamp ? await this.stamp() : void 0
+      );
     } catch (err) {
       socket.close();
       const refused2 = err instanceof KernelError && err.code === "ECONNREFUSED";
@@ -10802,7 +11235,7 @@ var KernelLoopback = class {
     const body = req.body ?? (/^(POST|PUT|PATCH)$/i.test(req.method) ? new Uint8Array(0) : void 0);
     const length2 = body ? [["Content-Length", String(body.length)]] : [];
     const head = requestHead(req.method, url, req.headers, [...length2, ["Connection", "close"]]);
-    const socket = this.connect(url, port, req.signal);
+    const socket = await this.connect(url, port, req.signal);
     try {
       await writeAll2(socket, body ? concat([head, body]) : head, req.signal);
       const incoming = new Incoming(socket);
@@ -10823,7 +11256,7 @@ var KernelLoopback = class {
   }
   async websocket(req, port) {
     const url = new URL(req.url);
-    const socket = this.connect(url, port, req.signal);
+    const socket = await this.connect(url, port, req.signal);
     try {
       const key = btoa(String.fromCharCode(...crypto.getRandomValues(new Uint8Array(16))));
       const extra = [
@@ -10848,6 +11281,9 @@ var KernelLoopback = class {
       if (!upgraded || accept2 !== await acceptFor(key)) {
         throw errno("EPROTO", "the server did not accept the WebSocket key");
       }
+      if (fieldValues(head.headers, "sec-websocket-extensions").length > 0) {
+        throw errno("EPROTO", "the server offered an unsolicited extension");
+      }
       const protocol = fieldValues(head.headers, "sec-websocket-protocol")[0] ?? "";
       return new LoopbackWebSocket(socket, incoming, protocol);
     } catch (err) {
@@ -10947,7 +11383,7 @@ var LoopbackWebSocket = class {
     })();
   }
   async pump(reader, deliver) {
-    let close = { code: 1006, reason: "" };
+    let close = { code: 1006, reason: "", wasClean: false };
     try {
       for (; ; ) {
         await this.space();
@@ -10957,14 +11393,14 @@ var LoopbackWebSocket = class {
         else if (event.kind === "binary") deliver(event.bytes);
         else if (event.kind === "ping") this.write(clientFrame(OP_PONG, event.payload));
         else {
-          close = { code: event.code, reason: event.reason };
+          close = { code: event.code, reason: event.reason, wasClean: true };
           if (!this.sentClose) this.sendClose(event.code === 1005 ? 1e3 : event.code, "");
           break;
         }
       }
     } catch (err) {
       if (err instanceof WsError) this.sendClose(err.code, err.message);
-      close = { code: err instanceof WsError ? err.code : 1006, reason: "" };
+      close = { code: 1006, reason: "", wasClean: false };
     } finally {
       const late = setTimeout(() => this.stop.abort(), CLOSE_WAIT_MS3);
       await this.writes;
@@ -11754,14 +12190,22 @@ var WsHandles = class {
         return typeof next2.value === "string" ? { ok: true, kind: "json", json: { text: next2.value } } : { ok: true, kind: "bytes", bytes: next2.value };
       }
       const closed = await socket.closed;
-      return { ok: true, kind: "json", json: { code: closed.code, reason: closed.reason } };
+      return {
+        ok: true,
+        kind: "json",
+        json: { code: closed.code, reason: closed.reason, wasClean: closed.wasClean === true }
+      };
     } catch (e) {
       return fail("ECONNRESET", message(e));
     }
   }
   async closed(socket) {
-    const { code, reason } = await socket.closed;
-    return { ok: true, kind: "json", json: { code, reason } };
+    const closed = await socket.closed;
+    return {
+      ok: true,
+      kind: "json",
+      json: { code: closed.code, reason: closed.reason, wasClean: closed.wasClean === true }
+    };
   }
   send(socket, req, entry) {
     const data = req.text ?? req.body;
@@ -11801,7 +12245,7 @@ function message2(e) {
 }
 function codeOf2(e) {
   const code = e?.code;
-  return typeof code === "string" && /^E[A-Z]+$/.test(code) ? code : "EIO";
+  return typeof code === "string" && /^E[A-Z]+$|^EAI_[A-Z]+$/.test(code) ? code : "EIO";
 }
 async function* once(bytes) {
   yield bytes;
@@ -11884,7 +12328,8 @@ var HttpHandles = class {
       if (port !== void 0) return { ok: false, errno: codeOf2(e), message: text };
       const status = e.status;
       if (text === NO_TRANSPORT || typeof status !== "number" || status === 502) {
-        const errno2 = text === NO_TRANSPORT ? "ENETUNREACH" : "ECONNREFUSED";
+        const code = codeOf2(e);
+        const errno2 = text === NO_TRANSPORT ? "ENETUNREACH" : code !== "EIO" ? code : "ECONNREFUSED";
         return { ok: false, errno: errno2, message: text };
       }
       entry.body = once(new TextEncoder().encode(text))[Symbol.asyncIterator]();
@@ -13477,7 +13922,7 @@ function isPtySyscall(req) {
   return req.op.startsWith("pty-");
 }
 function isVfsSyscall(req) {
-  return req.op.startsWith("fd-path-") || req.op === "fd-pread" || req.op === "fd-pwrite" || req.op === "fd-resize" || req.op === "fd-vfs-stat";
+  return req.op.startsWith("fd-path-") || req.op === "fd-pread" || req.op === "fd-pwrite" || req.op === "fd-resize" || req.op === "fd-vfs-stat" || req.op === "fd-chmod" || req.op === "fd-chown" || req.op === "fd-utimes";
 }
 function isFdSyscall(req) {
   return req.op.startsWith("fd-");
@@ -13497,6 +13942,9 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-pwrite",
   "fd-resize",
   "fd-vfs-stat",
+  "fd-chmod",
+  "fd-chown",
+  "fd-utimes",
   "fd-path-flush",
   "fd-path-unlinking",
   "fd-path-unlinked",
@@ -13527,6 +13975,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-tty-owner",
   "fd-open-sealed",
   "fd-open-clipboard",
+  "fd-clipboard-abort",
   "tty-get",
   "tty-set",
   "tty-winsz",
@@ -13872,7 +14321,11 @@ var WasmProcess = class {
     if (!stderr?.write || stderr.clipboard) return;
     const line = `${name2}: /dev/clipboard: ${clipboardLine(err.detail)}
 `;
-    await stderr.write(new TextEncoder().encode(line), AbortSignal.timeout(1e3)).catch(() => 0);
+    const timeout = new Promise((r) => setTimeout(() => r(0), 1e3));
+    await Promise.race([
+      stderr.write(new TextEncoder().encode(line), AbortSignal.timeout(1e3)).catch(() => 0),
+      timeout
+    ]);
   }
   async write(fd, body, nonblock = false, cancelled) {
     const file = this.fds.get(fd).file;
@@ -13899,10 +14352,13 @@ var WasmProcess = class {
     await refuseReadonly(this.options.fs, req.path, req.flags, req);
     if (this.writesAt(req)) await this.options.fs.mayChange?.(req.path, !req.exclusive);
     await this.mayOpen(req);
+    const marked = await this.markedPath(req);
+    await this.sourceOpen(marked === void 0 ? req : { ...req, path: marked });
+    const fs = marked === void 0 ? this.options.fs : this.options.noLinks;
     const fd = this.fds.install(heldFile(), 3);
     try {
       const nodes = this.nodes;
-      const path = req.orphan ? req.path : req.exclusive ? await nodes.entryKey(req.path) : req.create ? await nodes.targetKey(req.path) : await this.keptOr(await nodes.targetKey(req.path), req.handle);
+      const path = await this.openPath(req, marked);
       if (inProc(path)) {
         this.fds.installAt(fd, await this.procFile(req, path));
         return fd;
@@ -13912,23 +14368,23 @@ var WasmProcess = class {
       const plain = this.plainMode(req.mode);
       if (req.exclusive) {
         await nodes.createExclusive(path, this.newOwner(req.mode));
-        if (plain !== void 0) await this.options.fs.chmod?.(path, plain);
-        this.fds.installAt(fd, this.openVfsFile(open));
+        if (plain !== void 0) await fs.chmod?.(path, plain);
+        this.fds.installAt(fd, this.openVfsFile(open, void 0, fs));
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
           const marks = this.options.owners || plain !== void 0;
-          const fresh2 = marks && !await present2(this.options.fs, path, true);
-          this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
+          const fresh2 = marks && !await present2(fs, path, true);
+          this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path), fs));
           await this.fds.get(fd).file.stat?.();
-          if (fresh2 && plain !== void 0) await this.options.fs.chmod?.(path, plain);
+          if (fresh2 && plain !== void 0) await fs.chmod?.(path, plain);
           else if (fresh2) {
-            await this.options.fs.chown?.(path, { ...this.newOwner(req.mode), kind: "new" });
+            await fs.chown?.(path, { ...this.newOwner(req.mode), kind: "new" });
           }
         });
       } else {
-        this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
+        this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path), fs));
       }
-      if (req.existing && !await present2(this.options.fs, path, true)) {
+      if (req.existing && !await present2(fs, path, true)) {
         throw new KernelError("ENOENT");
       }
     } catch (err) {
@@ -13962,6 +14418,27 @@ var WasmProcess = class {
   writesAt(req) {
     return (req.flags & WRITE_ACCESS) !== 0 || req.truncate === true || req.create === true || req.exclusive === true;
   }
+  async sourceOpen(req) {
+    const { source } = this.options;
+    const inherited2 = req.orphan || req.contents !== void 0 || req.handle !== void 0;
+    if (!source || inherited2 || req.pin !== void 0 || req.exclusive) return;
+    await source.open(req.path);
+  }
+  async markedPath(req) {
+    const { guard: guard2, noLinks } = this.options;
+    const inherited2 = req.orphan || req.contents !== void 0 || req.handle !== void 0;
+    if (guard2?.links === void 0 || !noLinks || inherited2 || req.pin !== void 0)
+      return void 0;
+    return (await walk(guard2.fs, this.cred, req.path, !req.exclusive, guard2.links)).path;
+  }
+  async openPath(req, marked) {
+    const nodes = this.nodes;
+    if (req.orphan) return req.path;
+    if (req.exclusive) return nodes.entryKey(marked ?? req.path);
+    if (marked !== void 0) return marked;
+    if (req.create) return nodes.targetKey(req.path);
+    return this.keptOr(await nodes.targetKey(req.path), req.handle);
+  }
   async mayOpen(req) {
     const { guard: guard2 } = this.options;
     const inherited2 = req.orphan || req.contents !== void 0 || req.handle !== void 0;
@@ -14061,9 +14538,9 @@ var WasmProcess = class {
     );
     return memoryFile(tree2.read(path), path, req.position);
   }
-  openVfsFile(req, id2) {
+  openVfsFile(req, id2, fs = this.options.fs) {
     return vfsFile(
-      this.options.fs,
+      fs,
       {
         path: req.path,
         flags: req.flags,
@@ -14146,7 +14623,7 @@ var WasmProcess = class {
         return { ok: true, kind: "void" };
       case "fd-renumber":
         if (req.from !== req.to) {
-          this.fds.dup2(req.from, req.to);
+          await this.fds.dup2Clipboard(req.from, req.to);
           if (!req.keep) await Promise.resolve(this.fds.close(req.from));
         }
         return { ok: true, kind: "void" };
@@ -14158,6 +14635,11 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.openSealed(req.flags) };
       case "fd-open-clipboard":
         return { ok: true, kind: "json", json: await this.openClipboard(req.flags) };
+      case "fd-clipboard-abort": {
+        const file = this.fds.get(req.fd);
+        file.file.clipboard?.abort();
+        return { ok: true, kind: "void" };
+      }
       case "fd-tty-owner":
         return { ok: true, kind: "json", json: this.terminalByName(req.name).owner ?? null };
       case "fd-select": {
@@ -14210,12 +14692,23 @@ var WasmProcess = class {
       case "fd-resize":
         await file.resize(req.size);
         return { ok: true, kind: "void" };
-      case "fd-vfs-stat":
-        return {
-          ok: true,
-          kind: "json",
-          json: req.identity ? await this.identified(file.stat.bind(file), file.known?.bind(file)) : await file.stat()
-        };
+      case "fd-vfs-stat": {
+        if (req.identity) {
+          return {
+            ok: true,
+            kind: "json",
+            json: await this.identified(file.stat.bind(file), file.known?.bind(file))
+          };
+        }
+        const vfs = await file.stat();
+        if (!req.full) return { ok: true, kind: "json", json: vfs };
+        const st = await this.heldStat(vfs).catch(() => void 0);
+        return { ok: true, kind: "json", json: { ...vfs, ...st ? { stat: st } : {} } };
+      }
+      case "fd-chmod":
+      case "fd-chown":
+      case "fd-utimes":
+        return this.fdMetadata(await file.stat(), req);
     }
   }
   keptPath;
@@ -14236,7 +14729,7 @@ var WasmProcess = class {
   async promote(req) {
     if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
     if (req.share !== void 0) {
-      this.fds.dup2(req.share, req.fd);
+      await this.fds.dup2Clipboard(req.share, req.fd);
       return;
     }
     if (req.path === void 0) throw new KernelError("EINVAL");
@@ -14265,6 +14758,46 @@ var WasmProcess = class {
     this.fds.installAt(fd, heldFile(meta));
     return fd;
   }
+  heldPath(vfs) {
+    if (!vfs.path) throw new KernelError("EBADF");
+    if (vfs.orphan) throw new KernelError("EOPNOTSUPP");
+    return vfs.path;
+  }
+  heldFs() {
+    return this.options.guard?.fs ?? this.options.fs;
+  }
+  async heldStat(vfs) {
+    const stat = this.heldFs().stat;
+    if (!stat) throw new KernelError("ENOSYS");
+    return stat.call(this.heldFs(), this.heldPath(vfs));
+  }
+  async fdMetadata(vfs, req) {
+    const path = this.heldPath(vfs);
+    const fs = this.heldFs();
+    const g = this.guarded();
+    if (req.op === "fd-chown") {
+      const ids = {
+        ...req.uid !== void 0 ? { uid: req.uid } : {},
+        ...req.gid !== void 0 ? { gid: req.gid } : {}
+      };
+      if (!this.options.owners || !fs.chown || !fs.stat) await this.heldStat(vfs);
+      else await chownAs(fs, this.cred, path, { ...ids, follow: true });
+      return { ok: true, kind: "void" };
+    }
+    const st = await this.heldStat(vfs);
+    if (req.op === "fd-chmod") {
+      if (!fs.chmod) throw new KernelError("ENOSYS");
+      await fs.chmod(path, g ? heldChmodMode(g, path, st, req.mode) : req.mode);
+      return { ok: true, kind: "void" };
+    }
+    if (!fs.utimes) throw new KernelError("ENOSYS");
+    if (g) heldRetimable(g, path, st, req.now === true);
+    const at = (ms, kept) => ms === null ? kept : req.now ? /* @__PURE__ */ new Date() : new Date(ms);
+    const atime = at(req.atimeMs, st.atime);
+    const mtime = at(req.mtimeMs, st.mtime);
+    await fs.utimes(path, atime, mtime);
+    return { ok: true, kind: "void" };
+  }
   fdInfo(fd) {
     const file = this.fds.get(fd).file;
     const flags2 = this.fds.statusFlags(fd);
@@ -14483,7 +15016,10 @@ var WasmProcess = class {
     const { file, argv, env, cwd, cred, caller } = answer.grant;
     const stdio = [{ fd: 0 }, { fd: 1 }, { fd: 2 }];
     return {
-      pid: await this.children.spawn({ file, argv, env, cwd }, stdio, [], { cred, caller })
+      pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
+        cred,
+        caller
+      })
     };
   }
   async mountSyscall(req, cancelled) {
@@ -14787,7 +15323,9 @@ function holdingToken(opts, holds, caller) {
     ...opts.dac ? { dac: opts.dac, pid: opts.pid, created: caller.created } : {},
     ...opts.links !== void 0 ? { links: opts.links } : {},
     ...opts.fresh ? { fresh: (path) => opts.fresh?.(path, caller.umask()) } : {},
+    ...opts.source ? { source: opts.source } : {},
     fs: opts.fs,
+    noLinks: opts.noLinks,
     cwd: opts.cwd,
     ...opts.statfs ? { statfs: opts.statfs } : {},
     hold: (path, on, open, real, handle) => holds.hold(path, on, open, real, handle),
@@ -14813,6 +15351,8 @@ function processOptions(opts, header4, hooks, created3) {
     ...opts.outputFilter ? { outputFilter: opts.outputFilter } : {},
     ...opts.clipboard ? { clipboard: opts.clipboard, ...clipboardName(opts) } : {},
     ...opts.readonlyAt ? { readonlyAt: opts.readonlyAt } : {},
+    ...opts.source ? { source: opts.source } : {},
+    noLinks: opts.noLinks,
     ...opts.dac ? { guard: { dac: opts.dac, fs: opts.fs, created: created3, ...linksOf(opts) } } : {},
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
@@ -14868,8 +15408,8 @@ function threadInit(opts, program, sab, cred, thread, main) {
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header4 = new Int32Array(sab, 0, SAB_HEADER_I32);
-  if (opts.blocked && opts.program.abi === "wasi")
-    Atomics.store(header4, SAB_I_BLOCKED, opts.blocked);
+  const blocked = opts.fork?.wasi?.blocked ?? opts.blocked;
+  if (blocked && anyBlocked(blocked) && opts.program.abi === "wasi") storeBlocked(header4, blocked);
   const threadSignals = /* @__PURE__ */ new Map();
   const created3 = new Created();
   const process2 = new WasmProcess(
@@ -14884,7 +15424,7 @@ function spawnWasmProcess(opts) {
         ...opts.program.abi === "js" ? {
           exitNow: (code) => exitNow(code),
           exitSignal: (sig) => queueMicrotask(() => finish(128 + sig, sig))
-        } : {}
+        } : { exitSignal: (sig) => terminate(128 + sig, sig) }
       },
       created3
     )
@@ -14970,7 +15510,7 @@ function spawnWasmProcess(opts) {
     const tsab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
     const tw = opts.createWorker();
     const tsignals = threadSignalsOf(tsab);
-    if (thread.blocked) Atomics.store(tsignals.header, SAB_I_BLOCKED, thread.blocked);
+    if (thread.blocked) storeBlocked(tsignals.header, thread.blocked);
     threadSignals.set(thread.tid, tsignals);
     const tdispatch = (req) => dying.serving(
       () => isWasmSyscall(req) ? process2.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
@@ -14998,12 +15538,13 @@ function spawnWasmProcess(opts) {
     processInit(opts, sab, process2.umask, copyCred(process2.cred), lane?.lane),
     transferOf(opts, lane?.lane)
   );
-  const signal = (sig) => {
-    if (process2.signal(sig) !== "terminate") return;
-    const code = sig === SIG.KILL ? 137 : 128 + sig;
+  const terminate = (code, sig) => {
     if (opts.program.abi !== "wasi" || done4) finish(code, sig);
     else dying.start(code, sig, header4, process2, () => finish(code, sig));
   };
+  const signal = (sig) => {
+    if (process2.signal(sig) === "terminate") terminate(sig === SIG.KILL ? 137 : 128 + sig, sig);
+  };
   const kill = (code = 137) => finish(code, code > 128 && code < 160 ? code - 128 : void 0);
   return {
     pid: opts.pid,
@@ -15014,7 +15555,7 @@ function spawnWasmProcess(opts) {
     onState: (listener) => process2.onState(listener),
     memory: () => Atomics.load(header4, SAB_I_MEMORY) * 65536,
     ignoredSignals: (fork) => process2.inheritable(fork),
-    blockedSignals: () => opts.program.abi === "wasi" ? Atomics.load(header4, SAB_I_BLOCKED) : 0,
+    blockedSignals: () => opts.program.abi === "wasi" ? loadBlocked(header4) : [0, 0],
     signalMasks: () => process2.signalMasks(),
     umask: () => process2.umask,
     cred: () => copyCred(process2.cred),
@@ -18223,14 +18764,16 @@ var SUDO_COMMAND = {
 var SUDO_SOURCE = [
   "export default async function sudo(ctx) {",
   "  const say = (fd, text) => ctx.write(fd, text).catch(() => undefined);",
+  '  const RELAYED = ["SIGTERM", "SIGHUP", "SIGINT", "SIGQUIT", "SIGUSR1", "SIGUSR2", "SIGALRM"];',
+  "  const NUMBER = { SIGTERM: 15, SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGUSR1: 10, SIGUSR2: 12, SIGALRM: 14 };",
   "  let pid;",
   "  let held;",
   "  const relay = (sig) => {",
   "    if (pid === undefined) held = sig;",
-  "    else return ctx.kill(pid, sig).catch(() => undefined);",
+  "    else return ctx.kill(-pid, sig).catch(() => undefined);",
   "  };",
-  '  for (const sig of ["SIGTERM", "SIGHUP"]) await ctx.signals.on(sig, relay);',
-  "  const failed = () => (held === undefined ? 1 : 128 + held);",
+  "  for (const sig of RELAYED) await ctx.signals.on(sig, () => relay(sig));",
+  "  const failed = () => (held === undefined ? 1 : 128 + NUMBER[held]);",
   "  let answer;",
   "  try {",
   "    answer = await ctx.sudo(ctx.argv.slice(1));",
@@ -18246,18 +18789,41 @@ var SUDO_SOURCE = [
   "    await say(1, answer.list);",
   "    return 0;",
   "  }",
-  '  for (const sig of ["SIGINT", "SIGQUIT"]) await ctx.signals.on(sig, () => undefined);',
   "  if (answer.run !== undefined) {",
   "    try {",
-  "      pid = (await ctx.spawn({ argv: answer.run })).pid;",
+  "      pid = (await ctx.spawn({ argv: answer.run, pgid: 0 })).pid;",
   "    } catch (err) {",
   '      const why = err && err.code === "ENOENT" ? "command not found" : String(err && err.code);',
   '      await say(2, "sudo: " + answer.run[0] + ": " + why + "\\n");',
   "      return failed();",
   "    }",
   "  } else pid = answer.pid;",
+  '  const stat = () => new TextDecoder().decode(ctx.sync.fs.readFile("/proc/" + ctx.pid + "/stat"));',
+  '  const mine = Number(stat().replace(/^.*\\) /, "").split(" ")[2]);',
+  "  const foreground = () => ctx.tty.foreground(0).catch(() => undefined);",
+  "  const owned = (await foreground()) === mine;",
+  "  const handOver = async () => {",
+  "    if ((await foreground()) === mine) await ctx.tty.setForeground(0, pid).catch(() => undefined);",
+  "  };",
+  "  const takeBack = async () => {",
+  "    if (owned && (await foreground()) === pid) await ctx.tty.setForeground(0, mine).catch(() => undefined);",
+  "  };",
+  "  if (owned) await handOver();",
   "  if (held !== undefined) await relay(held);",
-  "  return (await ctx.wait(pid)).status;",
+  "  for (;;) {",
+  "    const ended = await ctx.wait(pid, { untraced: true });",
+  "    if (!ended.stopped) {",
+  "      await takeBack();",
+  "      return ended.status;",
+  "    }",
+  "    const reading = ended.signal === 21 || ended.signal === 22;",
+  "    if (!(reading && (await foreground()) === mine)) {",
+  "      await takeBack();",
+  '      ctx.sync.kill(ctx.pid, ended.signal === 19 ? "SIGTSTP" : ended.signal);',
+  "    }",
+  "    await handOver();",
+  '    await ctx.kill(-pid, "SIGCONT").catch(() => undefined);',
+  "  }",
   "}",
   ""
 ].join("\n");
@@ -18273,6 +18839,7 @@ var WASM_MAGIC = [0, 97, 115, 109];
 var SHEBANG_MAX = 256;
 var MAX_INTERPRETERS = 4;
 var NOT_FOUND = 127;
+var NOT_EXECUTABLE = 126;
 var DECIDE_MS = 100;
 var INIT_PID = 1;
 var SHARED_DIRS = ["/tmp", "/home"];
@@ -18422,6 +18989,9 @@ function addTimes(into, pid, t) {
 var Launcher = class {
   fs;
   processFs;
+  noLinksFs;
+  mounted;
+  protection;
   prefixes;
   writerTags;
   unguardedRoot;
@@ -18477,6 +19047,9 @@ var Launcher = class {
   hostname;
   watchers = new FsWatchers();
   pnpmHome;
+  pnpmChain;
+  pnpmMade;
+  pnpmEpoch = 0;
   mounts;
   createDriverWorker;
   media;
@@ -18527,11 +19100,14 @@ var Launcher = class {
     this.mounts = new MountTable({
       open: (type, spec) => this.driver(type, spec),
       busy: (target) => [...this.openFiles].some((nodes) => nodes.holds(target)) || heldUnder(this.held, target),
-      changed: this.watchers.changed.bind(this.watchers),
+      changed: (...paths) => {
+        if (paths.some((path) => this.pnpmChain.has(path))) this.pnpmStale();
+        this.watchers.changed(...paths);
+      },
       owners: this.owners
     });
-    const watched = this.watchers.wrap(this.mounts.wrap(options.fs));
-    this.base = this.owners ? this.freshModules.wrap(watched) : watched;
+    this.mounted = this.mounts.wrap(options.fs);
+    this.base = this.rooted(this.mounted);
     this.createWorker = options.createWorker;
     this.createDriverWorker = options.createDriverWorker;
     this.media = options.media ?? memoryMedia();
@@ -18540,6 +19116,7 @@ var Launcher = class {
     this.fstabRetries = options.fstabRetries ?? FSTAB_RETRIES;
     this.processMounts = options.processMounts ?? true;
     this.pnpmHome = options.env?.PNPM_HOME ?? SYSTEM_PNPM_HOME;
+    this.pnpmChain = new Set(chain(normalizePath(this.pnpmHome)));
     this.modulesDir = options.modules ?? "/node_modules";
     this.appended = appendedRoots(options.commands);
     this.cdp = new CdpHosts(options.cdp);
@@ -18568,12 +19145,7 @@ var Launcher = class {
     });
     enableCdp(this.net, this.cdp);
     this.facades.enable(this.net);
-    const fs = withCommandDirs(
-      this.base,
-      async () => new Set((await this.commands()).keys()),
-      (dir) => this.userCommandDir(dir),
-      this.owners
-    );
+    const fs = this.commandFs(this.base);
     this.nodes = new VfsNodes(fs, (path) => this.released(path));
     this.nodes.keepsOnDisk = true;
     this.openFiles.add(this.nodes);
@@ -18589,15 +19161,23 @@ var Launcher = class {
         ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );
-    this.fs = this.unlinked.wrap(keepingOpen(fs, this.nodes));
+    this.fs = this.processChain(fs, this.nodes, this.unlinked);
     this.writerTags = writerTags(options.protect);
     this.unlinkOwnerOption = options.unlinkOwner;
     if (this.writerTags.size > 0 && options.fs.protect && !options.fs.unguarded) {
       throw new TypeError("protect.writers needs a root file system with an unguarded view");
     }
+    if (!options.fs.noLinks) throw new TypeError("the root file system needs a noLinks view");
     this.unguardedRoot = options.fs.unguarded?.() ?? options.fs;
     this.prefixes = protectedPrefixes(options.protect?.paths ?? []);
-    this.processFs = this.prefixes.length > 0 ? new ProtectedFs(this.prefixes).view(this.fs) : this.fs;
+    this.protection = this.prefixes.length > 0 ? new ProtectedFs(this.prefixes) : void 0;
+    this.processFs = this.protection?.view(this.fs) ?? this.fs;
+    const noLinks = this.processChain(
+      this.commandFs(this.rooted(this.noLinksOf(this.mounted))),
+      this.nodes,
+      this.unlinked
+    );
+    this.noLinksFs = this.protection?.view(noLinks) ?? noLinks;
     const integrity = options.protect?.integrity;
     integrityOptions(integrity);
     options.fs.protect?.(this.prefixes, Boolean(integrity));
@@ -19009,10 +19589,15 @@ var Launcher = class {
   }
   async unrunnable(file, cwd, scope) {
     const path = this.fs.resolvePath(cwd, file);
+    if (await this.directory(file, path)) return "EACCES";
     const head = await this.base.readFileBuffer(path).catch(() => null);
     if (!head || head[0] === 35 && head[1] === 33) return "ENOENT";
     return binfmtOf(await this.interpreters(scope), path) ? "ENOENT" : "ENOEXEC";
   }
+  async directory(file, path) {
+    if (!file.includes("/") || COMMAND2.test(file)) return false;
+    return (await this.base.stat(path).catch(() => void 0))?.isDirectory === true;
+  }
   verifiedFs(fs) {
     const read = (path) => this.verified(path, KERNEL_CALLER, fs);
     return Object.assign(Object.create(fs), {
@@ -19138,6 +19723,7 @@ var Launcher = class {
     delete env[TICKET_ENV];
     env.HOSTNAME = this.hostname;
     let program;
+    await this.pnpmReady();
     try {
       const caller = { pid: req.ppid ?? 0, uid: req.cred.euid, tag: req.tag };
       if (this.integrity) await this.checkedSources(planned, caller);
@@ -19152,10 +19738,29 @@ var Launcher = class {
     return this.jobs.sessionOf(pgid);
   }
   loopbackFor(pid) {
-    return new KernelLoopback(this.net, () => {
-      const cred = this.credOf(pid);
-      return { pid, uid: cred.euid, gid: cred.egid };
+    return new KernelLoopback(
+      this.net,
+      () => {
+        const cred = this.credOf(pid);
+        return { pid, uid: cred.euid, gid: cred.egid };
+      },
+      () => this.connectorStamp(pid)
+    );
+  }
+  sourceCheck(pid, writer) {
+    const { integrity } = this;
+    if (!integrity?.readsChecked || writer) return {};
+    const caller = () => ({
+      pid,
+      uid: this.credOf(pid).euid,
+      tag: this.tagOf(pid)
     });
+    return {
+      source: {
+        read: (path, plain) => integrity.readSource(path, caller(), plain),
+        open: (path, real) => integrity.openSource(path, caller(), real)
+      }
+    };
   }
   treeScrubs(req) {
     const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
@@ -19192,11 +19797,12 @@ var Launcher = class {
       },
       settling: () => this.settling.isSettling(pid),
       ...req.ignored ? { ignored: req.ignored } : {},
-      ...req.blocked ? { blocked: req.blocked } : {},
+      ...anyBlocked(req.blocked) ? { blocked: req.blocked } : {},
       ...req.umask !== void 0 ? { umask: req.umask } : {},
       cred: req.cred,
       ...this.owners && req.program.abi === "wasi" ? { fresh: (path, umask) => this.freshModules.add(path, umask, pid) } : {},
       ...this.owners ? { owners: true } : {},
+      ...this.sourceCheck(pid, stack.writer),
       ...linksOf2(req),
       sealed: this.sealed,
       ...scrubs ? { outputFilter: (file) => scrubbedAll(file, scrubs) } : {},
@@ -19209,6 +19815,7 @@ var Launcher = class {
       cwd: req.cwd,
       fds: req.fds,
       fs: stack.fs,
+      noLinks: stack.noLinks,
       ...this.prefixes.length > 0 && !stack.writer ? { readonlyAt: (path) => isProtected(this.prefixes, path) } : {},
       createWorker: this.createWorker,
       onError: req.report,
@@ -19286,6 +19893,11 @@ var Launcher = class {
     return { shownPid: this.jobs.shown(req.ppid), ...ppid !== void 0 ? { ppid } : {} };
   }
   forget(pid) {
+    const image = this.jobs.list().find((m) => m.pid === pid)?.execParent;
+    const described2 = this.described.get(pid);
+    if (image !== void 0 && described2 && this.described.has(image)) {
+      this.described.set(image, described2);
+    }
     this.jobs.remove(pid);
     this.described.delete(pid);
     const spent = this.spent.get(pid);
@@ -19401,10 +20013,11 @@ var Launcher = class {
       const root = member && rootOf(member).pid;
       return root !== void 0 && this.running(root) ? root : INIT_PID;
     };
+    const superseded = new Set([...members.values()].map((m) => m.execParent));
     const listed = [];
     for (const member of members.values()) {
       const described2 = this.described.get(member.pid);
-      if (member.execed || !described2) continue;
+      if (member.execed && superseded.has(member.pid) || !described2) continue;
       const cred = this.credOf(member.pid);
       if (!maySee(viewer, cred)) continue;
       const root = rootOf(member);
@@ -19589,7 +20202,7 @@ var Launcher = class {
   }
   signalMasksOf(pid) {
     const masks = this.processes.get(pid)?.signalMasks?.();
-    const blocked = this.blockedBy(pid);
+    const [blocked] = this.blockedBy(pid);
     const sigBlk = blocked ? { sigBlk: blocked } : {};
     return masks ? { sigIgn: masks.ignored, sigCgt: masks.caught, ...sigBlk } : sigBlk;
   }
@@ -19597,14 +20210,14 @@ var Launcher = class {
     return this.settling.isSettling(pid) || (this.ignoredBy(pid) & sigbit(SIG.TTOU)) !== 0;
   }
   blockedBy(pid) {
-    return this.processes.get(pid)?.blockedSignals?.() ?? 0;
+    return this.processes.get(pid)?.blockedSignals?.() ?? [0, 0];
   }
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }
   kill(pid, sig, sender, from) {
     const session = from === void 0 ? void 0 : this.jobs.sidOf(from);
-    const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target) || from !== void 0 && this.granted.get(this.jobs.shown(target)) === from;
+    const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target) || from !== void 0 && this.granted.get(this.jobs.shown(target)) === from || from !== void 0 && this.granted.get(this.jobs.pgidOf(target) ?? 0) === from;
     if (pid === -1) {
       const sender2 = from === void 0 ? void 0 : this.imageOf(from);
       return this.killAll(sig, (member) => this.imageOf(member) !== sender2, may);
@@ -19755,8 +20368,7 @@ var Launcher = class {
       this.fs
     );
     void this.unlinked.sweep(entry.target);
-    if (this.pnpmHome.startsWith(`${entry.target.replace(/\/$/, "")}/`))
-      await this.provisionPnpmHome();
+    this.pnpmStale();
     return entry;
   }
   async ownTmp() {
@@ -19804,8 +20416,18 @@ var Launcher = class {
     if (path === "/") return path;
     return joinName(await realDir(this.base, parentOf(path)), baseName(path));
   }
-  async provisionPnpmHome() {
-    await this.base.mkdir(this.pnpmHome, { recursive: true }).catch(() => void 0);
+  pnpmReady() {
+    if (this.pnpmMade !== void 0) return this.pnpmMade;
+    const epoch = this.pnpmEpoch;
+    const made2 = this.base.mkdir(this.pnpmHome, { recursive: true }).then(() => this.owners ? this.stampLayout() : void 0).catch(() => {
+      if (this.pnpmEpoch === epoch) this.pnpmMade = void 0;
+    });
+    this.pnpmMade = made2;
+    return made2;
+  }
+  pnpmStale() {
+    this.pnpmEpoch++;
+    this.pnpmMade = void 0;
   }
   mountedBy(spec, cred) {
     if (!this.owners || cred.euid === 0 && cred.egid === 0) return spec;
@@ -19839,6 +20461,7 @@ var Launcher = class {
   umount(target, detach = false) {
     const at = normalizePath(target);
     this.mounts.umount(at, detach);
+    this.pnpmStale();
     if (!detach) return;
     for (const nodes of this.openFiles) nodes.revoke(at);
     for (const holds of this.held) holds.revoke(at);
@@ -19904,7 +20527,7 @@ var Launcher = class {
     await this.resolvePrefixes();
     for (const dir of SHARED_DIRS) await this.base.mkdir(dir, { recursive: true });
     if (this.owners) await this.ownTmp();
-    await this.provisionPnpmHome();
+    await this.pnpmReady();
     await this.users.ensure();
     if (this.owners) await this.stampLayout();
     if (this.owners) await this.sudoer.provision();
@@ -19967,19 +20590,20 @@ var Launcher = class {
   }
   stackFor(tag) {
     if (!this.isWriter(tag)) {
-      return { fs: this.processFs, nodes: this.nodes, unlinked: this.unlinked, writer: false };
+      return {
+        fs: this.processFs,
+        noLinks: this.noLinksFs,
+        nodes: this.nodes,
+        unlinked: this.unlinked,
+        writer: false
+      };
     }
     this.writers ??= this.writerStack();
     return this.writers;
   }
   writerStack() {
-    const watched = this.watchers.wrap(this.mounts.wrap(this.unguardedRoot));
-    const fs = withCommandDirs(
-      this.owners ? this.freshModules.wrap(watched) : watched,
-      async () => new Set((await this.commands()).keys()),
-      (dir) => this.userCommandDir(dir),
-      this.owners
-    );
+    const mounted = this.mounts.wrap(this.unguardedRoot);
+    const fs = this.commandFs(this.rooted(mounted));
     const nodes = new VfsNodes(fs, (path) => this.released(path), this.nodes.entries);
     nodes.keepsOnDisk = true;
     this.openFiles.add(nodes);
@@ -19994,7 +20618,32 @@ var Launcher = class {
         ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );
-    return { fs: unlinked.wrap(keepingOpen(fs, nodes)), nodes, unlinked, writer: true };
+    const noLinks = this.commandFs(this.rooted(this.noLinksOf(mounted)));
+    return {
+      fs: this.processChain(fs, nodes, unlinked),
+      noLinks: this.processChain(noLinks, nodes, unlinked),
+      nodes,
+      unlinked,
+      writer: true
+    };
+  }
+  noLinksOf(mounted) {
+    return mounted.noLinks.call(mounted);
+  }
+  rooted(mounted) {
+    const watched = this.watchers.wrap(mounted);
+    return this.owners ? this.freshModules.wrap(watched) : watched;
+  }
+  commandFs(root) {
+    return withCommandDirs(
+      root,
+      async () => new Set((await this.commands()).keys()),
+      (dir) => this.userCommandDir(dir),
+      this.owners
+    );
+  }
+  processChain(fs, nodes, unlinked) {
+    return unlinked.wrap(keepingOpen(fs, nodes));
   }
   async starting(argv, dir, account, tag) {
     this.resetCatalogs();
@@ -20076,8 +20725,10 @@ var Launcher = class {
     const report = (message3) => stderr(encoder7.encode(`${message3}
 `));
     if (!planned) {
-      report(`${file}: command not found`);
-      return { status: NOT_FOUND, stdout: concat6(out), stderr: concat6(err) };
+      const directory = await this.directory(file, this.fs.resolvePath(cwd, file));
+      report(`${file}: ${directory ? "Is a directory" : "command not found"}`);
+      const status2 = directory ? NOT_EXECUTABLE : NOT_FOUND;
+      return { status: status2, stdout: concat6(out), stderr: concat6(err) };
     }
     const fds = new FdTable();
     fds.installAt(0, options.stdin ? bytesSource(options.stdin) : deviceFile("null"));
@@ -20100,6 +20751,8 @@ var Launcher = class {
 };
 
 // src/node/loopback.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { subscribe } from "node:diagnostics_channel";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 var DEVTOOLS_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
@@ -20159,6 +20812,11 @@ function refusal(url, address, place) {
   const why = place === "link-local" ? `nodeTransport refuses link-local ${where}` : `nodeTransport refuses the host's loopback ${where} (see nodeTransport({ hostLoopback }))`;
   return Object.assign(new Error(why), { status: 403, code: "EACCES" });
 }
+function connectRefusal(address, port, place) {
+  const where = `${address}:${port}`;
+  const why = place === "link-local" ? `nodeTransport refuses link-local ${where}` : `nodeTransport refuses the host's loopback ${where} (see nodeTransport({ hostLoopback }))`;
+  return Object.assign(new Error(why), { status: 403, code: "EACCES" });
+}
 async function addressesOf(host, resolve2) {
   const plain = host.replace(/^\[(.*)\]$/, "$1");
   if (isIP(plain)) return [plain];
@@ -20185,7 +20843,66 @@ function guarded2(check, signal) {
   });
   return Promise.race([check, aborted2]).finally(() => signal.removeEventListener("abort", stop));
 }
+var loopbackStore = new AsyncLocalStorage();
+var subscribed = false;
+function envProxyEnabled() {
+  if (process.env.NODE_USE_ENV_PROXY === "1") return true;
+  const opts = process.env.NODE_OPTIONS ?? "";
+  const args = process.execArgv ?? [];
+  return args.includes("--use-env-proxy") || opts.includes("--use-env-proxy");
+}
+function normaliseProxyUrl(url) {
+  try {
+    const parsed2 = new URL(url);
+    const host = parsed2.hostname.replace(/^\[(.*)\]$/, "$1");
+    const port = parsed2.port || (parsed2.protocol === "https:" ? "443" : "80");
+    return `${host}:${port}`;
+  } catch {
+    return void 0;
+  }
+}
+function proxyAddresses() {
+  if (!envProxyEnabled()) return /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Set();
+  for (const key of ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"]) {
+    const val = process.env[key];
+    if (val) {
+      const addr = normaliseProxyUrl(val);
+      if (addr) out.add(addr);
+    }
+  }
+  return out;
+}
+function ensureSubscribed() {
+  if (subscribed) return;
+  subscribed = true;
+  subscribe("undici:client:connected", (message3) => {
+    const entry = loopbackStore.getStore();
+    if (!entry) return;
+    const { socket, connectParams } = message3;
+    const address = socket.remoteAddress;
+    if (!address) {
+      const err2 = connectRefusal("unknown", 0, "loopback");
+      entry.refused = err2;
+      socket.destroy(err2);
+      return;
+    }
+    const proxies = proxyAddresses();
+    if (proxies.size > 0 && connectParams.hostname) {
+      const cpPort = connectParams.port || (connectParams.protocol === "https:" ? "443" : "80");
+      if (proxies.has(`${connectParams.hostname}:${cpPort}`)) return;
+    }
+    const place = placeOf(address);
+    if (!place) return;
+    const port = socket.remotePort ?? 0;
+    if (place === "loopback" && allows(entry.policy, port)) return;
+    const err = connectRefusal(address, port, place);
+    entry.refused = err;
+    socket.destroy(err);
+  });
+}
 function guardedLoopback(transport, policy, resolve2) {
+  ensureSubscribed();
   const open = transport.websocket?.bind(transport);
   return {
     get traits() {
@@ -20193,12 +20910,22 @@ function guardedLoopback(transport, policy, resolve2) {
     },
     fetch: async (request, owner) => {
       await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
-      return transport.fetch(request, owner);
+      const entry = { policy };
+      try {
+        return await loopbackStore.run(entry, () => transport.fetch(request, owner));
+      } catch (err) {
+        throw entry.refused ?? err;
+      }
     },
     ...open ? {
       websocket: async (request) => {
         await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
-        return open(request);
+        const entry = { policy };
+        try {
+          return await loopbackStore.run(entry, () => open(request));
+        } catch (err) {
+          throw entry.refused ?? err;
+        }
       }
     } : {}
   };
@@ -20250,8 +20977,8 @@ var Chunks = class {
       const index = Math.floor((at + done4) / CHUNK4);
       const from = at + done4 - index * CHUNK4;
       const n = Math.min(CHUNK4 - from, bytes.length - done4);
-      const view = bytes.subarray(done4, done4 + n);
-      const part = view.buffer instanceof ArrayBuffer ? view : view.slice();
+      const view2 = bytes.subarray(done4, done4 + n);
+      const part = view2.buffer instanceof ArrayBuffer ? view2 : view2.slice();
       const old = this.blobs[index];
       if (from === 0 && n >= (old?.size ?? 0)) this.blobs[index] = new Blob([part]);
       else {