@ai-ecoverse/slicc-kernel 1.140.0 → 1.140.2

package/README.md

@@ -330,7 +330,7 @@ On top of preview1 a WASI program gets:
   A kernel without the imports answers `ENOSYS`, and the libc reports `SI_USER` with pid and uid 0, as before. **SIGCHLD:** with `SIGCHLD` set to `SIG_IGN` (by the program, or inherited), or with `SA_NOCLDWAIT` in the flags `slicc.sigaction_set` gets for `SIGCHLD`, an exited child is reaped at once and never stays a zombie: `waitpid` for it is `ECHILD`, and `wait` blocks until every child has exited, then fails with `ECHILD`, as on Linux. `SIGCHLD` is still sent. An explicit `SIG_DFL` turns it back off. A child that a process waits on for `exec`, or that `kernel.run` and the run calls collect, is never reaped that way.
 - **Pipes** have no file type for WASI and WASIX programs' `fstat` (`st_mode` type 0), because WASI has no FIFO file type. A socket type, as kernels 1.47.3 to 1.48.1 gave them, made Ruby treat a `popen` pipe as a socket (`close_write` then never ends the child's input). The kernel's `slicc_fs.fd_mode` answers `S_IFIFO | 0600` (Linux numbering) for a pipe, and wasix-sysroot 2025.9.30-21 and later take the type from it, so programs built on it see a FIFO (`S_ISFIFO`); older libcs keep only the permission bits. Until then Python's asyncio refuses a pipe for a subprocess (`Pipe transport is only for pipes, sockets and character devices`). They are read and written as pipes; socket calls on them fail with `ENOTSOCK`, and `isatty()` is false. Emscripten programs, bash included, see a FIFO. The same holds for any kernel descriptor that is neither seekable nor a terminal or device, such as captured output.
 - **Sockets**: the WASIX socket calls (`sock_open`, `sock_pair` for an `AF_UNIX` stream or datagram pair, `bind`, `listen`, `connect`, `accept`, options, local and peer names) are the kernel's loopback sockets, and preview1's `sock_recv` / `sock_send` / `sock_shutdown` work on them and on inherited ones. Writing to a socket whose peer is gone fails with `EPIPE`, through `fd_write` as through `sock_send`, as if `MSG_NOSIGNAL` were set. A write to a pipe, FIFO or terminal whose reader is gone follows the program's `SIGPIPE` disposition, as the kernel knows it (#810): at the default it ends the program with status 141; ignored (also an ignore inherited across `exec` and spawn, as bash's `trap '' PIPE` passes on), the write fails with `EPIPE`; with a handler, the handler runs on the thread that wrote and then the write fails with `EPIPE` (#820); blocked, `SIGPIPE` stays pending and the write fails with `EPIPE`. An Emscripten program's write to a pipe, and its `send` without `MSG_NOSIGNAL`, follow the same rules, except that the kernel doesn't see an Emscripten program's signal mask, so a blocked `SIGPIPE` there still ends it. A WASIX program's libc reads an inherited ignore back through `slicc.sigaction_inherited` (wasix-sysroot -32 and later; see below). An Emscripten program's shim reads it from `Module.sliccKernel.sigInherited()` (#965, homescoop#973). That's a mask with bit n set for signal n (not bit n-1, as the WASIX import has it) holding only inherited `SIG_IGN`s, never `SIGKILL` or `SIGSTOP`. The shim seeds its `sigaction` table from it in a constructor that runs before any user constructor. The kernel puts the function on `Module.sliccKernel` before the glue runs constructors, ahead of the rest of `sliccKernel`. On a kernel without the function it is undefined, and the shim keeps the defaults. HTTP and HTTPS leave through the realm proxy that `https_proxy` names, as for any other program; `resolve` answers `/etc/hosts` names and literal addresses, and the [uplink](#uplink)'s names. `sock_open(SOCK_DGRAM)` on `AF_INET`/`AF_INET6` gives a [datagram socket](#datagram-sockets-udp); `sock_send_to` and `sock_recv_from` carry its addresses, and `RECV_DATA_TRUNCATED` is set in `ro_flags` when a datagram did not fit.
-- **Diagnostics**: a trap ends the program with 134 and its message on stderr; a program that crashes its worker otherwise (a JS stack overflow, `RangeError: Maximum call stack size exceeded`, or any other uncaught error) ends with 70, and its message goes to the process's own fd 2 too, so `2>` catches it (#1237), or to the session's stderr when it has no fd 2 to write; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
+- **Diagnostics**: a trap ends the program with 134 and its message on stderr; a program that crashes its worker otherwise (a JS stack overflow, `RangeError: Maximum call stack size exceeded`, or any other uncaught error) ends with 70, and its message goes to the process's own fd 2 too, so `2>` catches it (#1237), or to the session's stderr when it has no fd 2 to write; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). A sidecar that doesn't fit the module, naming another number of functions than the module has (imported and defined), gets one warning line before the trap message, and the frames keep their raw indices instead of wrong names (#1239). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
 
 ### Program imports
 
