@ai-ecoverse/slicc-kernel 1.124.7 → 1.124.9

package/README.md

@@ -735,7 +735,7 @@ Programs mount and unmount with `mount(2)` and `umount2(2)`, so a `mount`/`umoun
 
 ### Exec
 
-An exec'd program takes over the pid of the process it replaces, as on Linux: `getpid()` and `$$` in the new image, `/proc`, `ps`, `kill` and the parent's `waitpid` all agree on that pid, and the image's parent pid is the replaced process's. Its own children see that pid as their parent. A file removed or renamed over while programs hold it open keeps its bytes for them, as on Linux, whether the descriptors live in the kernel or a program opened the file in its own worker: every open, read-only ones included, is known to the kernel, and all holders share the one file (writes through one are seen through the others). The kernel does not copy it: as NFS does with its "silly rename", it moves the file into a hidden directory, `.slicc-unlinked/`, at the root of the mount it lives on (or of the root file system), and serves the holders' reads and writes from there (a worker's I/O on the old path while the path is gone). No file data is held in memory for it. The file is deleted when the last holder closes it or exits, and the directory goes as soon as it is empty. A file created at the path afterwards is the new file for everyone, also for the holder; a holder whose file another process renames (rather than removes) still uses the old path. A rename over a held file stays atomic for everyone else, as `rename(2)` is: moving the held file aside and the new one into its place are two steps, so a lookup of that name (`open`, `stat`, a read) that comes while they run waits for both, and one that started before them and missed the name in between looks again (also when it spelled the name through a symlinked parent, which the wait doesn't match by path: a miss is retried whenever any replacement finished meanwhile, up to three tries). Every open finds the old file or the new one, never no file (#903). A read through a held descriptor and the rename take the file's turn in order: lookups start to wait for the rename only once it has its turn on every held file it moves aside, so a read that came first finishes, and a rename over a file other processes keep reading never stalls them or itself (#980). A process that opens the file while the rename waits for its turn is a holder too: the rename looks for holders again once it has its turn, so that process keeps the old file as well, and a holder that closed meanwhile leaves nothing to move aside. The OPFS root does the same for its own two steps: a rename onto an existing name replaces the file with `move()` (or, in a browser without it, a copy into the name and a removal of the source), and a lookup that loses that race to a stale handle looks again. A `tmpfs` mount replaces the name in one step; on `fsa` and `hostfs` mounts it is the real file system's `rename`. Listings in the kernel leave `.slicc-unlinked` out, but on an `fsa` or `hostfs` mount it is visible on the real machine while a removed file is held (add `.slicc-unlinked/` to a `.gitignore` there). Each kernel names its entries after itself and holds a Web Lock for that name while it runs; when a mount is set up (and the root at start), the kernel removes the entries whose owner holds no lock, so a tab that died while holding a file leaves nothing behind for long, and entries of other live tabs on the same origin are left alone. Under the Node entry, which has no Web Locks, entries are named after the kernel's process id instead, and an entry is removed when that process is gone (`kill(pid, 0)` fails with `ESRCH`); a reused pid leaves the entry alone. Signals a program ignores stay ignored in the image it execs and in the children it spawns or forks, as POSIX has it, so `nohup cmd` and `trap '' TERM; exec cmd` keep `cmd` safe from them; caught signals go back to their default. The kernel holds what was handed down, so a new image that sets one of those signals back to the default with `signal(SIG_DFL)` still ignores it, until it installs a handler.
+An exec'd program takes over the pid of the process it replaces, as on Linux: `getpid()` and `$$` in the new image, `/proc`, `ps`, `kill` and the parent's `waitpid` all agree on that pid, and the image's parent pid is the replaced process's. Its own children see that pid as their parent. A file removed or renamed over while programs hold it open keeps its bytes for them, as on Linux, whether the descriptors live in the kernel or a program opened the file in its own worker: every open, read-only ones included, is known to the kernel, and all holders share the one file (writes through one are seen through the others). The kernel does not copy it: as NFS does with its "silly rename", it moves the file into a hidden directory, `.slicc-unlinked/`, at the root of the mount it lives on (or of the root file system), and serves the holders' reads and writes from there (a worker's I/O on the old path while the path is gone). No file data is held in memory for it. The file is deleted when the last holder closes it or exits, and the directory goes as soon as it is empty. A file created at the path afterwards is the new file for everyone, also for the holder; a holder whose file another process renames (rather than removes) still uses the old path. A rename over a held file stays atomic for everyone else, as `rename(2)` is: moving the held file aside and the new one into its place are two steps, so a lookup of that name (`open`, `stat`, a read) that comes while they run waits for both, and one that started before them and missed the name in between looks again (also when it spelled the name through a symlinked parent, which the wait doesn't match by path: a miss is retried whenever any replacement finished meanwhile, up to three tries). Every open finds the old file or the new one, never no file (#903). A read through a held descriptor and the rename take the file's turn in order: lookups start to wait for the rename only once it has its turn on every held file it moves aside, so a read that came first finishes, and a rename over a file other processes keep reading never stalls them or itself (#980). A process that opens the file while the rename waits for its turn is a holder too: the rename looks for holders again once it has its turn, so that process keeps the old file as well, and a holder that closed meanwhile leaves nothing to move aside. The same holds for a directory that is removed or renamed over while programs hold files in it: the removal keeps looking for holders until nothing new appears, moving each held file aside, and lookups inside the directory wait for it. An open, a hand-over of a program's descriptor to the kernel (at a fork) or a hold that was under way while the directory went looks its path up again, so it gets the kept old file or ENOENT, never an empty file at the old name (#1013). An open of a path that is gone, with a handle the process no longer holds, is ENOENT rather than a descriptor for a missing file. The OPFS root does the same for its own two steps: a rename onto an existing name replaces the file with `move()` (or, in a browser without it, a copy into the name and a removal of the source), and a lookup that loses that race to a stale handle looks again. A `tmpfs` mount replaces the name in one step; on `fsa` and `hostfs` mounts it is the real file system's `rename`. Listings in the kernel leave `.slicc-unlinked` out, but on an `fsa` or `hostfs` mount it is visible on the real machine while a removed file is held (add `.slicc-unlinked/` to a `.gitignore` there). Each kernel names its entries after itself and holds a Web Lock for that name while it runs; when a mount is set up (and the root at start), the kernel removes the entries whose owner holds no lock, so a tab that died while holding a file leaves nothing behind for long, and entries of other live tabs on the same origin are left alone. Under the Node entry, which has no Web Locks, entries are named after the kernel's process id instead, and an entry is removed when that process is gone (`kill(pid, 0)` fails with `ESRCH`); a reused pid leaves the entry alone. Signals a program ignores stay ignored in the image it execs and in the children it spawns or forks, as POSIX has it, so `nohup cmd` and `trap '' TERM; exec cmd` keep `cmd` safe from them; caught signals go back to their default. The kernel holds what was handed down, so a new image that sets one of those signals back to the default with `signal(SIG_DFL)` still ignores it, until it installs a handler.
 
 - **Emscripten:** `Module.sliccKernel.execve(file, argv, env, cwd)` runs `file` as this process's new image on its fds 0, 1 and 2, waits for it, and returns its wait status, or a negative errno when it cannot start. `env` and `cwd` may be `null` for this process's own. An exec shim detects it with `typeof Module.sliccKernel.execve === 'function'` and exits with the status it returns, as `execve` never returns on success. Older shims spawn the program and then call `Module.sliccKernel.execWait(pid)`; that works the same way: a new program asks the kernel for its pid before `main`, and the kernel answers once its parent has made its next call, so an image an older shim execs also reports the pid it replaced (the wait starts once the program is loaded; should the parent make no call within 100 ms after that, the kernel answers anyway, and the image may then report its own pid; `launcher.identities` counts the programs that asked and those answered by that timeout).
 - **WASIX:** `proc_exec` does this by itself.
@@ -1232,6 +1232,19 @@ A WASIX C program for `test/integration/sig-inherited.test.mjs` (#820), built on
 
 **Build:** `WASIX_SYSROOT_33=/path/to/wasix-sysroot ./build.sh`, with `wasixcc` 0.4.7 and binaryen's `wasm-opt` on `PATH`. `bin/inherittest.wasm` is 39,068 bytes, sha256 `c561a52eb27b3c1b6204b997f4eec967b9f4869c6ab13e7915a5a94b326a710e`.
 
+### `sigjmptest`
+
+A WASIX C program for `test/integration/sigjmp.test.mjs` ([#975](https://github.com/ai-ecoverse/slicc-kernel/issues/975), homescoop#1059), built on wasix-sysroot 2025.9.30-35. Each run takes a mode as its only argument:
+- `term`: a `SIGTERM` handler with `SIGUSR1` in its `sa_mask` sends itself `SIGUSR1`, which must wait until the handler returns: `term-done usr1`.
+- `longjmp`: `longjmp` out of a `SIGUSR1` handler that has `SIGUSR2` in `sa_mask`. It prints the mask after the jump, then unblocks everything and raises `SIGUSR1` again with a handler that returns.
+- `lsleep`, `lnanosleep`, `lread`, `lpoll`: the same with a `SIGALRM` that interrupts `sleep`, `nanosleep`, a `read` of an empty pipe, or `poll`. `sleep`, `nanosleep`, `read`, `poll` (no `l`) and `raise` use `sigsetjmp`/`siglongjmp`.
+- `direct`, `directmask`: `siglongjmp` with no signal at all. `fork` is `raise` in a forked child.
+- `hold` holds `flock` on `sigjmp.lock` for 3 seconds.
+
+On -35, `sigsetjmp` is an ordinary libc function rather than the `setjmp` that LLVM's wasm setjmp/longjmp lowering rewrites, so every `siglongjmp` escapes the program (`[object WebAssembly.Exception]`, exit 70), even `direct`. That is homescoop#1059. The rows use plain `longjmp` until the sysroot fixes it.
+
+**Build:** `WASIX_SYSROOT_35=/path/to/wasix-sysroot ./build.sh`, with `wasixcc` 0.4.7 and binaryen's `wasm-opt` 133 on `PATH`. Asyncify runs with `asyncify-ignore-indirect`, because functions with wasm `try` blocks can't be flattened. `bin/sigjmptest.wasm` is 52,240 bytes, sha256 `9768c2caafa0bcf55e4b9cd2c97a486d46496a275d4e9bd9d5998e163d630fbb`.
+
 ### `handlertest`
 
 A WASIX C program for `test/integration/handler-defer.test.mjs` (#971), built on wasix-sysroot 2025.9.30-33. Its `SIGTERM` handler counts how often and how deeply it runs. On its first run it sends itself `SIGTERM` again and then writes to stderr. `handlertest` installs it with no flags, and `handlertest nodefer` with `SA_NODEFER`. Either way it prints `the handler ran N times, at most D deep`.

package/dist/kernel-worker.js

@@ -6625,7 +6625,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.7" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.124.9" : "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
@@ -7465,6 +7465,7 @@ var LOOKUP_OPS = [
   "realpath"
 ];
 var within4 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var TOUCHED_MAX = 4096;
 var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
@@ -7503,6 +7504,9 @@ var UnlinkedKeeper = class {
   queue = Promise.resolve();
   count = 0;
   replacing = /* @__PURE__ */ new Map();
+  gen = 0;
+  floor = 0;
+  touched = /* @__PURE__ */ new Map();
   replaced = 0;
   links = /* @__PURE__ */ new Map();
   linked = /* @__PURE__ */ new Map();
@@ -7529,28 +7533,28 @@ var UnlinkedKeeper = class {
     const { replacing } = this;
     const replace = async (target, op) => {
       const { promise, resolve: resolve2 } = Promise.withResolvers();
+      keeper.touch(target);
       let mine;
       const gated = () => {
         const before = replacing.get(target);
-        mine = { done: Promise.all([before?.done, promise]).then(() => void 0) };
+        mine = { done: Promise.all([before?.done, promise]).then(() => void 0), sealed: false };
         replacing.set(target, mine);
       };
+      const sealed = () => {
+        if (mine) mine.sealed = true;
+      };
       try {
-        await op(gated);
+        await op(gated, sealed);
       } finally {
         keeper.replaced += 1;
+        keeper.touch(target);
         resolve2();
         if (mine && replacing.get(target) === mine) replacing.delete(target);
       }
     };
     const unreplaced = async (path, op) => {
       const at = fs.resolvePath("/", path);
-      const pending = async () => {
-        for (let p = at; replacing.size > 0; p = parentOf5(p)) {
-          await replacing.get(p)?.done;
-          if (p === "/") return;
-        }
-      };
+      const pending = () => keeper.settled(at);
       for (let attempt = 1; ; attempt++) {
         await pending();
         const seen = keeper.replaced;
@@ -7584,8 +7588,8 @@ var UnlinkedKeeper = class {
       lstat: (path) => unreplaced(path, async () => counted2(await fs.lstat(path))),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
-        await replace(target, async (gated) => {
-          const pinned = await keeper.pin(target, gated);
+        await replace(target, async (gated, sealed) => {
+          const pinned = await keeper.pin(target, gated, sealed);
           if (pinned.moved.has(target)) pinned.commit();
           else await keeper.settle(pinned, () => fs.rm(path, options));
         });
@@ -7593,8 +7597,8 @@ var UnlinkedKeeper = class {
       async rename(from, to) {
         const target = fs.resolvePath("/", to);
         if (target === fs.resolvePath("/", from)) return fs.rename(from, to);
-        await replace(target, async (gated) => {
-          const pinned = await keeper.pin(target, gated);
+        await replace(target, async (gated, sealed) => {
+          const pinned = await keeper.pin(target, gated, sealed);
           await keeper.settle(pinned, () => fs.rename(from, to));
         });
       },
@@ -7602,6 +7606,39 @@ var UnlinkedKeeper = class {
       readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted2(st)])
     };
   }
+  async settled(path) {
+    for (let p = path; this.replacing.size > 0; p = parentOf5(p)) {
+      await this.replacing.get(p)?.done;
+      if (p === "/") return;
+    }
+  }
+  generation() {
+    return this.gen;
+  }
+  changedSince(path, gen) {
+    if (gen < this.floor) return true;
+    for (let p = path; this.touched.size > 0; p = parentOf5(p)) {
+      if ((this.touched.get(p) ?? 0) > gen) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
+  touch(target) {
+    this.gen += 1;
+    this.touched.delete(target);
+    this.touched.set(target, this.gen);
+    if (this.touched.size <= TOUCHED_MAX) return;
+    const [oldest, at] = this.touched.entries().next().value;
+    this.touched.delete(oldest);
+    this.floor = at;
+  }
+  missed(path) {
+    for (let p = path; this.replacing.size > 0; p = parentOf5(p)) {
+      if (this.replacing.get(p)?.sealed) return true;
+      if (p === "/") return false;
+    }
+    return false;
+  }
   async settle(pinned, op) {
     try {
       await op();
@@ -7622,33 +7659,41 @@ var UnlinkedKeeper = class {
     }
     return held;
   }
-  async pin(target, gated = () => void 0) {
+  async pin(target, gated = () => void 0, sealed = () => void 0) {
     const paths = [];
     const releases = [];
-    for (; ; ) {
-      const fresh2 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
-      if (fresh2.length === 0) break;
-      fresh2.sort();
-      if (paths.some((path) => path > fresh2[0])) {
-        for (const release of releases.splice(0)) release();
-        fresh2.push(...paths.splice(0));
+    const take = async () => {
+      for (; ; ) {
+        const fresh2 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
+        if (fresh2.length === 0) return;
         fresh2.sort();
+        if (paths.some((path) => path > fresh2[0])) {
+          for (const release of releases.splice(0)) release();
+          fresh2.push(...paths.splice(0));
+          fresh2.sort();
+        }
+        for (const path of fresh2) {
+          paths.push(path);
+          releases.push(await this.gate.acquire(path));
+        }
       }
-      for (const path of fresh2) {
-        paths.push(path);
-        releases.push(await this.gate.acquire(path));
-      }
-    }
+    };
+    await take();
     gated();
-    const now = this.heldWithin(target);
-    const held = new Map(
-      paths.flatMap((path) => now.has(path) ? [[path, now.get(path)]] : [])
-    );
+    const held = /* @__PURE__ */ new Map();
     const hidden = /* @__PURE__ */ new Map();
-    for (const path of held.keys()) {
-      const at = await this.hide(path);
-      if (at !== void 0) hidden.set(path, at);
+    for (; ; ) {
+      await take();
+      const now = this.heldWithin(target);
+      const next3 = paths.filter((path) => now.has(path) && !held.has(path));
+      if (next3.length === 0) break;
+      for (const path of next3) {
+        held.set(path, now.get(path));
+        const at = await this.hide(path);
+        if (at !== void 0) hidden.set(path, at);
+      }
     }
+    sealed();
     const done4 = () => {
       for (const release of releases) release();
     };
@@ -10314,6 +10359,9 @@ var HeldPaths = class extends Map {
   keptFor(handle) {
     return this.keptHandles.get(handle);
   }
+  holdsHandle(handle) {
+    return this.handles.has(handle);
+  }
   keeps(hidden) {
     for (const file of this.uses.keys()) if (file.hidden === hidden) return true;
     for (const file of this.unlinked.values()) if (file.hidden === hidden) return true;
@@ -11760,10 +11808,16 @@ async function run(entry, path, req) {
       return done;
     case "exists":
       return json2(await fs.exists(path));
-    case "stat":
-      return json2(statJson(await shownAs(entry, path, await fs.stat(path))));
-    case "lstat":
-      return json2(statJson(await shownAs(entry, path, await fs.lstat(path))));
+    case "stat": {
+      const gen = entry.replacements?.generation();
+      const st = statJson(await shownAs(entry, path, await fs.stat(path)));
+      return json2(gen === void 0 ? st : { ...st, gen });
+    }
+    case "lstat": {
+      const gen = entry.replacements?.generation();
+      const st = statJson(await shownAs(entry, path, await fs.lstat(path)));
+      return json2(gen === void 0 ? st : { ...st, gen });
+    }
     case "readdir":
       return json2(await fs.readdir(path));
     case "readdir-stat":
@@ -11938,14 +11992,26 @@ async function opening(entry, path, mode) {
     await need(g, "open", path, want, { directory: false });
   }
 }
+async function stillThere(entry, path, req) {
+  if (req.gen === void 0 || !entry.replacements?.changedSince(path, req.gen)) return;
+  const st = await entry.fs.stat(path).catch(() => void 0);
+  if (!st) throw syncError("ENOENT", path);
+}
 async function holdOp(entry, path, req) {
   const mode = req.mode ?? 0;
   const [on, open] = [(mode & 1) === 1, (mode & 2) === 2];
   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);
+    for (; ; ) {
+      const r = entry.replacements;
+      await r?.settled(path);
+      const gen = r?.generation() ?? 0;
+      await opening(entry, path, mode);
+      const real = await entry.fs.realpath?.(path, true).catch(() => path);
+      await entry.source?.open(path, real);
+      await stillThere(entry, path, req);
+      if (!r || !r.missed(path) && !r.changedSince(path, gen))
+        return json2(entry.hold?.(path, on, open, real) ?? null);
+    }
   }
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
@@ -17684,6 +17750,7 @@ var VfsNode = class {
   path;
   orphaned;
   id;
+  ino;
   onDirty;
   onDirtyState;
   counted = false;
@@ -18036,8 +18103,12 @@ var VfsNodes = class {
     if (id2 !== void 0) this.know(node, id2);
     return node;
   }
-  open(path, pin, writable2 = false, id2) {
-    const node = this.named(path, id2) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
+  open(path, pin, writable2 = false, id2, ino) {
+    const found = this.named(path, id2);
+    const same = !found || ino === void 0 || found.ino === void 0 || found.ino === ino;
+    if (found && !same) this.orphan(found);
+    const node = (same ? found : void 0) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
+    node.ino ??= ino;
     node.opens++;
     if (writable2) node.writers++;
     return node;
@@ -18331,7 +18402,7 @@ function vfsFile(fs, opts, nodes) {
   const access2 = opts.flags & O_ACCMODE;
   const readable2 = access2 !== O_WRONLY;
   const writable2 = access2 === O_WRONLY || access2 === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id);
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id, opts.ino);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -19101,6 +19172,7 @@ var WasmProcess = class {
     const fd = this.fds.install(heldFile(), 3);
     try {
       const nodes = this.nodes;
+      const gen = this.replacements?.generation() ?? 0;
       const path = await this.openPath(req, marked);
       if (inProc(path)) {
         this.fds.installAt(fd, await this.procFile(req, path));
@@ -19125,7 +19197,15 @@ var WasmProcess = class {
           }
         });
       } else {
-        this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path), fs));
+        await this.unmissed(
+          () => this.openPath(req, marked),
+          async (at) => {
+            await this.stillOpen(at, req.handle);
+            return nodes.identify(at);
+          },
+          (id2, at) => this.fds.installAt(fd, this.openVfsFile({ ...open, path: at }, id2, fs)),
+          { at: path, gen }
+        );
       }
       if (req.existing && !await present2(fs, path, true)) {
         throw new KernelError("ENOENT");
@@ -19306,7 +19386,8 @@ var WasmProcess = class {
         ...req.truncate ? { truncate: true } : {},
         ...req.create ? { create: true } : {},
         ...req.pin ? { pin: req.pin } : {},
-        ...id2 !== void 0 && !req.orphan ? { id: id2 } : {}
+        ...id2 !== void 0 && !req.orphan ? { id: id2 } : {},
+        ...req.ino !== void 0 && !req.orphan ? { ino: req.ino } : {}
       },
       this.nodes
     );
@@ -19477,9 +19558,27 @@ var WasmProcess = class {
     return false;
   }
   keptHandle;
+  holdsHandle;
+  replacements;
+  async unmissed(path, look, make, first) {
+    let given = first;
+    for (; ; ) {
+      const r = this.replacements;
+      const gen = given?.gen ?? r?.generation() ?? 0;
+      const at = given?.at ?? await path();
+      given = void 0;
+      await r?.settled(at);
+      const found = await look(at);
+      if (!r || !r.missed(at) && !r.changedSince(at, gen)) return make(found, at);
+    }
+  }
+  async stillOpen(at, handle) {
+    if (handle === void 0 || this.keptHandle?.(handle) !== void 0) return;
+    if (this.holdsHandle?.(handle) !== false) return;
+    if (!await present2(this.options.fs, at, true)) throw new KernelError("ENOENT");
+  }
   async keptOr(path, handle) {
-    const held = handle === void 0 ? void 0 : this.keptHandle?.(handle);
-    if (held !== void 0) return held;
+    if (handle !== void 0) return this.keptHandle?.(handle) ?? path;
     const kept = this.keptPath?.(path);
     return kept !== void 0 && !await present2(this.options.fs, path, true) ? kept : path;
   }
@@ -19489,25 +19588,37 @@ var WasmProcess = class {
       await this.fds.dup2Clipboard(req.share, req.fd);
       return;
     }
-    if (req.path === void 0) throw new KernelError("EINVAL");
-    const path = req.orphan ? req.path : await this.keptOr(await this.nodes.targetKey(req.path), req.handle);
-    const id2 = req.orphan ? void 0 : await this.nodes.identify(path);
-    if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
-    const file = vfsFile(
-      this.options.fs,
-      {
-        path,
-        flags: req.flags ?? 0,
-        position: req.position ?? 0,
-        ...req.contents !== void 0 ? { contents: req.contents } : {},
-        ...req.orphan ? { orphan: true } : {},
-        ...req.dirty ? { dirty: true } : {},
-        ...req.pin ? { pin: req.pin } : {},
-        ...id2 !== void 0 ? { id: id2 } : {}
+    const asked = req.path;
+    if (asked === void 0) throw new KernelError("EINVAL");
+    const install = ([path, id2]) => {
+      if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
+      const file = vfsFile(
+        this.options.fs,
+        {
+          path,
+          flags: req.flags ?? 0,
+          position: req.position ?? 0,
+          ...req.contents !== void 0 ? { contents: req.contents } : {},
+          ...req.orphan ? { orphan: true } : {},
+          ...req.dirty ? { dirty: true } : {},
+          ...req.pin ? { pin: req.pin } : {},
+          ...id2 !== void 0 ? { id: id2 } : {},
+          ...req.ino !== void 0 && path === asked ? { ino: req.ino } : {}
+        },
+        this.nodes
+      );
+      this.fds.installAt(req.fd, file);
+    };
+    if (req.orphan) return install([asked, void 0]);
+    await this.unmissed(
+      () => this.nodes.targetKey(asked),
+      async (target) => {
+        const at = await this.keptOr(target, req.handle);
+        await this.stillOpen(at, req.handle);
+        return [at, await this.nodes.identify(at)];
       },
-      this.nodes
+      install
     );
-    this.fds.installAt(req.fd, file);
   }
   reserve(fd, min = 3, meta) {
     if (fd === void 0) return this.fds.install(heldFile(meta), Math.max(3, min));
@@ -20160,6 +20271,12 @@ function inherited(opts) {
     ...opts.cred ? { cred: opts.cred } : {}
   };
 }
+function heldBy(process, holds2, replacements) {
+  process.keptPath = (path) => holds2.keptAt(path)?.hidden;
+  process.keptHandle = (handle) => holds2.keptFor(handle)?.hidden;
+  process.holdsHandle = (handle) => holds2.holdsHandle(handle);
+  if (replacements) process.replacements = replacements;
+}
 function holdingToken(opts, holds2, caller) {
   return mintSyncFsToken({
     ...opts.owners ? caller : { umask: caller.umask },
@@ -20167,6 +20284,7 @@ function holdingToken(opts, holds2, caller) {
     ...opts.links !== void 0 ? { links: opts.links } : {},
     ...opts.fresh ? { fresh: (path) => opts.fresh?.(path, caller.umask()) } : {},
     ...opts.source ? { source: opts.source } : {},
+    ...opts.replacements ? { replacements: opts.replacements } : {},
     fs: opts.fs,
     noLinks: opts.noLinks,
     cwd: opts.cwd,
@@ -20248,6 +20366,7 @@ function threadInit(opts, program, sab, cred, thread, main) {
     cred: copyCred(cred),
     owners: opts.owners === true,
     ...opts.links !== void 0 ? { links: true } : {},
+    ...opts.changes ? { changes: opts.changes } : {},
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
     thread,
     signals: main
@@ -20305,8 +20424,7 @@ function spawnWasmProcess(opts) {
     created: created3,
     holdsKept: async (path) => path.includes(`/${UNLINKED_DIR}/`) && (holds2.keeps(path) || await process.holds(path))
   });
-  process.keptPath = (path) => holds2.keptAt(path)?.hidden;
-  process.keptHandle = (handle2) => holds2.keptFor(handle2)?.hidden;
+  heldBy(process, holds2, opts.replacements);
   const worker = opts.createWorker();
   const dying = new Dying();
   const dispatch2 = (req, block) => dying.serve(
@@ -25426,6 +25544,7 @@ var Launcher = class {
       nodes: stack.nodes,
       held: this.held,
       unlinkGate: stack.unlinked.gate,
+      replacements: stack.unlinked,
       statfs: (path) => this.mounts.statfs(path),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),