@@ -1121,7 +1121,7 @@ A character device (`0666`), there in every `users` mode, through which programs
 
 ### `/proc`
 
-Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `exe`, a link to the file the process was started from: the glue or `.wasm` that ran, as resolved (a copy run by its own path names the copy, a symlink its target) (#1264). As on Linux without ptrace access, reading another process's `exe` link is `EACCES` unless the reader is root or its uid and gid match all of the target's real, effective and saved ids; `cmdline` and `status` stay readable, and `/proc/self` is a link to the `/proc/<pid>` of the process that reads it, as on Linux (`readlink /proc/self` is its pid, the one it was exec'd under included). They come from the kernel's process table when they are opened, so a terminal sees the processes of every client. A process that exits while a program reads the `/proc` directory doesn't fail or cut short the listing: its pid is still listed, and opening its files fails with `ENOENT`, which `ps`, `pgrep` and `pidof` skip, as on Linux; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. `/proc/version` names the kernel, Linux-shaped, with the slicc-kernel version that built it: `Linux version 6.0.0-slicc (slicc-kernel <version>) #1 SMP PREEMPT_DYNAMIC`. `/proc/sys/kernel/osrelease` is `6.0.0-slicc` and `/proc/sys/kernel/ostype` is `Linux`. The version is the one npm publishes, set when the package is built (`0.0.0-dev` when run from the sources). A JS program reads it as `ctx.kernel.version`. A process with no parent in the kernel (one a page, a client or the Node entry started) has parent 1, as children of init do, in `getppid()`, `/proc/<pid>/stat` and `ps` alike, and so does a process whose parent has ended, waited for or not (`getppid()` asks the kernel each time; a shell's `$PPID` keeps the value it started with, as on Linux). Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so are the credentials in `status` (`Uid:`, `Gid:`, `Groups:`; a process with a tag, see `kernel.run`, also has `Tag:\t<tag>` after `Gid:`, shown to root and to the same uid only, with newlines, tabs and carriage returns written `\n`, `\t` and `\r`) and each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times are measured per process, its threads and the images it exec'd included: time a worker spends waiting for the kernel's answer is system time (at most 20 ms of each call; the rest of a longer one, such as a write into a full pipe, counts as blocked), time it spends blocked (a read, a `poll` or `select` that waits, a sleep, `wait`, a futex, while stopped) is neither, from the moment the call actually starts to wait (a call that could wait but answers at once, such as a `select` with a zero timeout or a ready descriptor, a `waitpid` with `WNOHANG`, or a futex wait whose value has already changed, is system time), and the rest is user time; a process's times stop when it ends, a call still in flight then adds nothing, so a loop that never calls the kernel shows as user time while it runs; they show in `/proc/<pid>/stat`, `ps` and `ps()`, and the times of the children a process has waited for (theirs and their own waited-for children's, as POSIX counts them) show as its `cutime` and `cstime` in `/proc/<pid>/stat`; a stopped process is `T` there, in `/proc/<pid>/status` (`T (stopped)`) and in `ps()`; a WASI or WASIX program's `CLOCK_PROCESS_CPUTIME_ID` and `CLOCK_THREAD_CPUTIME_ID` (`clock_time_get`) count only the time its thread runs, its own waits and blocked kernel calls left out (a sleep is not CPU time), per thread for now, so a threaded program's process clock is its calling thread's; and `/proc/stat` counts every process of the kernel, the reaped ones included, and `/proc/loadavg` averages the processes not blocked, sampled every 5 seconds. A JS program's time isn't measured yet. `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) is a placeholder. A process that isn't root sees only its own user's processes (see [Users](#users)). WASI and WASIX programs see the same `/proc`, read-only (opening a file in it for writing, or linking one of its files elsewhere, fails with `EROFS`), from every thread, also through a symlink that points into it (where every change, `mkdir`, `rename`, `unlink`, `chmod`, a hard link from it or into it, and so on, fails too: with `EROFS` when the root file system has a physical `/proc`, which stays hidden and untouched, and otherwise with the `ENOENT` of the missing directory, since that check is only paid for when a physical `/proc` exists; with one, a symlink whose target passes `..` after a file or a missing name, such as `/f/../proc`, fails with `ENOTDIR` or `ENOENT`, as on Linux), and `/` lists it, so a WASI program gets a preopen for it; `/proc/self` is the program's own pid there too (the pid an exec'd program took over). WASI and WASIX programs also have `/proc/<pid>/task/<tid>/stat` for each of a process's threads (the main thread is tid 1), whose state is `S` while the thread is blocked in the kernel (a `sem_wait`, a blocking read, a sleep, a futex) and `R` otherwise (`T` and `Z` as for the process). JS programs read the same `/proc` through `ctx.fs` and `ctx.open` (see [JS programs](#js-programs)). Neither has `/proc/<pid>/fd` yet.
+Every process of the kernel has `/proc/<pid>/` with `cmdline`, `comm`, `stat`, `statm` and `status`, in the formats procps reads, and `exe`, a link to the file the process was started from: the glue or `.wasm` that ran, as resolved (a copy run by its own path names the copy, a symlink its target) (#1264). For WASI and WASIX programs, as for Emscripten ones, `stat`, `open` and reading `/proc/self/exe` act on the program file, while `lstat` and `readlink` show the link (#1273). As on Linux without ptrace access, reading another process's `exe` link is `EACCES` unless the reader is root or its uid and gid match all of the target's real, effective and saved ids; `cmdline` and `status` stay readable, and `/proc/self` is a link to the `/proc/<pid>` of the process that reads it, as on Linux (`readlink /proc/self` is its pid, the one it was exec'd under included). They come from the kernel's process table when they are opened, so a terminal sees the processes of every client. A process that exits while a program reads the `/proc` directory doesn't fail or cut short the listing: its pid is still listed, and opening its files fails with `ENOENT`, which `ps`, `pgrep` and `pidof` skip, as on Linux; an exec'd program shows under the pid its parent knows. `/proc/uptime`, `/proc/loadavg`, `/proc/stat` and `/proc/meminfo` are there too, and `/proc/mounts`. `/proc/version` names the kernel, Linux-shaped, with the slicc-kernel version that built it: `Linux version 6.0.0-slicc (slicc-kernel <version>) #1 SMP PREEMPT_DYNAMIC`. `/proc/sys/kernel/osrelease` is `6.0.0-slicc` and `/proc/sys/kernel/ostype` is `Linux`. The version is the one npm publishes, set when the package is built (`0.0.0-dev` when run from the sources). A JS program reads it as `ctx.kernel.version`. A process with no parent in the kernel (one a page, a client or the Node entry started) has parent 1, as children of init do, in `getppid()`, `/proc/<pid>/stat` and `ps` alike, and so does a process whose parent has ended, waited for or not (`getppid()` asks the kernel each time; a shell's `$PPID` keeps the value it started with, as on Linux). Pids, parents, process groups, sessions, command lines, terminals, start and boot times are real, and so are the credentials in `status` (`Uid:`, `Gid:`, `Groups:`; a process with a tag, see `kernel.run`, also has `Tag:\t<tag>` after `Gid:`, shown to root and to the same uid only, with newlines, tabs and carriage returns written `\n`, `\t` and `\r`) and each process's memory: the size of its wasm memory (`VSZ` and `RSS` alike, as wasm has no paging), which `/proc/meminfo` counts as used. CPU times are measured per process, its threads and the images it exec'd included: time a worker spends waiting for the kernel's answer is system time (at most 20 ms of each call; the rest of a longer one, such as a write into a full pipe, counts as blocked), time it spends blocked (a read, a `poll` or `select` that waits, a sleep, `wait`, a futex, while stopped) is neither, from the moment the call actually starts to wait (a call that could wait but answers at once, such as a `select` with a zero timeout or a ready descriptor, a `waitpid` with `WNOHANG`, or a futex wait whose value has already changed, is system time), and the rest is user time; a process's times stop when it ends, a call still in flight then adds nothing, so a loop that never calls the kernel shows as user time while it runs; they show in `/proc/<pid>/stat`, `ps` and `ps()`, and the times of the children a process has waited for (theirs and their own waited-for children's, as POSIX counts them) show as its `cutime` and `cstime` in `/proc/<pid>/stat`; a stopped process is `T` there, in `/proc/<pid>/status` (`T (stopped)`) and in `ps()`; a WASI or WASIX program's `CLOCK_PROCESS_CPUTIME_ID` and `CLOCK_THREAD_CPUTIME_ID` (`clock_time_get`) count only the time its thread runs, its own waits and blocked kernel calls left out (a sleep is not CPU time), per thread for now, so a threaded program's process clock is its calling thread's; and `/proc/stat` counts every process of the kernel, the reaped ones included, and `/proc/loadavg` averages the processes not blocked, sampled every 5 seconds. A JS program's time isn't measured yet. `MemTotal` (from `navigator.deviceMemory`, else 4 GiB) is a placeholder. A process that isn't root sees only its own user's processes (see [Users](#users)). WASI and WASIX programs see the same `/proc`, read-only (opening a file in it for writing, or linking one of its files elsewhere, fails with `EROFS`), from every thread, also through a symlink that points into it (where every change, `mkdir`, `rename`, `unlink`, `chmod`, a hard link from it or into it, and so on, fails too: with `EROFS` when the root file system has a physical `/proc`, which stays hidden and untouched, and otherwise with the `ENOENT` of the missing directory, since that check is only paid for when a physical `/proc` exists; with one, a symlink whose target passes `..` after a file or a missing name, such as `/f/../proc`, fails with `ENOTDIR` or `ENOENT`, as on Linux), and `/` lists it, so a WASI program gets a preopen for it; `/proc/self` is the program's own pid there too (the pid an exec'd program took over). WASI and WASIX programs also have `/proc/<pid>/task/<tid>/stat` for each of a process's threads (the main thread is tid 1), whose state is `S` while the thread is blocked in the kernel (a `sem_wait`, a blocking read, a sleep, a futex) and `R` otherwise (`T` and `Z` as for the process). JS programs read the same `/proc` through `ctx.fs` and `ctx.open` (see [JS programs](#js-programs)). Neither has `/proc/<pid>/fd` yet.
 
 The kernel writes `/etc/passwd` and `/etc/group` when it starts (see [Users](#users)). While the root has none of them, or no `/etc/mtab`, reading them gets per-process ones: root is uid 0 and the realm user, uid 1000, is named after `USER`, or `web_user` (Emscripten's default) without one, so it matches `$USER`, with `HOME` as its home, so `id`, `whoami`, `ls -l` and `ps` show names. Nothing is written to OPFS, and a real file there wins.
 

package/dist/kernel-worker.js

@@ -118,8 +118,9 @@ var MemoryMeta = class {
     this.entries.set(to, moved(root(carried.find((entry) => entry.path === from)), to));
     if (left) this.entries.set(from, left);
   }
-  async remove(paths) {
+  async remove(paths, left) {
     for (const path of paths) this.entries.deleteTree(path);
+    if (left) this.entries.set(left.path, left);
   }
   absent(path) {
     return !this.entries.has(path);
@@ -265,9 +266,9 @@ var IndexedDbMeta = class {
   }
   removing = /* @__PURE__ */ new Map();
   removeTimer;
-  async remove(paths) {
+  async remove(paths, left) {
     this.settleRemoves();
-    return this.removeNow(paths);
+    return this.removeNow(paths, left);
   }
   async removeFile(path) {
     const known = this.cache.get(path);
@@ -281,14 +282,16 @@ var IndexedDbMeta = class {
       REMOVE_WAIT_MS
     );
   }
-  async removeNow(paths) {
+  async removeNow(paths, left) {
     const [transaction, store] = this.transaction("readwrite");
     for (const path of paths) {
       store.delete(path);
       store.delete(descendants(path));
     }
+    if (left) store.put(left);
     await settle(transaction, () => void 0);
     this.changed({ trees: paths });
+    if (left) this.cache.set(left.path, left);
   }
   settleRemoves() {
     if (this.removing.size > 0) void this.flushRemoves().catch(() => void 0);
@@ -2316,10 +2319,10 @@ var OpfsFs = class {
         return;
       }
     }
-    await this.meta.remove([found.path]);
-    if (found.handle?.kind === "directory") {
-      await this.meta.update(found.path, (entry) => entry ?? vacatedAt(found.path));
-    }
+    await this.meta.remove(
+      [found.path],
+      found.handle?.kind === "directory" ? vacatedAt(found.path) : void 0
+    );
     this.touch(Date.now(), parentOf3(found.path));
   }
   links() {
@@ -7125,7 +7128,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.140.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.140.2" : "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
@@ -9808,6 +9811,9 @@ function devCreation(path, cred) {
 // src/fs/etc-files.ts
 var HOSTNAME_PATH = "/etc/hostname";
 var S_IFREG3 = 32768;
+var MAX_HOPS2 = 40;
+var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var baseOf2 = (path) => path.slice(path.lastIndexOf("/") + 1);
 function missing4(err) {
   return err?.code === "ENOENT";
 }
@@ -9828,21 +9834,53 @@ function statOf(path, bytes) {
     gid: 0
   };
 }
+function linkFollower(fs, files) {
+  const bases = new Set([...files.keys()].map(baseOf2));
+  const linkOf2 = (path) => fs.readlink(path).then(
+    (link2) => link2,
+    () => void 0
+  );
+  const viaParent = async (path) => {
+    if (!bases.has(baseOf2(path)) || !fs.realpath) return path;
+    const parent = parentOf6(path);
+    const dir = await fs.realpath(parent, true).catch(() => parent);
+    return fs.resolvePath(dir, baseOf2(path));
+  };
+  return async (path) => {
+    let current = path;
+    for (let hop = 0; hop < MAX_HOPS2 && !files.has(current); hop++) {
+      const link2 = await linkOf2(current);
+      if (link2 === void 0) return viaParent(current);
+      current = fs.resolvePath(parentOf6(current), link2);
+    }
+    return current;
+  };
+}
+function materializer(fs, listedAbsent) {
+  return async (path) => {
+    const bytes = await listedAbsent(path);
+    if (bytes !== void 0) await fs.writeFile(path, bytes);
+  };
+}
 function withEtcFiles(fs, files) {
   const bytesOf2 = (path) => {
     const text = files.get(path)?.();
     return text === void 0 ? void 0 : new TextEncoder().encode(text);
   };
   const absent2 = (path) => fs.lstat(path).then(() => false, missing4);
+  const follow2 = linkFollower(fs, files);
+  const listedAbsent = async (path) => files.has(path) && await absent2(path) ? bytesOf2(path) : void 0;
   const fallback = (path, make) => async (err) => {
-    const bytes = missing4(err) && files.has(path) && await absent2(path) ? bytesOf2(path) : void 0;
-    if (bytes === void 0) throw err;
-    return make(bytes);
+    const at = missing4(err) ? await follow2(path) : void 0;
+    const bytes = at === void 0 ? void 0 : await listedAbsent(at);
+    if (bytes === void 0 || at === void 0) throw err;
+    return make(bytes, at);
   };
   const ranged2 = rangedOps(fs);
+  const materialize = materializer(fs, listedAbsent);
   const own = {
-    stat: (path) => fs.stat(path).catch(fallback(path, (b) => statOf(path, b))),
-    lstat: (path) => fs.lstat(path).catch(fallback(path, (b) => statOf(path, b))),
+    stat: (path) => fs.stat(path).catch(fallback(path, (b, at) => statOf(at, b))),
+    lstat: (path) => fs.lstat(path).catch(fallback(path, (b, at) => statOf(at, b))),
     exists: async (path) => await fs.exists(path) || files.has(path) && await absent2(path),
     ...fs.createExclusive ? {
       createExclusive: async (path, owner) => {
@@ -9855,9 +9893,23 @@ function withEtcFiles(fs, files) {
       }
     } : {},
     readFile: (path) => fs.readFile(path).catch(fallback(path, (b) => new TextDecoder().decode(b))),
+    ...fs.append ? {
+      append: async (path, bytes) => {
+        if (files.has(path)) await materialize(path);
+        return fs.append.call(fs, path, bytes);
+      }
+    } : {},
     readFileBuffer: (path) => fs.readFileBuffer(path).catch(fallback(path, (b) => b)),
     ...ranged2 ? {
-      pread: (path, offset, length2, version) => ranged2.pread(path, offset, length2, version).catch(fallback(path, (b) => b.slice(offset, offset + length2)))
+      pread: (path, offset, length2, version) => ranged2.pread(path, offset, length2, version).catch(fallback(path, (b) => b.slice(offset, offset + length2))),
+      pwrite: async (path, offset, bytes, transfer) => {
+        if (files.has(path)) await materialize(path);
+        return ranged2.pwrite(path, offset, bytes, transfer);
+      },
+      truncate: async (path, size) => {
+        if (files.has(path)) await materialize(path);
+        return ranged2.truncate(path, size);
+      }
     } : {}
   };
   return new Proxy(fs, {
@@ -9990,7 +10042,7 @@ var FreshModules = class {
 };
 
 // src/fs/physical-path.ts
-var MAX_HOPS2 = 40;
+var MAX_HOPS3 = 40;
 function start(path) {
   return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
 }
@@ -10015,7 +10067,7 @@ function rest(walk2, part) {
   return lexical(`/${[...walk2.done, part, ...walk2.todo].join("/")}`);
 }
 function follow(walk2, target) {
-  if (++walk2.hops > MAX_HOPS2) return false;
+  if (++walk2.hops > MAX_HOPS3) return false;
   if (target.startsWith("/")) walk2.done.length = 0;
   walk2.todo = [...target.split("/").filter((p) => p !== ""), ...walk2.todo];
   return true;
@@ -10038,13 +10090,13 @@ async function physicalPathAsync(fs, path) {
 
 // src/fs/watch.ts
 var WATCH_NOTES_LIMIT = 1e3;
-var baseOf2 = (path) => path.slice(path.lastIndexOf("/") + 1);
+var baseOf3 = (path) => path.slice(path.lastIndexOf("/") + 1);
 var WATCH_BATCH_LIMIT = 1e3;
 var under3 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
-var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf7 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 function touches(watcher, changed) {
   return watcher.paths.some(
-    (watched) => changed === watched || under3(watched, changed) || (watcher.recursive ? under3(changed, watched) : parentOf6(changed) === watched)
+    (watched) => changed === watched || under3(watched, changed) || (watcher.recursive ? under3(changed, watched) : parentOf7(changed) === watched)
   );
 }
 var REALS_KEPT = 4096;
@@ -10068,11 +10120,11 @@ function route(watch, type, path) {
 }
 function routed(watch, root, type, path) {
   if (path === root || type === "rename" && root !== "/" && under3(root, path)) {
-    noted(watch, { type, filename: baseOf2(root) });
+    noted(watch, { type, filename: baseOf3(root) });
     if (type === "rename") noted(watch, { ended: true });
     return true;
   }
-  if (parentOf6(path) === root) noted(watch, { type, filename: baseOf2(path) });
+  if (parentOf7(path) === root) noted(watch, { type, filename: baseOf3(path) });
   else if (watch.recursive && under3(path, root)) {
     noted(watch, { type, filename: path.slice(root === "/" ? 1 : root.length + 1) });
   } else return false;
@@ -10148,7 +10200,7 @@ var FsWatchers = class {
   covers(path) {
     for (const watch of this.typed) {
       for (const root of watch.roots) {
-        if (path === root || parentOf6(path) === root || watch.recursive && under3(path, root))
+        if (path === root || parentOf7(path) === root || watch.recursive && under3(path, root))
           return true;
       }
     }
@@ -11317,7 +11369,7 @@ var HeldPaths = class extends Map {
     return this.revoked.has(path);
   }
 };
-var parentOf7 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf8 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var readonly = (mount) => mount.caps.readonly === true || mount.options.ro !== void 0;
 function inodeless(mount, attr2) {
   if (attr2.ino !== void 0) return false;
@@ -11617,7 +11669,7 @@ var MountTable = class {
     for (const [key, cached] of [...mount.attrs])
       if (within6(key, path) || linked2(cached.value)) mount.attrs.delete(key);
     mount.lists.delete(path);
-    mount.lists.delete(parentOf7(path));
+    mount.lists.delete(parentOf8(path));
     for (const [key, cached] of [...mount.lists])
       if (within6(key, path) || cached.value.some((e) => linked2(e.attr))) mount.lists.delete(key);
   }
@@ -11737,7 +11789,7 @@ var MountFs = class _MountFs {
     const real = normalizePath(path);
     if (this.at(real)) return real;
     try {
-      await this.base.stat(parentOf7(real));
+      await this.base.stat(parentOf8(real));
       return real;
     } catch (err) {
       const moved2 = redirectOf(err);
@@ -11779,7 +11831,7 @@ var MountFs = class _MountFs {
     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);
+    return this.follow(this.base.resolvePath(parentOf8(real), target), hops + 1, create);
   }
   async open(mount, rel2, write, owner) {
     return await mount.conn.call({
@@ -11795,8 +11847,8 @@ var MountFs = class _MountFs {
   async driverOwner(found, real, owner, directory) {
     const { mount, rel: rel2 } = found;
     if (!owner || !mount.owners || !mount.caps.owners) return void 0;
-    const dir = parentOf7(real);
-    const above = statOf2(await this.table.getattr(mount, dir, parentOf7(rel2)), dir, mount);
+    const dir = parentOf8(real);
+    const above = statOf2(await this.table.getattr(mount, dir, parentOf8(rel2)), dir, mount);
     const setgid = (above.mode & S_ISGID4) !== 0;
     let mode = owner.mode;
     if (directory && setgid) mode = (mode ?? 493) | S_ISGID4;
@@ -12302,7 +12354,7 @@ var MountFs = class _MountFs {
   }
   async named(path) {
     const at = normalizePath(path);
-    return joinName(await realDir(this, parentOf7(at)), at.slice(at.lastIndexOf("/") + 1));
+    return joinName(await realDir(this, parentOf8(at)), at.slice(at.lastIndexOf("/") + 1));
   }
   async link(source, target, follow2 = false) {
     const from = follow2 ? await realTarget(this, normalizePath(source)) : await this.named(source);
@@ -14188,6 +14240,12 @@ var ProcTree = class {
     if (node.kind !== "dir") throw syncError("ENOTDIR", path);
     return node.names();
   }
+  escape(path) {
+    const node = this.node(this.parts(path, true));
+    if (node?.kind !== "link" || !node.target.startsWith("/")) return void 0;
+    if (node.denied) throw syncError("EACCES", path);
+    return node.target;
+  }
   readlink(path) {
     const node = this.find(path, false);
     if (node.kind !== "link") throw syncError("EINVAL", path);
@@ -14203,7 +14261,7 @@ var ProcTree = class {
     }
   }
 };
-var MAX_HOPS3 = 40;
+var MAX_HOPS4 = 40;
 function* procWalk(path, follow2) {
   let done5 = [];
   let todo = path.split("/").filter((part) => part !== "");
@@ -14222,7 +14280,7 @@ function* procWalk(path, follow2) {
     if (!follow2 && todo.length === 0) return void 0;
     const target = yield { at, check: todo.find((next3) => next3 !== ".") === ".." };
     if (typeof target === "string") {
-      if (++hops > MAX_HOPS3) return void 0;
+      if (++hops > MAX_HOPS4) return void 0;
       [done5, todo] = throughLink(target, done5, todo);
     } else {
       broken ??= refusalOf(target);
@@ -21882,7 +21940,7 @@ function isWatchSyscall(req) {
   return WATCHING.has(req.op);
 }
 var WATCHES_MAX = 8192;
-var parentOf8 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf9 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 function visibleTo2(watch, root, visible) {
   return {
     close: () => watch.close(),
@@ -21892,7 +21950,7 @@ function visibleTo2(watch, root, visible) {
       const shown = await Promise.all(
         notes.map(async (note) => {
           if (!("filename" in note) || !note.filename.includes("/")) return true;
-          const dir = parentOf8(`${root === "/" ? "" : root}/${note.filename}`);
+          const dir = parentOf9(`${root === "/" ? "" : root}/${note.filename}`);
           if (!seen.has(dir)) seen.set(dir, visible(dir));
           return seen.get(dir);
         })