npm - @ai-ecoverse/slicc-kernel - Versions diffs - 1.50.0 → 1.52.0 - Mend

@ai-ecoverse/slicc-kernel 1.50.0 → 1.52.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +5 -5
package/dist/kernel-worker.js +24 -9
package/dist/kernel-worker.js.map +2 -2
package/dist/node-process-worker.js +714 -269
package/dist/node-process-worker.js.map +4 -4
package/dist/node.js +24 -9
package/dist/node.js.map +2 -2
package/dist/process-worker.js +764 -319
package/dist/process-worker.js.map +4 -4
package/package.json +1 -1

package/dist/process-worker.js CHANGED Viewed

@@ -9,8 +9,8 @@ var __esm = (fn, res, err) => function __init() {
   }
 };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 // src/kernel/protocol.ts
@@ -30,13 +30,13 @@ var init_protocol = __esm({
 });
 // src/kernel/net/loopback-names.ts
-function reserved(name) {
-  const lower = name.toLowerCase();
+function reserved(name2) {
+  const lower = name2.toLowerCase();
   return lower === "localhost" || lower.endsWith(".localhost") || lower === HOST_LOOPBACK || lower === "wasmer.sh" || /^\d+(\.\d+){3}$/.test(lower);
 }
-function isHostname(name) {
-  if (typeof name !== "string" || name.length > 253 || reserved(name)) return false;
-  return name.split(".").every((l) => LABEL.test(l));
+function isHostname(name2) {
+  if (typeof name2 !== "string" || name2.length > 253 || reserved(name2)) return false;
+  return name2.split(".").every((l) => LABEL.test(l));
 }
 function hostnameOf(env) {
   return isHostname(env.HOSTNAME) ? env.HOSTNAME : DEFAULT_HOSTNAME;
@@ -416,11 +416,11 @@ var init_types = __esm({
 // src/process/wasi/wasi-abi.ts
 function wasiErrnoOf(code2) {
   if (!code2) return E.IO;
-  const name = code2.startsWith("E") ? code2.slice(1) : code2;
-  if (name === "OPNOTSUPP") return E.NOTSUP;
-  if (name === "WOULDBLOCK") return E.AGAIN;
-  if (name === "NOMEDIUM") return E.NODEV;
-  return E[name] ?? E.IO;
+  const name2 = code2.startsWith("E") ? code2.slice(1) : code2;
+  if (name2 === "OPNOTSUPP") return E.NOTSUP;
+  if (name2 === "WOULDBLOCK") return E.AGAIN;
+  if (name2 === "NOMEDIUM") return E.NODEV;
+  return E[name2] ?? E.IO;
 }
 function wasixSignal(sig) {
   return Number.isInteger(sig) && sig >= 1 && sig <= 31 ? sig : void 0;
@@ -563,7 +563,7 @@ var init_wasi_errno = __esm({
     "use strict";
     init_wasi_abi();
     WASI_ERRNO = {
-      ...Object.fromEntries(Object.entries(E).map(([name, errno2]) => [`E${name}`, errno2])),
+      ...Object.fromEntries(Object.entries(E).map(([name2, errno2]) => [`E${name2}`, errno2])),
       EWOULDBLOCK: E.AGAIN,
       ENOTSUP: 138,
       EOPNOTSUPP: 138,
@@ -641,8 +641,8 @@ function createHelpers(Fs, ops) {
   function freshState(stat) {
     return { ...stat ? { stat } : {}, len: 0, loaded: false, dirty: false, openCount: 0 };
   }
-  function makeNode(parent, name, st) {
-    const node = Fs.createNode(parent, name, modeFromStat(st), 0);
+  function makeNode(parent, name2, st) {
+    const node = Fs.createNode(parent, name2, modeFromStat(st), 0);
     node.node_ops = ops.node;
     node.stream_ops = ops.stream;
     node.live = freshState(st);
@@ -660,9 +660,9 @@ function createHelpers(Fs, ops) {
     }
     return node.live.stat;
   }
-  function childPath(parent, name) {
+  function childPath(parent, name2) {
     const base = liveNodePath(parent);
-    return base === "/" ? `/${name}` : `${base}/${name}`;
+    return base === "/" ? `/${name2}` : `${base}/${name2}`;
   }
   function ensureLoaded(node) {
     const s = node.live;
@@ -829,15 +829,15 @@ function createNodeOps(h) {
       if (times) setTimes(node, path, ...times);
       node.live.stat = void 0;
     },
-    lookup(parent, name) {
-      const listed = parent.live.listed?.get(name);
-      parent.live.listed?.delete(name);
-      const st = listed ?? call2(() => bridgeOf(parent).lstat(childPath(parent, name)));
-      return makeNode(parent, name, st);
+    lookup(parent, name2) {
+      const listed = parent.live.listed?.get(name2);
+      parent.live.listed?.delete(name2);
+      const st = listed ?? call2(() => bridgeOf(parent).lstat(childPath(parent, name2)));
+      return makeNode(parent, name2, st);
     },
-    mknod(parent, name, mode) {
+    mknod(parent, name2, mode) {
       parent.live.listed = void 0;
-      const path = childPath(parent, name);
+      const path = childPath(parent, name2);
       if (Fs.isDir(mode)) {
         call2(() => bridgeOf(parent).mkdir(path));
         const perm = mode & PERM_MASK & ~UMASK;
@@ -850,7 +850,7 @@ function createNodeOps(h) {
       } else {
         throw new Fs.ErrnoError(wasiErrno("EPERM"));
       }
-      const node = makeNode(parent, name, {
+      const node = makeNode(parent, name2, {
         isFile: Fs.isFile(mode),
         isDirectory: Fs.isDir(mode),
         isSymbolicLink: false,
@@ -877,11 +877,11 @@ function createNodeOps(h) {
       oldNode.parent = newDir;
       oldNode.live.stat = void 0;
     },
-    unlink(parent, name) {
+    unlink(parent, name2) {
       parent.live.listed = void 0;
       let open;
       try {
-        const node = Fs.lookupNode?.(parent, name);
+        const node = Fs.lookupNode?.(parent, name2);
         if (node && node.live?.openCount > 0 && Fs.isFile(node.mode)) open = node;
       } catch {
       }
@@ -891,18 +891,18 @@ function createNodeOps(h) {
         if (ranged) ranged.pin();
         else ensureLoaded(open);
       }
-      call2(() => bridgeOf(parent).unlink(childPath(parent, name)));
+      call2(() => bridgeOf(parent).unlink(childPath(parent, name2)));
       if (open) open.live.orphan = true;
     },
-    rmdir(parent, name) {
+    rmdir(parent, name2) {
       parent.live.listed = void 0;
-      call2(() => bridgeOf(parent).rmdir(childPath(parent, name)));
+      call2(() => bridgeOf(parent).rmdir(childPath(parent, name2)));
     },
     readdir(node) {
       const listed = call2(() => bridgeOf(node).readdirStat(liveNodePath(node)));
       node.live.listed = /* @__PURE__ */ new Map();
-      for (const [name, st] of listed) if (st) node.live.listed.set(name, st);
-      return [".", "..", ...listed.map(([name]) => name)];
+      for (const [name2, st] of listed) if (st) node.live.listed.set(name2, st);
+      return [".", "..", ...listed.map(([name2]) => name2)];
     },
     symlink(parent, newName, target) {
       parent.live.listed = void 0;
@@ -1165,28 +1165,28 @@ function liveRoot(Fs, bridge) {
   const memfs = root.memfs ?? root.node_ops;
   const live = plugin.node_ops;
   root.memfs = memfs;
-  const own = (name) => Object.hasOwn(root.contents ?? {}, name);
+  const own = (name2) => Object.hasOwn(root.contents ?? {}, name2);
   root.node_ops = {
     ...memfs,
-    lookup: (parent, name) => live.lookup(parent, name),
-    mknod: (parent, name, mode, dev) => live.mknod(parent, name, mode, dev),
-    unlink: (parent, name) => live.unlink(parent, name),
-    rmdir: (parent, name) => (own(name) ? memfs : live).rmdir(parent, name),
-    symlink: (parent, name, target) => live.symlink(parent, name, target),
-    rename: (node, dir, name) => (node.live ? live : memfs).rename(node, dir, name),
+    lookup: (parent, name2) => live.lookup(parent, name2),
+    mknod: (parent, name2, mode, dev) => live.mknod(parent, name2, mode, dev),
+    unlink: (parent, name2) => live.unlink(parent, name2),
+    rmdir: (parent, name2) => (own(name2) ? memfs : live).rmdir(parent, name2),
+    symlink: (parent, name2, target) => live.symlink(parent, name2, target),
+    rename: (node, dir, name2) => (node.live ? live : memfs).rename(node, dir, name2),
     readdir(node) {
       const names = new Set(memfs.readdir(node));
-      for (const name of live.readdir(node)) names.add(name);
+      for (const name2 of live.readdir(node)) names.add(name2);
       return [...names];
     }
   };
 }
 function crosses(Fs, from, to) {
   const parentOf = (path) => Fs.lookupPath?.(path, { parent: true }).node;
-  const name = from.replace(/\/+$/, "").split("/").pop() ?? "";
+  const name2 = from.replace(/\/+$/, "").split("/").pop() ?? "";
   try {
     const fromDir = parentOf(from);
-    const node = fromDir && Fs.lookupNode?.(fromDir, name);
+    const node = fromDir && Fs.lookupNode?.(fromDir, name2);
     const dir = parentOf(to);
     return !!node && !!dir && !!node.live !== !!dir.live;
   } catch {
@@ -1227,8 +1227,8 @@ function guardKeptNodes(Fs, handled) {
   Fs.sliccKept = true;
   const lookupPath = Fs.lookupPath.bind(Fs);
   Fs.open = (path, flags, mode) => {
-    const name = path.slice(path.lastIndexOf("/") + 1);
-    if (![...handled].some((held) => held.name === name)) return open(path, flags, mode);
+    const name2 = path.slice(path.lastIndexOf("/") + 1);
+    if (![...handled].some((held) => held.name === name2)) return open(path, flags, mode);
     let node;
     try {
       node = lookupPath(path, { follow: true }).node;
@@ -1276,7 +1276,7 @@ function topLevelDirs(bridge, warn) {
     warn(`cannot list the VFS root, nothing mounted: ${String(err)}`);
     return void 0;
   }
-  const candidates = names.filter((name) => name && !name.includes("/") && !MODULE_OWNED_DIRS.has(name)).map((name) => `/${name}`);
+  const candidates = names.filter((name2) => name2 && !name2.includes("/") && !MODULE_OWNED_DIRS.has(name2)).map((name2) => `/${name2}`);
   for (const dir of SYNTHETIC_DIRS) if (!candidates.includes(dir)) candidates.push(dir);
   const dirs = [];
   for (const dir of candidates) {
@@ -1754,14 +1754,14 @@ var init_kernel_streams = __esm({
       nameTerminal(stream) {
         const kfd = stream.sliccKernelFd;
         if (!stream.tty || kfd === void 0) return;
-        const name = this.sys.ttyName?.(kfd);
-        if (name) this.nameStream(stream, name);
+        const name2 = this.sys.ttyName?.(kfd);
+        if (name2) this.nameStream(stream, name2);
       }
-      nameStream(stream, name) {
-        stream.path = name;
-        this.ttyNode(name);
+      nameStream(stream, name2) {
+        stream.path = name2;
+        this.ttyNode(name2);
         if (typeof this.Fs.stat !== "function") return;
-        stream.stream_ops = { ...stream.stream_ops, getattr: () => this.Fs.stat?.(name) ?? {} };
+        stream.stream_ops = { ...stream.stream_ops, getattr: () => this.Fs.stat?.(name2) ?? {} };
       }
       creatingTerminal = false;
       useTerminalNodes() {
@@ -1769,12 +1769,12 @@ var init_kernel_streams = __esm({
         const { lookupNode, readdir, getPath, mkdev, makedev } = fs;
         const ttyNames = this.sys.ttyNames?.bind(this.sys);
         if (!lookupNode || !readdir || !getPath || !mkdev || !makedev || !ttyNames) return;
-        fs.lookupNode = (parent, name) => {
+        fs.lookupNode = (parent, name2) => {
           try {
-            return lookupNode.call(fs, parent, name);
+            return lookupNode.call(fs, parent, name2);
           } catch (e) {
-            const path = `/dev/${name}`;
-            if (this.creatingTerminal || !TTY_NAME.test(name) || getPath.call(fs, parent) !== "/dev")
+            const path = `/dev/${name2}`;
+            if (this.creatingTerminal || !TTY_NAME.test(name2) || getPath.call(fs, parent) !== "/dev")
               throw e;
             if (!ttyNames().includes(path)) throw e;
             this.creatingTerminal = true;
@@ -1783,21 +1783,21 @@ var init_kernel_streams = __esm({
             } finally {
               this.creatingTerminal = false;
             }
-            return lookupNode.call(fs, parent, name);
+            return lookupNode.call(fs, parent, name2);
           }
         };
         fs.readdir = (path) => {
           const names = readdir.call(fs, path);
           if (path.replace(/\/+$/, "") !== "/dev") return names;
-          const missing = ttyNames().map((tty) => tty.slice("/dev/".length)).filter((name) => TTY_NAME.test(name) && !names.includes(name));
+          const missing = ttyNames().map((tty) => tty.slice("/dev/".length)).filter((name2) => TTY_NAME.test(name2) && !names.includes(name2));
           return [...names, ...missing];
         };
       }
-      ttyNode(name) {
+      ttyNode(name2) {
         const { analyzePath, mkdev, makedev } = this.Fs;
-        if (!TTY_PATH.test(name) || !analyzePath || !mkdev || !makedev) return;
-        if (!analyzePath.call(this.Fs, name).exists)
-          mkdev.call(this.Fs, name, makedev.call(this.Fs, 6, 0));
+        if (!TTY_PATH.test(name2) || !analyzePath || !mkdev || !makedev) return;
+        if (!analyzePath.call(this.Fs, name2).exists)
+          mkdev.call(this.Fs, name2, makedev.call(this.Fs, 6, 0));
       }
       ttyOps(kfd) {
         return {
@@ -1834,18 +1834,18 @@ var init_kernel_streams = __esm({
           size: this.call(() => size.call(this.sys, kfd))
         }));
       }
-      describe(stream, name, getattr) {
+      describe(stream, name2, getattr) {
         if (this.descriptions.size === 0) this.useDescriptions();
-        this.descriptions.set(name, getattr);
-        stream.path = name;
+        this.descriptions.set(name2, getattr);
+        stream.path = name2;
         stream.stream_ops = { ...stream.stream_ops, getattr };
       }
       useDescriptions() {
         const fs = this.Fs;
-        for (const name of ["stat", "lstat"]) {
-          const original = fs[name];
+        for (const name2 of ["stat", "lstat"]) {
+          const original = fs[name2];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest2) => {
+          fs[name2] = (path, ...rest2) => {
             const getattr = this.descriptions.get(path);
             return getattr ? getattr() : original.call(fs, path, ...rest2);
           };
@@ -1932,15 +1932,15 @@ var init_kernel_streams = __esm({
       }
       usePtyPaths() {
         const fs = this.Fs;
-        for (const name of ["chown", "lchown", "chmod", "lchmod"]) {
-          const original = fs[name];
+        for (const name2 of ["chown", "lchown", "chmod", "lchmod"]) {
+          const original = fs[name2];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest2) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest2);
+          fs[name2] = (path, ...rest2) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest2);
         }
-        for (const name of ["stat", "lstat"]) {
-          const original = fs[name];
+        for (const name2 of ["stat", "lstat"]) {
+          const original = fs[name2];
           if (typeof original !== "function") continue;
-          fs[name] = (path, ...rest2) => {
+          fs[name2] = (path, ...rest2) => {
             if (!isPtyPath(path)) return original.call(fs, path, ...rest2);
             this.existingPty(path);
             return ptyStat(path);
@@ -1953,14 +1953,14 @@ var init_kernel_streams = __esm({
         if (!exists) throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
       }
       devicePath(path) {
-        const name = path.slice(path.lastIndexOf("/") + 1);
-        if (!TTY_NAME.test(name)) return void 0;
+        const name2 = path.slice(path.lastIndexOf("/") + 1);
+        if (!TTY_NAME.test(name2)) return void 0;
         const { lookupPath, cwd } = this.Fs;
         const absolute = path.startsWith("/") ? path : `${cwd?.call(this.Fs) ?? "/"}/${path}`;
         const dir = absolute.slice(0, absolute.lastIndexOf("/")) || "/";
         try {
           const real = lookupPath?.call(this.Fs, dir, { follow: true }).path ?? dir;
-          return `${real === "/" ? "" : real}/${name}`;
+          return `${real === "/" ? "" : real}/${name2}`;
         } catch {
           return absolute;
         }
@@ -2257,11 +2257,11 @@ function kernelTimer(setitimer, timer) {
     return 0;
   };
 }
-function syscallOf(glue, name, value2) {
+function syscallOf(glue, name2, value2) {
   const names = Object.keys(IMPORT_NAMES);
   const own = names.find((key) => glue[key] !== void 0 && glue[key] === value2);
   if (own) return own;
-  return typeof value2 === "function" ? names.find((key) => glue[key] !== void 0 && IMPORT_NAMES[key] === name) : void 0;
+  return typeof value2 === "function" ? names.find((key) => glue[key] !== void 0 && IMPORT_NAMES[key] === name2) : void 0;
 }
 function wrapCloexecSyscalls(imports, glue, deps) {
   if (!glue) return;
@@ -2270,10 +2270,10 @@ function wrapCloexecSyscalls(imports, glue, deps) {
   for (const namespace of Object.values(imports)) {
     if (!namespace || typeof namespace !== "object" || seen.has(namespace)) continue;
     seen.add(namespace);
-    for (const [name, value2] of Object.entries(namespace)) {
-      const key = syscallOf(glue, name, value2);
+    for (const [name2, value2] of Object.entries(namespace)) {
+      const key = syscallOf(glue, name2, value2);
       const wrap2 = key && factories[key];
-      if (wrap2) namespace[name] = wrap2(value2);
+      if (wrap2) namespace[name2] = wrap2(value2);
     }
   }
 }
@@ -2317,7 +2317,7 @@ function kernelUmask(imports, deps) {
 function noFollowUtimes(imports, fs, glue) {
   for (const namespace of namespaces(imports)) {
     const key = Object.keys(namespace).find(
-      (name) => glue !== void 0 && namespace[name] === glue || name === "__syscall_utimensat"
+      (name2) => glue !== void 0 && namespace[name2] === glue || name2 === "__syscall_utimensat"
     );
     const utimensat = key === void 0 ? void 0 : namespace[key];
     if (key === void 0 || typeof utimensat !== "function") continue;
@@ -2357,10 +2357,10 @@ function namespaces(imports) {
   }
   return [...seen];
 }
-function keyOf(namespace, name, glue) {
-  const own = glue?.[name];
+function keyOf(namespace, name2, glue) {
+  const own = glue?.[name2];
   const found = typeof own === "function" ? Object.keys(namespace).find((k) => namespace[k] === own) : void 0;
-  return found ?? (typeof namespace[name] === "function" ? name : void 0);
+  return found ?? (typeof namespace[name2] === "function" ? name2 : void 0);
 }
 function syncFsync(imports, fs, glue) {
   for (const namespace of namespaces(imports)) {
@@ -2424,11 +2424,11 @@ function positioned(original, write2, deps) {
 }
 function positionalIo(imports, deps) {
   for (const namespace of namespaces(imports)) {
-    for (const [name, write2] of [
+    for (const [name2, write2] of [
       ["fd_pread", false],
       ["fd_pwrite", true]
     ]) {
-      const key = keyOf(namespace, name, deps.glue);
+      const key = keyOf(namespace, name2, deps.glue);
       if (key !== void 0) {
         namespace[key] = positioned(namespace[key], write2, deps);
       }
@@ -2530,8 +2530,8 @@ function describeFdDir(Fs) {
   dir.node_ops = {
     ...ops,
     getattr: () => syntheticAttr(DIR_MODE, 1),
-    lookup: (parent, name) => {
-      const entry = lookup(parent, name);
+    lookup: (parent, name2) => {
+      const entry = lookup(parent, name2);
       entry.node_ops = {
         ...entry.node_ops,
         getattr: () => syntheticAttr(LINK_MODE, entry.id ?? 0)
@@ -2568,13 +2568,13 @@ function useZeroDevices(Fs) {
 function linkStdio(Fs) {
   const { unlink, symlink } = Fs;
   if (!unlink || !symlink) return;
-  for (const [fd, name] of ["stdin", "stdout", "stderr"].entries()) {
+  for (const [fd, name2] of ["stdin", "stdout", "stderr"].entries()) {
     try {
-      unlink.call(Fs, `/dev/${name}`);
+      unlink.call(Fs, `/dev/${name2}`);
     } catch {
     }
     try {
-      symlink.call(Fs, `/proc/self/fd/${fd}`, `/dev/${name}`);
+      symlink.call(Fs, `/proc/self/fd/${fd}`, `/dev/${name2}`);
     } catch {
     }
   }
@@ -2626,14 +2626,14 @@ function mountTable(mounts = []) {
 }
 function accounts(env = {}) {
   const user = env.USER ?? "web_user";
-  const name = NAME.test(user) && user !== "root" ? user : "user";
+  const name2 = NAME.test(user) && user !== "root" ? user : "user";
   const home = env.HOME || "/home";
   return {
     passwd: `root:x:0:0:root:/root:/bin/sh
-${name}:x:1000:1000:${name}:${home}:/bin/bash
+${name2}:x:1000:1000:${name2}:${home}:/bin/bash
 `,
     group: `root:x:0:
-${name}:x:1000:
+${name2}:x:1000:
 `
   };
 }
@@ -3442,9 +3442,9 @@ function createSocketKernel(deps) {
     }),
     shutdown: (fd, how) => guard(() => done({ op: "sock-shutdown", fd: kfd(fd), how })),
     name: (fd, peer) => guard(() => json({ op: "sock-name", fd: kfd(fd), peer })),
-    getopt: (fd, level, name) => guard(() => ({ value: json({ op: "sock-getopt", fd: kfd(fd), level, name }) })),
-    setopt: (fd, level, name, value2) => guard(() => done({ op: "sock-setopt", fd: kfd(fd), level, name, value: value2 })),
-    resolve: (name, family = 4) => guard(() => json({ op: "sock-resolve", name, family })),
+    getopt: (fd, level, name2) => guard(() => ({ value: json({ op: "sock-getopt", fd: kfd(fd), level, name: name2 }) })),
+    setopt: (fd, level, name2, value2) => guard(() => done({ op: "sock-setopt", fd: kfd(fd), level, name: name2, value: value2 })),
+    resolve: (name2, family = 4) => guard(() => json({ op: "sock-resolve", name: name2, family })),
     send: (fd, bytes, flags) => guard(() => {
       const stream = socketAt(fd);
       const nonblock = flags.dontwait === true || (stream.flags & O_NONBLOCK) !== 0;
@@ -3501,8 +3501,8 @@ var init_cred = __esm({
 // src/process/procfs.ts
 function commOf(info) {
-  const name = info.argv[0] ?? "";
-  return name.slice(name.lastIndexOf("/") + 1).slice(0, 15);
+  const name2 = info.argv[0] ?? "";
+  return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
 }
 function ttyNumber(tty) {
   const pts = tty && /^\/dev\/pts\/(\d+)$/.exec(tty);
@@ -3589,12 +3589,12 @@ function pidStatus(info) {
     ""
   ].join("\n");
 }
-function pidFile(name, info, boot) {
-  if (name === "cmdline") return info.state === "Z" ? "" : `${info.argv.join("\0")}\0`;
-  if (name === "comm") return `${commOf(info)}
+function pidFile(name2, info, boot) {
+  if (name2 === "cmdline") return info.state === "Z" ? "" : `${info.argv.join("\0")}\0`;
+  if (name2 === "comm") return `${commOf(info)}
 `;
-  if (name === "stat") return pidStat(info, boot);
-  if (name === "statm") {
+  if (name2 === "stat") return pidStat(info, boot);
+  if (name2 === "statm") {
     const p = pages(info.memory);
     return `${p} ${p} 0 0 0 ${p} 0
 `;
@@ -3618,18 +3618,18 @@ function memoryInfo(source, used = 0) {
     ["SwapFree", kb(0)]
   ].map(([key, value2]) => `${`${key}:`.padEnd(16)}${value2.padStart(12)}`).concat("").join("\n");
 }
-function systemFile(name, listing, now, memory) {
+function systemFile(name2, listing, now, memory) {
   const up = Math.max(0, now - listing.boot) / 1e3;
-  if (name === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
+  if (name2 === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
 `;
-  if (name === "meminfo") {
+  if (name2 === "meminfo") {
     return memoryInfo(
       memory,
       listing.processes.reduce((sum, p) => sum + p.memory, 0)
     );
   }
   const live = listing.processes.filter((p) => p.state !== "Z");
-  if (name === "loadavg") {
+  if (name2 === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
     return `0.00 0.00 0.00 1/${live.length} ${last}
 `;
@@ -3688,8 +3688,8 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     return;
   }
   const error = (errno2 = ENOENT) => new Fs.ErrnoError(errno2);
-  const fresh = (parent, name, mode) => {
-    const node = createNode.call(Fs, parent, name, mode, 0);
+  const fresh = (parent, name2, mode) => {
+    const node = createNode.call(Fs, parent, name2, mode, 0);
     hashRemoveNode.call(Fs, node);
     node.node_ops = { getattr: attr, setattr: () => {
     } };
@@ -3702,8 +3702,8 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     };
     return node;
   };
-  const file = (parent, name, content) => {
-    const node = fresh(parent, name, FILE_MODE);
+  const file = (parent, name2, content) => {
+    const node = fresh(parent, name2, FILE_MODE);
     node.stream_ops = {
       open: (stream) => {
         stream.sliccProc = new TextEncoder().encode(content());
@@ -3725,15 +3725,15 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
   };
   const find = (processes2, target, own) => (own ? processes2.find((p) => p.tid === target) : void 0) ?? processes2.find((p) => p.pid === target || p.tid === target);
   const infoOf = (target) => find(procList().processes, target, false);
-  const pidContent = (target, name, own = false) => () => {
+  const pidContent = (target, name2, own = false) => () => {
     const listing = procList();
     const info = find(listing.processes, target, own);
     if (!info) throw error(ESRCH);
-    return pidFile(name, info, listing.boot);
+    return pidFile(name2, info, listing.boot);
   };
   const pidNames = (names) => [.../* @__PURE__ */ new Set([...names, ...PID_FILES])];
-  const pidDir = (name, target) => {
-    const dir = fresh(proc, name, DIR_MODE2);
+  const pidDir = (name2, target) => {
+    const dir = fresh(proc, name2, DIR_MODE2);
     dir.node_ops.lookup = (parent, child) => {
       if (!PID_FILES.includes(child)) throw error();
       return file(parent, child, pidContent(target, child));
@@ -3746,25 +3746,25 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
   const readdir = procOps.readdir?.bind(procOps);
   proc.node_ops = {
     ...procOps,
-    lookup: (parent, name) => {
-      if (/^[1-9]\d*$/.test(name)) {
-        if (!infoOf(Number(name))) throw error();
-        return pidDir(name, Number(name));
+    lookup: (parent, name2) => {
+      if (/^[1-9]\d*$/.test(name2)) {
+        if (!infoOf(Number(name2))) throw error();
+        return pidDir(name2, Number(name2));
       }
-      if (name === "mounts") return file(parent, name, () => mountTable(sys.mountList?.() ?? []));
-      if (SYSTEM_FILES.includes(name)) {
+      if (name2 === "mounts") return file(parent, name2, () => mountTable(sys.mountList?.() ?? []));
+      if (SYSTEM_FILES.includes(name2)) {
         return file(
           parent,
-          name,
-          () => systemFile(name, procList(), Date.now(), memory)
+          name2,
+          () => systemFile(name2, procList(), Date.now(), memory)
         );
       }
       if (!lookup) throw error();
-      return lookup(parent, name);
+      return lookup(parent, name2);
     },
     readdir: (node) => {
       const names = new Set(readdir ? readdir(node) : [".", ".."]);
-      for (const name of [...SYSTEM_FILES, "mounts"]) names.add(name);
+      for (const name2 of [...SYSTEM_FILES, "mounts"]) names.add(name2);
       for (const p of procList().processes) names.add(String(p.pid));
       return [...names];
     }
@@ -3774,18 +3774,18 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
   const shownPid = () => String(find(procList().processes, pid, true)?.pid ?? pid);
   link.node_ops.readlink = shownPid;
   const procLookup = proc.node_ops.lookup;
-  proc.node_ops.lookup = (parent, name) => name === "self" ? link : name === shownPid() ? self : procLookup(parent, name);
+  proc.node_ops.lookup = (parent, name2) => name2 === "self" ? link : name2 === shownPid() ? self : procLookup(parent, name2);
   const selfOps = self.node_ops;
   const selfLookup = selfOps.lookup?.bind(selfOps);
   const selfReaddir = selfOps.readdir?.bind(selfOps);
   self.node_ops = {
     ...selfOps,
-    lookup: (parent, name) => {
-      if (PID_FILES.includes(name)) {
-        return file(parent, name, pidContent(pid, name, true));
+    lookup: (parent, name2) => {
+      if (PID_FILES.includes(name2)) {
+        return file(parent, name2, pidContent(pid, name2, true));
       }
       if (!selfLookup) throw error();
-      return selfLookup(parent, name);
+      return selfLookup(parent, name2);
     },
     readdir: (node) => pidNames(selfReaddir ? selfReaddir(node) : [".", ".."])
   };
@@ -3920,9 +3920,9 @@ function kernelSys(transport) {
     ttyNames() {
       return json(call2({ op: "fd-tty-names" }, "fd-tty-names"));
     },
-    openTty(name) {
-      const req = name === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name };
-      return json(call2(req, `fd-open-tty ${name ?? ""}`));
+    openTty(name2) {
+      const req = name2 === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name: name2 };
+      return json(call2(req, `fd-open-tty ${name2 ?? ""}`));
     },
     tcgets(fd) {
       return json(call2({ op: "tty-get", fd }, `tty-get ${fd}`));
@@ -4013,8 +4013,8 @@ function wireKernelStdio(Fs, streams, sys) {
 function glueBody(glue) {
   return glue.startsWith("#!") ? glue.slice(glue.indexOf("\n") + 1) : glue;
 }
-function ownValue(module, name) {
-  const own = Object.getOwnPropertyDescriptor(module, name);
+function ownValue(module, name2) {
+  const own = Object.getOwnPropertyDescriptor(module, name2);
   return own && "value" in own ? own.value : void 0;
 }
 function identify(transport, init) {
@@ -4342,11 +4342,66 @@ var init_process_runtime = __esm({
   }
 });
+// src/fs/physical-path.ts
+function start(path) {
+  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
+}
+function next(walk) {
+  while (walk.todo.length > 0) {
+    const part = walk.todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      walk.done.pop();
+      continue;
+    }
+    return part;
+  }
+  return void 0;
+}
+function lexical(path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
+  return `/${walk.done.join("/")}`;
+}
+function rest(walk, part) {
+  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
+}
+function follow(walk, target) {
+  if (++walk.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk.done.length = 0;
+  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+  return true;
+}
+function physicalPath(fs, path) {
+  const walk = start(path);
+  for (let part = next(walk); part !== void 0; part = next(walk)) {
+    const at = `/${[...walk.done, part].join("/")}`;
+    let target;
+    try {
+      target = fs.lstat(at).isSymbolicLink ? fs.readlink(at) : void 0;
+    } catch {
+      return rest(walk, part);
+    }
+    if (target === void 0) walk.done.push(part);
+    else if (!follow(walk, target)) {
+      throw Object.assign(new Error("too many levels of symbolic links"), { code: "ELOOP" });
+    }
+  }
+  return `/${walk.done.join("/")}`;
+}
+var MAX_HOPS;
+var init_physical_path = __esm({
+  "src/fs/physical-path.ts"() {
+    "use strict";
+    MAX_HOPS = 40;
+  }
+});
 // src/process/wasi/dylink.ts
 function dylinkInfo(module) {
-  const [section] = WebAssembly.Module.customSections(module, "dylink.0");
-  if (!section) return void 0;
-  const bytes = new Uint8Array(section);
+  const [section2] = WebAssembly.Module.customSections(module, "dylink.0");
+  if (!section2) return void 0;
+  const bytes = new Uint8Array(section2);
   let at = 0;
   const uleb = () => {
     let value2 = 0;
@@ -4454,10 +4509,10 @@ function cachingBridge(bridge, now = () => performance.now()) {
     readdirStat: (p) => {
       const list = bridge.readdirStat(p);
       const base = p === "/" ? "" : p;
-      for (const [name, st] of list) {
+      for (const [name2, st] of list) {
         if (!st) continue;
-        lstats.set(`${base}/${name}`, st);
-        if (!st.isSymbolicLink) stats.set(`${base}/${name}`, st);
+        lstats.set(`${base}/${name2}`, st);
+        if (!st.isSymbolicLink) stats.set(`${base}/${name2}`, st);
       }
       return list;
     },
@@ -4715,6 +4770,10 @@ function kernelEntry2() {
 function deviceEntry(meta) {
   return { type: "device", device: meta.device, ...meta.access ? { access: meta.access } : {} };
 }
+function refuseWrite(s, oflags, rights) {
+  const writes = (rights & RIGHTS.FD_WRITE) !== 0n || (oflags & OFLAGS.TRUNC) !== 0;
+  if (s?.readonly && writes) throw new WasiError("EROFS");
+}
 function preopenOf(e) {
   return {
     ...e.preopen ? { preopen: e.preopen } : {},
@@ -4822,8 +4881,8 @@ var init_wasi_fds = __esm({
         } catch {
           return out;
         }
-        for (const name of [.../* @__PURE__ */ new Set([...names, "dev", ...SYNTHETIC_DIRS2])].sort()) {
-          const path = `/${name}`;
+        for (const name2 of [.../* @__PURE__ */ new Set([...names, "dev", ...SYNTHETIC_DIRS2])].sort()) {
+          const path = `/${name2}`;
           if (path === "/dev") {
             out.push({ type: "dir", path, preopen: path });
             continue;
@@ -5182,6 +5241,7 @@ var init_wasi_fds = __esm({
           return this.install({ type: "dir", path });
         }
         if (!s && !(oflags & OFLAGS.CREAT)) throw new WasiError("ENOENT");
+        refuseWrite(s, oflags, rights);
         if (this.shared) return this.kernelFile(path, s, oflags, rights, fdflags);
         return this.install({ type: "file", file: this.file(path, s, oflags, rights, fdflags) });
       }
@@ -5559,8 +5619,8 @@ function kernelFiletype(kind) {
       return { filetype: FILETYPE.UNKNOWN, seeks: false };
   }
 }
-function direntRecord(next2, ino, name, filetype) {
-  const nameBytes = new TextEncoder().encode(name);
+function direntRecord(next2, ino, name2, filetype) {
+  const nameBytes = new TextEncoder().encode(name2);
   const record = new Uint8Array(SIZE.DIRENT + nameBytes.length);
   const v = new DataView(record.buffer);
   v.setBigUint64(0, BigInt(next2), true);
@@ -5572,8 +5632,8 @@ function direntRecord(next2, ino, name, filetype) {
 }
 function wrap(table) {
   const out = {};
-  for (const [name, fn] of Object.entries(table)) {
-    out[name] = (...args) => {
+  for (const [name2, fn] of Object.entries(table)) {
+    out[name2] = (...args) => {
       try {
         return fn(...args) ?? E.SUCCESS;
       } catch (e) {
@@ -5634,8 +5694,8 @@ var init_wasi_host = __esm({
           return kernel.call(req);
         };
         const sys = new Proxy(kernel.sys, {
-          get: (target, name) => {
-            const member = Reflect.get(target, name);
+          get: (target, name2) => {
+            const member = Reflect.get(target, name2);
             if (typeof member !== "function") return member;
             return (...args) => {
               this.fds.flushEarly();
@@ -5863,13 +5923,13 @@ var init_wasi_host = __esm({
             } else if (e.type === "dir") this.setTimes(e.path, atim, mtim, flags);
           },
           fd_prestat_get: (fd, out) => {
-            const name = new TextEncoder().encode(fds.preopen(fd).preopen);
+            const name2 = new TextEncoder().encode(fds.preopen(fd).preopen);
             mem.view().setUint8(out, PREOPENTYPE_DIR);
-            mem.view().setUint32(out + 4, name.length, true);
+            mem.view().setUint32(out + 4, name2.length, true);
           },
           fd_prestat_dir_name: (fd, buf, len) => {
-            const name = new TextEncoder().encode(fds.preopen(fd).preopen);
-            mem.bytes(buf, Math.min(len, name.length)).set(name.subarray(0, len));
+            const name2 = new TextEncoder().encode(fds.preopen(fd).preopen);
+            mem.bytes(buf, Math.min(len, name2.length)).set(name2.subarray(0, len));
           },
           fd_readdir: (fd, buf, len, cookie, used) => void this.readdir(fd, buf, len, Number(cookie), used)
         };
@@ -6148,14 +6208,14 @@ var init_wasi_host = __esm({
         const { names, stats } = dir.listing;
         let at = 0;
         for (let i = cookie; i < names.length && at < len; i++) {
-          const name = names[i];
-          const full = name === "." ? dir.path : name === ".." ? normalize(`${dir.path}/..`) : resolveUnder(dir.path, name);
-          if (!stats.has(name)) stats.set(name, this.lstatOrNull(full));
-          const st = stats.get(name) ?? null;
+          const name2 = names[i];
+          const full = name2 === "." ? dir.path : name2 === ".." ? normalize(`${dir.path}/..`) : resolveUnder(dir.path, name2);
+          if (!stats.has(name2)) stats.set(name2, this.lstatOrNull(full));
+          const st = stats.get(name2) ?? null;
           const record = direntRecord(
             i + 1,
             st?.ino !== void 0 ? BigInt(st.ino) : pathInode(full),
-            name,
+            name2,
             filetypeOf(st)
           );
           const n = Math.min(record.length, len - at);
@@ -6167,7 +6227,7 @@ var init_wasi_host = __esm({
       list(path) {
         const { fs } = this.o;
         const listed = fs.readdirStat(path);
-        return { names: [".", "..", ...listed.map(([name]) => name)], stats: new Map(listed) };
+        return { names: [".", "..", ...listed.map(([name2]) => name2)], stats: new Map(listed) };
       }
       lstatOrNull(path) {
         try {
@@ -6253,61 +6313,6 @@ var init_wasi_threads = __esm({
   }
 });
-// src/fs/physical-path.ts
-function start(path) {
-  return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
-}
-function next(walk) {
-  while (walk.todo.length > 0) {
-    const part = walk.todo.shift();
-    if (part === ".") continue;
-    if (part === "..") {
-      walk.done.pop();
-      continue;
-    }
-    return part;
-  }
-  return void 0;
-}
-function lexical(path) {
-  const walk = start(path);
-  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
-  return `/${walk.done.join("/")}`;
-}
-function rest(walk, part) {
-  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
-}
-function follow(walk, target) {
-  if (++walk.hops > MAX_HOPS) return false;
-  if (target.startsWith("/")) walk.done.length = 0;
-  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
-  return true;
-}
-function physicalPath(fs, path) {
-  const walk = start(path);
-  for (let part = next(walk); part !== void 0; part = next(walk)) {
-    const at = `/${[...walk.done, part].join("/")}`;
-    let target;
-    try {
-      target = fs.lstat(at).isSymbolicLink ? fs.readlink(at) : void 0;
-    } catch {
-      return rest(walk, part);
-    }
-    if (target === void 0) walk.done.push(part);
-    else if (!follow(walk, target)) {
-      throw Object.assign(new Error("too many levels of symbolic links"), { code: "ELOOP" });
-    }
-  }
-  return `/${walk.done.join("/")}`;
-}
-var MAX_HOPS;
-var init_physical_path = __esm({
-  "src/fs/physical-path.ts"() {
-    "use strict";
-    MAX_HOPS = 40;
-  }
-});
 // src/process/wasi/wasix-process.ts
 function restarted2(issue) {
   for (; ; ) {
@@ -6354,18 +6359,18 @@ var init_wasix_process = __esm({
       environment() {
         return { ...this.host.o.env, PWD: this.host.cwd };
       }
-      locate(name, search, path) {
-        if (name.includes("/"))
-          return name.startsWith("/") ? name : normalize(`${this.host.cwd}/${name}`);
-        if (!search) return name;
+      locate(name2, search, path) {
+        if (name2.includes("/"))
+          return name2.startsWith("/") ? name2 : normalize(`${this.host.cwd}/${name2}`);
+        if (!search) return name2;
         for (const dir of path.split(":")) {
           if (!dir) continue;
           const candidate = normalize(
-            `${dir.startsWith("/") ? "" : `${this.host.cwd}/`}${dir}/${name}`
+            `${dir.startsWith("/") ? "" : `${this.host.cwd}/`}${dir}/${name2}`
           );
           if (this.host.o.fs.exists(candidate)) return candidate;
         }
-        return name;
+        return name2;
       }
       childFds(ops) {
         const { fds } = this.host;
@@ -6680,7 +6685,7 @@ function processes(host, call2, inThread) {
       const theirs = [];
       host.fds.promoteFiles();
       try {
-        const stdio = STDIO.map((name, n) => slot(n, o[name] ?? "inherit", mine, theirs));
+        const stdio = STDIO.map((name2, n) => slot(n, o[name2] ?? "inherit", mine, theirs));
         const req = {
           op: "proc-spawn",
           file: o.argv[0],
@@ -6692,8 +6697,8 @@ function processes(host, call2, inThread) {
         };
         const pid = restarted2(() => call2(req));
         const out = { pid };
-        STDIO.forEach((name, n) => {
-          if (mine[n] !== void 0) out[name] = mine[n];
+        STDIO.forEach((name2, n) => {
+          if (mine[n] !== void 0) out[name2] = mine[n];
         });
         return out;
       } catch (err) {
@@ -6748,6 +6753,191 @@ var init_wasi_module = __esm({
   }
 });
+// src/process/wasi/wasi-procfs.ts
+function inProc(path) {
+  return path === "/proc" || path.startsWith("/proc/");
+}
+function procfsBridge(fs, tree) {
+  const over = {
+    readFile: (p) => inProc(p) ? tree.read(p) : fs.readFile(p),
+    stat: (p) => inProc(p) ? tree.stat(p) : fs.stat(p),
+    lstat: (p) => inProc(p) ? tree.stat(p, false) : fs.lstat(p),
+    readdir: (p) => {
+      if (inProc(p)) return tree.readdir(p);
+      const names = fs.readdir(p);
+      return p === "/" && !names.includes("proc") ? [...names, "proc"] : names;
+    },
+    exists: (p) => inProc(p) ? tree.exists(p) : fs.exists(p),
+    readlink: (p) => inProc(p) ? tree.readlink(p) : fs.readlink(p),
+    readdirStat: (p) => {
+      if (!inProc(p)) {
+        const listed = fs.readdirStat(p);
+        if (p !== "/" || listed.some(([name2]) => name2 === "proc")) return listed;
+        return [...listed, ["proc", tree.stat("/proc")]];
+      }
+      return tree.readdir(p).map((name2) => {
+        try {
+          return [name2, tree.stat(`${p}/${name2}`, false)];
+        } catch {
+          return [name2, null];
+        }
+      });
+    },
+    rename: (from, to) => {
+      if (inProc(from) || inProc(to)) throw syncError("EROFS", from);
+      fs.rename(from, to);
+    },
+    hold: (p, ...rest2) => inProc(p) ? void 0 : fs.hold?.(p, ...rest2),
+    ...fs.pread ? {
+      pread: (p, at, n, version) => inProc(p) ? tree.read(p).subarray(at, at + n) : fs.pread(p, at, n, version)
+    } : {}
+  };
+  for (const name2 of READ_ONLY) {
+    const fn = fs[name2];
+    if (!fn) continue;
+    over[name2] = (p, ...rest2) => {
+      if (inProc(p)) throw syncError("EROFS", p);
+      return fn.call(fs, p, ...rest2);
+    };
+  }
+  return new Proxy(fs, {
+    get: (target, key, receiver) => key in over ? over[key] : Reflect.get(target, key, receiver)
+  });
+}
+var DIR_MODE3, FILE_MODE2, LINK_MODE3, PID_NAMES, SYSTEM_NAMES, ProcTree, READ_ONLY;
+var init_wasi_procfs = __esm({
+  "src/process/wasi/wasi-procfs.ts"() {
+    "use strict";
+    init_sync_fs_wire();
+    init_process_fds();
+    init_procfs();
+    DIR_MODE3 = 16749;
+    FILE_MODE2 = 33060;
+    LINK_MODE3 = 41471;
+    PID_NAMES = PID_FILES;
+    SYSTEM_NAMES = SYSTEM_FILES;
+    ProcTree = class {
+      source;
+      pid;
+      memory;
+      constructor(source, pid, memory = memorySource()) {
+        this.source = source;
+        this.pid = pid;
+        this.memory = memory;
+      }
+      listing() {
+        return this.source.procList();
+      }
+      alive(pid) {
+        return this.listing().processes.some((p) => p.pid === pid);
+      }
+      node(parts) {
+        const [top, leaf, ...rest2] = parts;
+        if (top === void 0) {
+          return {
+            kind: "dir",
+            names: () => [
+              ...SYSTEM_NAMES,
+              "mounts",
+              "self",
+              ...this.listing().processes.map((p) => String(p.pid))
+            ]
+          };
+        }
+        if (top === "self") {
+          return leaf === void 0 ? { kind: "link", target: String(this.pid) } : void 0;
+        }
+        if (leaf === void 0 && top === "mounts") {
+          return { kind: "file", content: () => mountTable(this.source.mountList()) };
+        }
+        if (leaf === void 0 && SYSTEM_NAMES.includes(top)) {
+          return {
+            kind: "file",
+            content: () => systemFile(top, this.listing(), Date.now(), this.memory)
+          };
+        }
+        if (!/^[1-9]\d*$/.test(top) || rest2.length > 0 || !this.alive(Number(top))) return void 0;
+        if (leaf === void 0) return { kind: "dir", names: () => [...PID_NAMES] };
+        if (!PID_NAMES.includes(leaf)) return void 0;
+        return {
+          kind: "file",
+          content: () => {
+            const listing = this.listing();
+            const info = listing.processes.find((p) => p.pid === Number(top));
+            if (!info) throw syncError("ENOENT", `/proc/${top}/${leaf}`);
+            return pidFile(leaf, info, listing.boot);
+          }
+        };
+      }
+      parts(path, follow2) {
+        const parts = path.split("/").filter((p) => p !== "").slice(1);
+        if (parts[0] === "self" && (follow2 || parts.length > 1)) parts[0] = String(this.pid);
+        return parts;
+      }
+      find(path, follow2) {
+        const node = this.node(this.parts(path, follow2));
+        if (!node) throw syncError("ENOENT", path);
+        return node;
+      }
+      stat(path, follow2 = true) {
+        const node = this.find(path, follow2);
+        const base = {
+          isFile: false,
+          isDirectory: false,
+          size: 0,
+          mtimeMs: Date.now(),
+          readonly: true
+        };
+        if (node.kind === "dir") return { ...base, isDirectory: true, mode: DIR_MODE3 };
+        if (node.kind === "link") {
+          return { ...base, isSymbolicLink: true, mode: LINK_MODE3, size: node.target.length };
+        }
+        return { ...base, isFile: true, mode: FILE_MODE2, size: this.bytes(node).length };
+      }
+      bytes(node) {
+        return new TextEncoder().encode(node.kind === "file" ? node.content() : "");
+      }
+      read(path) {
+        const node = this.find(path, true);
+        if (node.kind !== "file") throw syncError("EISDIR", path);
+        return this.bytes(node);
+      }
+      readdir(path) {
+        const node = this.find(path, true);
+        if (node.kind !== "dir") throw syncError("ENOTDIR", path);
+        return node.names();
+      }
+      readlink(path) {
+        const node = this.find(path, false);
+        if (node.kind !== "link") throw syncError("EINVAL", path);
+        return node.target;
+      }
+      exists(path) {
+        try {
+          this.find(path, true);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    };
+    READ_ONLY = [
+      "writeFile",
+      "mkdir",
+      "rm",
+      "unlink",
+      "rmdir",
+      "symlink",
+      "chmod",
+      "utimes",
+      "lutimes",
+      "create",
+      "pwrite",
+      "truncate"
+    ];
+  }
+});
 // src/process/wasi/wasi-signals.ts
 var DELIVERED_MASK, KERNEL_DEFAULTS, LIBC_DEFAULT_EXIT, SA_RESTART, DISPOSITION_IGNORE, DISPOSITION_HANDLER, withBit, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
 var init_wasi_signals = __esm({
@@ -6788,8 +6978,8 @@ var init_wasi_signals = __esm({
       bind(exports) {
         this.exports = exports;
       }
-      register(name) {
-        if (typeof this.exports?.[name] === "function") this.callback = name;
+      register(name2) {
+        if (typeof this.exports?.[name2] === "function") this.callback = name2;
       }
       useHook() {
         this.hooked = true;
@@ -6886,11 +7076,11 @@ var init_wasi_stats = __esm({
       mark = performance.now();
       wrap(tag, table) {
         return Object.fromEntries(
-          Object.entries(table).map(([name, value2]) => {
-            if (typeof value2 !== "function") return [name, value2];
+          Object.entries(table).map(([name2, value2]) => {
+            if (typeof value2 !== "function") return [name2, value2];
             const fn = value2;
-            const key = `${tag}.${name}`;
-            return [name, (...args) => this.time(key, () => fn.apply(table, args))];
+            const key = `${tag}.${name2}`;
+            return [name2, (...args) => this.time(key, () => fn.apply(table, args))];
           })
         );
       }
@@ -6902,9 +7092,9 @@ var init_wasi_stats = __esm({
           this.count(key, performance.now() - t);
         }
       }
-      phase(name) {
+      phase(name2) {
         const now = performance.now();
-        this.phases.push([name, now - this.mark]);
+        this.phases.push([name2, now - this.mark]);
         this.mark = now;
       }
       count(key, ms) {
@@ -6916,7 +7106,7 @@ var init_wasi_stats = __esm({
       }
       report() {
         const ms = (v) => v.toFixed(1).padStart(9);
-        const lines = this.phases.map(([name, t]) => `${ms(t)} ms  ${name}`);
+        const lines = this.phases.map(([name2, t]) => `${ms(t)} ms  ${name2}`);
         lines.push(`${"total ms".padStart(12)} ${"calls".padStart(7)} ${"max ms".padStart(9)}  call`);
         const sorted = [...this.rows].sort((a, b) => b[1].ms - a[1].ms);
         for (const [key, row] of sorted) {
@@ -6932,12 +7122,12 @@ var init_wasi_stats = __esm({
 // src/process/wasi/wasix-fork.ts
 function mutableGlobals(exports) {
   const out = [];
-  for (const [name, value2] of Object.entries(exports)) {
+  for (const [name2, value2] of Object.entries(exports)) {
     if (!(value2 instanceof WebAssembly.Global) || typeof value2.value !== "number") continue;
     try {
       const v = value2.value;
       value2.value = v;
-      out.push([name, v]);
+      out.push([name2, v]);
     } catch {
     }
   }
@@ -7047,8 +7237,8 @@ var init_wasix_fork = __esm({
         return E.SUCCESS;
       }
       restoreGlobals(globals) {
-        for (const [name, value2] of globals) {
-          const g = this.exports[name];
+        for (const [name2, value2] of globals) {
+          const g = this.exports[name2];
           if (g instanceof WebAssembly.Global) g.value = value2;
         }
       }
@@ -7118,6 +7308,173 @@ var init_wasix_ffi = __esm({
   }
 });
+// src/process/wasi/wasix-trampoline.ts
+function valueTypes(codes) {
+  const out = [];
+  for (const code2 of codes) {
+    const type = CODES[code2];
+    if (!type) return void 0;
+    out.push(type);
+  }
+  return out;
+}
+function u32(n) {
+  const out = [];
+  let v = n >>> 0;
+  do {
+    let b = v & 127;
+    v >>>= 7;
+    if (v) b |= 128;
+    out.push(b);
+  } while (v);
+  return out;
+}
+function s32(n) {
+  const out = [];
+  let v = n | 0;
+  for (; ; ) {
+    const b = v & 127;
+    v >>= 7;
+    if (v === 0 && !(b & 64) || v === -1 && b & 64) {
+      out.push(b);
+      return out;
+    }
+    out.push(b | 128);
+  }
+}
+function name(s) {
+  const bytes = [...new TextEncoder().encode(s)];
+  return [...u32(bytes.length), ...bytes];
+}
+function section(id, body) {
+  return [id, ...u32(body.length), ...body];
+}
+function vec(items) {
+  return [...u32(items.length), ...items.flat()];
+}
+function align16(n) {
+  return Math.ceil(n / 16) * 16;
+}
+function trampolineBytes(params, results, shared) {
+  const sig = [
+    96,
+    ...vec(params.map((t) => [VALTYPE[t]])),
+    ...vec(results.map((t) => [VALTYPE[t]]))
+  ];
+  const backing = [96, ...vec([[127], [127], [127]]), ...vec([])];
+  const memory = shared ? [3, 0, ...u32(65536)] : [0, 0];
+  const imports = vec([
+    [...name("env"), ...name("memory"), 2, ...memory],
+    [...name("env"), ...name("__indirect_function_table"), 1, 112, 0, 0],
+    [...name("env"), ...name("__stack_pointer"), 3, 127, 1],
+    [...name("env"), ...name("backing"), 3, 127, 0],
+    [...name("env"), ...name("user_data"), 3, 127, 0]
+  ]);
+  const n = params.length;
+  const [orig, args, res] = [n, n + 1, n + 2];
+  const valuesSize = align16(params.reduce((sum, t) => sum + SIZE3[t], 0));
+  const resultsSize = align16(results.reduce((sum, t) => sum + SIZE3[t], 0));
+  const body = [
+    35,
+    0,
+    34,
+    ...u32(orig),
+    65,
+    ...s32(resultsSize),
+    107,
+    34,
+    ...u32(res)
+  ];
+  body.push(65, ...s32(valuesSize), 107, 34, ...u32(args), 36, 0);
+  let at = 0;
+  params.forEach((t, i) => {
+    body.push(32, ...u32(args), 32, ...u32(i), ...STORE[t], 0, ...u32(at));
+    at += SIZE3[t];
+  });
+  body.push(32, ...u32(args), 32, ...u32(res), 35, 2, 35, 1, 17, 1, 0);
+  at = 0;
+  for (const t of results) {
+    body.push(32, ...u32(res), ...LOAD[t], 0, ...u32(at));
+    at += SIZE3[t];
+  }
+  body.push(32, ...u32(orig), 36, 0, 11);
+  const func = [...vec([[...u32(3), 127]]), ...body];
+  return Uint8Array.from([
+    0,
+    97,
+    115,
+    109,
+    1,
+    0,
+    0,
+    0,
+    ...section(1, vec([sig, backing])),
+    ...section(2, imports),
+    ...section(3, vec([[0]])),
+    ...section(7, vec([[...name("t"), 0, 0]])),
+    ...section(10, vec([[...u32(func.length), ...func]]))
+  ]);
+}
+var CODES, VALTYPE, SIZE3, STORE, LOAD, Trampolines;
+var init_wasix_trampoline = __esm({
+  "src/process/wasi/wasix-trampoline.ts"() {
+    "use strict";
+    CODES = ["i32", "i64", "f32", "f64", "v128"];
+    VALTYPE = {
+      i32: 127,
+      i64: 126,
+      f32: 125,
+      f64: 124,
+      v128: 123
+    };
+    SIZE3 = { i32: 4, i64: 8, f32: 4, f64: 8, v128: 16 };
+    STORE = {
+      i32: [54],
+      i64: [55],
+      f32: [56],
+      f64: [57],
+      v128: [253, 11]
+    };
+    LOAD = {
+      i32: [40],
+      i64: [41],
+      f32: [42],
+      f64: [43],
+      v128: [253, 0]
+    };
+    Trampolines = class {
+      modules = /* @__PURE__ */ new Map();
+      get compiled() {
+        return this.modules.size;
+      }
+      make(params, results, env) {
+        const shared = env.memory.buffer instanceof SharedArrayBuffer;
+        const key = `${params.join(",")}>${results.join(",")}${shared ? "s" : ""}`;
+        let module = this.modules.get(key);
+        if (!module) {
+          module = new WebAssembly.Module(trampolineBytes(params, results, shared));
+          this.modules.set(key, module);
+        }
+        const i32 = (v) => new WebAssembly.Global({ value: "i32", mutable: false }, v);
+        const instance = new WebAssembly.Instance(module, {
+          env: {
+            memory: env.memory,
+            __indirect_function_table: env.table,
+            __stack_pointer: env.stackPointer,
+            backing: i32(env.backing),
+            user_data: i32(env.userData)
+          }
+        });
+        const sig = {
+          params: params.map((t) => t === "v128" ? "other" : t),
+          results: results.map((t) => t === "v128" ? "other" : t)
+        };
+        return { fn: instance.exports.t, sig };
+      }
+    };
+  }
+});
 // src/process/wasi/wasm-functypes.ts
 function readTypes(r, s) {
   for (let i = r.u32(); i > 0; i--) {
@@ -7186,10 +7543,10 @@ function readGlobals(r, s) {
 }
 function readExports(r, s) {
   for (let i = r.u32(); i > 0; i--) {
-    const name = r.name();
+    const name2 = r.name();
     const kind = r.byte();
     const index2 = r.u32();
-    if (kind === 0) s.info.exports[name] = index2;
+    if (kind === 0) s.info.exports[name2] = index2;
   }
 }
 function readElems(r, s) {
@@ -7309,8 +7666,8 @@ var init_wasm_functypes = __esm({
       }
       add(info, instance, table, tableBase) {
         const sig = (func) => info.sigs[info.funcs[func] ?? -1];
-        for (const [name, func] of Object.entries(info.exports)) {
-          const fn = instance.exports[name];
+        for (const [name2, func] of Object.entries(info.exports)) {
+          const fn = instance.exports[name2];
           const type = sig(func);
           if (typeof fn === "function" && type) this.known.set(fn, type);
         }
@@ -7353,8 +7710,8 @@ function growTo(memory, bytes) {
 function growTable(table, length) {
   if (table.length < length) table.grow(length - table.length);
 }
-function call(instance, name) {
-  const fn = instance.exports[name];
+function call(instance, name2) {
+  const fn = instance.exports[name2];
   if (typeof fn === "function") fn();
 }
 var TABLE_BASE2, PAGE2, STACK_SIZE, LIBRARY_DIRS, DlError, WasixLinker;
@@ -7363,6 +7720,7 @@ var init_wasix_linker = __esm({
     "use strict";
     init_dylink();
     init_wasi_files();
+    init_wasix_trampoline();
     init_wasm_functypes();
     TABLE_BASE2 = 1;
     PAGE2 = 65536;
@@ -7387,6 +7745,7 @@ var init_wasix_linker = __esm({
       publisher;
       indices;
       types = new FuncTypes();
+      trampolines = new Trampolines();
       memory;
       host;
       constructor(memory, mainInfo, host, thread = false) {
@@ -7450,16 +7809,25 @@ var init_wasix_linker = __esm({
         this.main = instance;
         if (relocate) call(instance, "__wasm_apply_data_relocs");
       }
-      open(name, cwd, ldPath) {
-        return this.load(this.locate(name, cwd, ldPath), cwd, ldPath).handle;
-      }
-      symbol(handle, name) {
-        const found = handle === 0 ? this.find(name) : this.findIn(this.module(handle), name, /* @__PURE__ */ new Set());
-        if (!found) throw new DlError(`undefined symbol: ${name}`);
+      mainPath;
+      isMain(path) {
+        if (this.mainPath === void 0) return false;
+        if (path === this.mainPath) return true;
+        const real = this.host.real;
+        return real !== void 0 && real(path) === real(this.mainPath);
+      }
+      open(name2, cwd, ldPath) {
+        const path = this.locate(name2, cwd, ldPath);
+        if (this.isMain(path)) return 0;
+        return this.load(path, cwd, ldPath).handle;
+      }
+      symbol(handle, name2) {
+        const found = handle === 0 ? this.find(name2) : this.findIn(this.module(handle), name2, /* @__PURE__ */ new Set());
+        if (!found) throw new DlError(`undefined symbol: ${name2}`);
         const [owner, value2] = found;
-        if (typeof value2 === "function") return this.slot(value2, owner, name);
+        if (typeof value2 === "function") return this.slot(value2, owner, name2);
         if (value2 instanceof WebAssembly.Global) return this.baseOf(owner) + value2.value;
-        throw new DlError(`${name} is neither a function nor data`);
+        throw new DlError(`${name2} is neither a function nor data`);
       }
       invalid(handle) {
         return !this.modules.has(handle);
@@ -7479,6 +7847,25 @@ var init_wasix_linker = __esm({
         this.indices?.free(index2);
         this.table.set(index2, null);
       }
+      prepareClosure(record) {
+        if (record.index >= this.table.length)
+          throw new DlError(`closure ${record.index}: no such slot`);
+        const full = { kind: "closure-prepare", ...record };
+        this.install(full);
+        this.publisher?.(full);
+      }
+      install(record) {
+        growTable(this.table, record.index + 1);
+        const { fn, sig } = this.trampolines.make(record.params, record.results, {
+          memory: this.memory,
+          table: this.table,
+          stackPointer: this.stackPointer,
+          backing: record.backing,
+          userData: record.userData
+        });
+        this.table.set(record.index, fn);
+        this.types.set(fn, sig);
+      }
       reserve(size) {
         return this.indices?.reserve(this.table.length, size) ?? this.table.length;
       }
@@ -7491,6 +7878,10 @@ var init_wasix_linker = __esm({
           if (record.index < this.table.length) this.table.set(record.index, null);
           return;
         }
+        if (record.kind === "closure-prepare") {
+          this.install(record);
+          return;
+        }
         if (record.kind === "load") {
           if (this.modules.has(record.handle)) return;
           this.instantiate(record.path, this.moduleAt(record.path), record, false);
@@ -7515,14 +7906,14 @@ var init_wasix_linker = __esm({
         if (!m) throw new DlError(`invalid handle ${handle}`);
         return m;
       }
-      locate(name, cwd, ldPath) {
-        if (name.includes("/"))
-          return name.startsWith("/") ? normalize(name) : normalize(`${cwd}/${name}`);
+      locate(name2, cwd, ldPath) {
+        if (name2.includes("/"))
+          return name2.startsWith("/") ? normalize(name2) : normalize(`${cwd}/${name2}`);
         for (const dir of [...ldPath.filter(Boolean), ...LIBRARY_DIRS]) {
-          const path = normalize(`${dir.startsWith("/") ? "" : `${cwd}/`}${dir}/${name}`);
+          const path = normalize(`${dir.startsWith("/") ? "" : `${cwd}/`}${dir}/${name2}`);
           if (this.byPath.has(path) || this.host.read(path)) return path;
         }
-        throw new DlError(`${name}: not found`);
+        throw new DlError(`${name2}: not found`);
       }
       load(path, cwd, ldPath) {
         const loaded = this.byPath.get(path);
@@ -7617,46 +8008,46 @@ var init_wasix_linker = __esm({
         }
         return linked;
       }
-      functionImport(name) {
-        const now = this.find(name);
+      functionImport(name2) {
+        const now = this.find(name2);
         if (now && typeof now[1] === "function") return now[1];
         let resolved2;
         return (...args) => {
           if (!resolved2) {
-            const later = this.find(name);
+            const later = this.find(name2);
             if (!later || typeof later[1] !== "function")
-              throw new WebAssembly.RuntimeError(`unresolved symbol ${name}`);
+              throw new WebAssembly.RuntimeError(`unresolved symbol ${name2}`);
             resolved2 = later[1];
           }
           return resolved2(...args);
         };
       }
-      addressOrNull(name) {
-        const found = this.find(name);
+      addressOrNull(name2) {
+        const found = this.find(name2);
         if (!found || !(found[1] instanceof WebAssembly.Global)) return 0;
         return this.baseOf(found[0]) + found[1].value;
       }
-      slotOrNull(name) {
-        const found = this.find(name);
+      slotOrNull(name2) {
+        const found = this.find(name2);
         if (!found || typeof found[1] !== "function") return 0;
-        return this.slot(found[1], found[0], name);
+        return this.slot(found[1], found[0], name2);
       }
-      find(name) {
-        const inMain = this.main?.exports[name];
+      find(name2) {
+        const inMain = this.main?.exports[name2];
         if (inMain !== void 0) return [0, inMain];
         for (const m of this.modules.values()) {
-          const v = m.instance?.exports[name];
+          const v = m.instance?.exports[name2];
           if (v !== void 0) return [m.handle, v];
         }
         return void 0;
       }
-      findIn(m, name, seen) {
+      findIn(m, name2, seen) {
         if (seen.has(m.handle)) return void 0;
         seen.add(m.handle);
-        const v = m.instance.exports[name];
+        const v = m.instance.exports[name2];
         if (v !== void 0) return [m.handle, v];
         for (const h of m.needed) {
-          const found = this.findIn(this.module(h), name, seen);
+          const found = this.findIn(this.module(h), name2, seen);
           if (found) return found;
         }
         return void 0;
@@ -7664,14 +8055,23 @@ var init_wasix_linker = __esm({
       baseOf(handle) {
         return handle === 0 ? this.memoryBase : this.module(handle).memoryBase;
       }
-      slot(fn, handle, name) {
+      indexed = 0;
+      indexTable() {
+        for (let i = this.indexed; i < this.table.length; i++) {
+          const fn = this.table.get(i);
+          if (fn && !this.slots.has(fn)) this.slots.set(fn, i);
+        }
+        this.indexed = this.table.length;
+      }
+      slot(fn, handle, name2) {
+        this.indexTable();
         const known = this.slots.get(fn);
         if (known !== void 0) return known;
         const index2 = this.reserve(1);
         growTable(this.table, index2 + 1);
         this.table.set(index2, fn);
         this.slots.set(fn, index2);
-        this.publisher?.({ kind: "slot", index: index2, handle, name });
+        this.publisher?.({ kind: "slot", index: index2, handle, name: name2 });
         return index2;
       }
       allocate(size, alignment) {
@@ -7909,8 +8309,8 @@ function wasixSocketImports(host, preview1) {
     },
     sock_set_opt_time: (fd) => void socket(fd),
     sock_send_file: () => E.NOSYS,
-    resolve: (name, len, _port, addrs, naddrs, out) => {
-      const found = call2({ op: "sock-resolve", name: mem.string(name, len), family: 0 });
+    resolve: (name2, len, _port, addrs, naddrs, out) => {
+      const found = call2({ op: "sock-resolve", name: mem.string(name2, len), family: 0 });
       const ips = found.map(ipBytes).filter((ip) => ip !== void 0);
       if (ips.length === 0) throw new WasiError("ENOENT");
       if (naddrs < 1) throw new WasiError("EINVAL");
@@ -7975,7 +8375,7 @@ function posixSignal(sig) {
 function nsToMs(ns) {
   return Math.ceil(Number(ns) / 1e6);
 }
-var FDFLAGSEXT_CLOEXEC, SPAWN_OP_SIZE, SPAWN_OPS, RIGHTS_FD_WRITE, ICANON, ECHO, FUTEX_SLICE_MS, WasixHost;
+var FDFLAGSEXT_CLOEXEC, SPAWN_OP_SIZE, SPAWN_OPS, RIGHTS_FD_WRITE, ICANON, ECHO, FUTEX_SLICE_MS, MAIN_HANDLE, WasixHost;
 var init_wasix_host = __esm({
   "src/process/wasi/wasix-host.ts"() {
     "use strict";
@@ -7987,6 +8387,7 @@ var init_wasix_host = __esm({
     init_wasix_linker();
     init_wasix_process();
     init_wasix_sockets();
+    init_wasix_trampoline();
     init_wasm_functypes();
     FDFLAGSEXT_CLOEXEC = 1;
     SPAWN_OP_SIZE = 56;
@@ -7995,6 +8396,7 @@ var init_wasix_host = __esm({
     ICANON = 2;
     ECHO = 8;
     FUTEX_SLICE_MS = 50;
+    MAIN_HANDLE = 2147483647;
     WasixHost = class _WasixHost {
       process;
       threads;
@@ -8086,6 +8488,18 @@ var init_wasix_host = __esm({
             if (!this.linker) throw new WasiError("ENOTSUP");
             this.mem.view().setUint32(out, this.linker.allocateClosure(), true);
           },
+          closure_prepare: (backing, index2, argTypes, argCount, resultTypes, resultCount, userData) => {
+            if (!this.linker) throw new WasiError("ENOTSUP");
+            const params = valueTypes(this.mem.bytes(argTypes, argCount));
+            const results = valueTypes(this.mem.bytes(resultTypes, resultCount));
+            if (!params || !results) throw new WasiError("EINVAL");
+            try {
+              this.linker.prepareClosure({ index: index2, backing, userData, params, results });
+            } catch (e) {
+              if (e instanceof DlError) throw new WasiError("EINVAL");
+              throw e;
+            }
+          },
           closure_free: (index2) => {
             if (!this.linker) throw new WasiError("ENOTSUP");
             this.linker.freeClosure(index2);
@@ -8115,7 +8529,7 @@ var init_wasix_host = __esm({
           },
           proc_signals_sizes_get: (out) => void mem.view().setUint32(out, 0, true),
           proc_signals_get: () => E.SUCCESS,
-          callback_signal: (name, len) => void this.signals?.register(this.str(name, len)),
+          callback_signal: (name2, len) => void this.signals?.register(this.str(name2, len)),
           proc_raise_interval: (sig, interval, repeat) => void host.o.kernel.call({
             op: "proc-alarm",
             sig: posixSignal(sig),
@@ -8262,23 +8676,23 @@ var init_wasix_host = __esm({
         return {
           dlopen: (p, pl, _flags, buf, len, lp, ll, out) => {
             if (p === 0) {
-              mem.view().setUint32(out, 0, true);
+              mem.view().setUint32(out, MAIN_HANDLE, true);
               return E.SUCCESS;
             }
             return linked(
               buf,
               len,
               (l) => l.open(this.str(p, pl), host.cwd, lp === 0 ? [] : this.str(lp, ll).split(":")),
-              (h) => void mem.view().setUint32(out, h, true)
+              (h) => void mem.view().setUint32(out, h === 0 ? MAIN_HANDLE : h, true)
             );
           },
           dlsym: (handle, s, sl, buf, len, out) => linked(
             buf,
             len,
-            (l) => l.symbol(handle, this.str(s, sl)),
+            (l) => l.symbol(handle === MAIN_HANDLE ? 0 : handle, this.str(s, sl)),
             (v) => void mem.view().setUint32(out, v, true)
           ),
-          dl_invalid_handle: (handle) => handle !== 0 && this.linker && !this.linker.invalid(handle) ? E.SUCCESS : E.NOEXEC
+          dl_invalid_handle: (handle) => handle === MAIN_HANDLE || handle !== 0 && this.linker && !this.linker.invalid(handle) ? E.SUCCESS : E.NOEXEC
         };
       }
       threadImports() {
@@ -8409,10 +8823,10 @@ function mainModule(lines) {
   }
   return void 0;
 }
-function nameFrame(line, module, name) {
+function nameFrame(line, module, name2) {
   const m = UNNAMED_FRAME.exec(line);
   if (!m || m[3] !== module) return line;
-  const found = name(Number(m[4]));
+  const found = name2(Number(m[4]));
   return found === void 0 ? line : `${m[1]}${found} (${m[2]})`;
 }
 function sidecarNames(read2, path) {
@@ -8448,29 +8862,29 @@ __export(wasi_runtime_exports, {
   trapMessage: () => trapMessage,
   unsupportedImport: () => unsupportedImport
 });
-function enosys(module, name, foreign) {
-  const type = foreign?.[module]?.[name];
-  if (type === "other") throw new Error(noErrno(`${module}.${name}`));
+function enosys(module, name2, foreign) {
+  const type = foreign?.[module]?.[name2];
+  if (type === "other") throw new Error(noErrno(`${module}.${name2}`));
   if (type === "none") return () => void 0;
   if (type === "i64") return () => 52n;
   return () => 52;
 }
 function firstOther(foreign) {
   for (const [module, fields] of Object.entries(foreign)) {
-    const name = Object.keys(fields).find((field2) => fields[field2] === "other");
-    if (name !== void 0) return `${module}.${name}`;
+    const name2 = Object.keys(fields).find((field2) => fields[field2] === "other");
+    if (name2 !== void 0) return `${module}.${name2}`;
   }
   return void 0;
 }
 function accepted(imp, scope2) {
-  const { module, name, kind } = imp;
+  const { module, name: name2, kind } = imp;
   if (module === PREVIEW1 || module === WASIX) return true;
   if (!RESERVED2.has(module) && (scope2.extended || scope2.wasi && kind === "function")) return true;
   if (scope2.pie && (module === "GOT.mem" || module === "GOT.func")) return true;
   if (scope2.pie && module === "env" && kind !== "memory") return true;
-  if (kind === "memory" && scope2.memory?.module === module && scope2.memory.name === name)
+  if (kind === "memory" && scope2.memory?.module === module && scope2.memory.name === name2)
     return true;
-  return module === "wasi" && name === "thread-spawn" && (scope2.wasix || !!scope2.memory?.shared);
+  return module === "wasi" && name2 === "thread-spawn" && (scope2.wasix || !!scope2.memory?.shared);
 }
 function unsupportedImport(module, memory, extended = false, foreign = {}) {
   const imports = WebAssembly.Module.imports(module);
@@ -8661,11 +9075,21 @@ async function instantiate(host, module, memory, threads, {
   }
   if (sync) {
     sync.linker.bindMain(instance, !thread);
+    if (path !== void 0) sync.linker.mainPath = path;
     if (thread) sync.catchUp();
     sync.linker.bindMainGot();
   }
   return { instance, driver };
 }
+function procTree(call2, pid) {
+  return new ProcTree(
+    {
+      procList: () => call2({ op: "proc-list" }),
+      mountList: () => call2({ op: "mount-list" })
+    },
+    pid
+  );
+}
 function exportedTable(instance) {
   const table = instance.exports.__indirect_function_table;
   return table instanceof WebAssembly.Table ? table : void 0;
@@ -8682,7 +9106,8 @@ function linkerHost(host, imports) {
     hostImports: () => {
       const { env: _env, "GOT.mem": _mem, "GOT.func": _func, ...rest2 } = imports();
       return rest2;
-    }
+    },
+    real: (path) => physicalPath(host.o.fs, path)
   };
 }
 function merge(base, extra) {
@@ -8736,7 +9161,10 @@ async function runWasiProcess(init, port2) {
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
     kernel: { sys: traced(stats, "kernel", sys), call: call2 },
-    fs: cachingBridge(traced(stats, "fs", createSyncFsSabBridge(transport))),
+    fs: procfsBridge(
+      cachingBridge(traced(stats, "fs", createSyncFsSabBridge(transport))),
+      procTree(call2, id.pid)
+    ),
     ...descriptors(init, fork, threads)
   });
   if (threads) {
@@ -8784,12 +9212,12 @@ async function runWasiProcess(init, port2) {
     if (stats) report(stats, sys);
   }
 }
-function trapMessage(e, env, where = "", name) {
+function trapMessage(e, env, where = "", name2) {
   const head = `wasm trap${where}: ${e.message}`;
   if (env.SLICC_WASM_BACKTRACE !== "1") return head;
   const lines = (e.stack ?? "").split("\n");
-  const main = name && mainModule(lines);
-  const frames = lines.filter((line) => /^\s+at .*wasm:\/\/wasm\//.test(line)).slice(0, BACKTRACE_FRAMES).map((line) => name && main ? nameFrame(line, main, name) : line);
+  const main = name2 && mainModule(lines);
+  const frames = lines.filter((line) => /^\s+at .*wasm:\/\/wasm\//.test(line)).slice(0, BACKTRACE_FRAMES).map((line) => name2 && main ? nameFrame(line, main, name2) : line);
   return frames.length ? `${head}
 ${frames.join("\n")}` : head;
 }
@@ -8827,7 +9255,7 @@ async function runWasiThread(init, port2) {
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
     kernel: { sys, call: call2 },
-    fs: cachingBridge(createSyncFsSabBridge(transport)),
+    fs: procfsBridge(cachingBridge(createSyncFsSabBridge(transport)), procTree(call2, id.pid)),
     shared: threads.ids
   });
   const program = await programImports(init.program, host, transport, thread.tid);
@@ -8869,6 +9297,7 @@ var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, SLICC_FS, SLI
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
+    init_physical_path();
     init_protocol();
     init_signals();
     init_sync_sab_bridge();
@@ -8881,6 +9310,7 @@ var init_wasi_runtime = __esm({
     init_wasi_host();
     init_wasi_imports();
     init_wasi_module();
+    init_wasi_procfs();
     init_wasi_signals();
     init_wasi_stats();
     init_wasi_threads();
@@ -8940,8 +9370,8 @@ var init_wasi_runtime = __esm({
         const ids = this.ids;
         if (!ids) return { preview1, wasix };
         const wrap2 = (table) => Object.fromEntries(
-          Object.entries(table).map(([name, fn]) => [
-            name,
+          Object.entries(table).map(([name2, fn]) => [
+            name2,
             ((...args) => {
               if (Atomics.load(ids, DL_GEN) !== this.gen) this.catchUp();
               const result = fn(...args);
@@ -9273,7 +9703,7 @@ async function preflight(kernel, hows) {
   }
 }
 async function slots(kernel, o, mine, theirs) {
-  const hows = STDIO2.map((name) => o[name] ?? "inherit");
+  const hows = STDIO2.map((name2) => o[name2] ?? "inherit");
   await preflight(kernel, hows);
   const stdio = [];
   for (const [n, how] of hows.entries()) {
@@ -9321,7 +9751,7 @@ function rewrite(hop, status2, location) {
   const toGet = (status2 === 301 || status2 === 302) && hop.method === "POST" || status2 === 303 && hop.method !== "GET" && hop.method !== "HEAD";
   const crossOrigin = next2.origin !== new URL(hop.url).origin;
   const headers = hop.headers.filter(
-    ([name]) => !(toGet && BODY_HEADERS.has(name.toLowerCase())) && !(crossOrigin && CREDENTIALS.has(name.toLowerCase()))
+    ([name2]) => !(toGet && BODY_HEADERS.has(name2.toLowerCase())) && !(crossOrigin && CREDENTIALS.has(name2.toLowerCase()))
   );
   return {
     url: withoutFragment(next2),
@@ -9373,7 +9803,7 @@ function parameter(text, from, params) {
   while (SPACE.test(text[at] ?? "")) at++;
   let end = at;
   while (end < text.length && text[end] !== ";" && text[end] !== "=") end++;
-  const name = text.slice(at, end).toLowerCase();
+  const name2 = text.slice(at, end).toLowerCase();
   if (text[end] !== "=") return end;
   const start2 = end + 1;
   let value2;
@@ -9386,8 +9816,8 @@ function parameter(text, from, params) {
     if (!value2) return end < 0 ? text.length : end;
   }
   if (end < 0) end = text.length;
-  if (TOKEN.test(name) && QUOTABLE.test(value2) && !params.has(name)) {
-    params.set(name, value2);
+  if (TOKEN.test(name2) && QUOTABLE.test(value2) && !params.has(name2)) {
+    params.set(name2, value2);
   }
   return end;
 }
@@ -9401,8 +9831,8 @@ function mimeType(input) {
   const params = /* @__PURE__ */ new Map();
   for (let at = semi < 0 ? text.length : semi; at < text.length; ) at = parameter(text, at, params);
   let out = `${type}/${subtype}`.toLowerCase();
-  for (const [name, value2] of params) {
-    out += `;${name}=${TOKEN.test(value2) ? value2 : `"${value2.replace(/["\\]/g, "\\$&")}"`}`;
+  for (const [name2, value2] of params) {
+    out += `;${name2}=${TOKEN.test(value2) ? value2 : `"${value2.replace(/["\\]/g, "\\$&")}"`}`;
   }
   return out;
 }
@@ -9603,7 +10033,7 @@ function fetchOp(kernel) {
     };
     for (let hops = 0; ; hops++) {
       const head = await send(hop, signal);
-      const location = head.headers.find(([name]) => name.toLowerCase() === "location")?.[1];
+      const location = head.headers.find(([name2]) => name2.toLowerCase() === "location")?.[1];
       const follow2 = known.manualRedirects && REDIRECTS.has(head.status) && location !== void 0 && request.redirect !== "manual";
       if (!follow2) {
         const redirected = hops > 0 || head.redirected === true;
@@ -9748,9 +10178,9 @@ function port(n) {
   return n;
 }
 function netOps(kernel, io) {
-  const name = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
+  const name2 = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
   const connection = async (fd) => {
-    const [local, remote] = [await name(fd, false), await name(fd, true)];
+    const [local, remote] = [await name2(fd, false), await name2(fd, true)];
     const stop = new AbortController();
     let closed;
     const close = () => {
@@ -9832,7 +10262,7 @@ function netOps(kernel, io) {
       };
       await kernel.call({ op: "sock-bind", fd, addr });
       await kernel.call({ op: "sock-listen", fd, backlog: options.backlog ?? 128 });
-      return listener(fd, await name(fd, false));
+      return listener(fd, await name2(fd, false));
     }),
     connect: async (options) => {
       const signal = options.signal ?? NEVER;
@@ -10143,10 +10573,25 @@ function ttyOps(kernel) {
       await kernel.call({ op: "tty-pgrp-set", fd, pgrp });
     }
   };
+  const openOn = async (terminal, fd) => {
+    const open = await kernel.json({ op: "fd-list" });
+    const on = open.filter((entry) => entry.terminal === terminal);
+    return (on.find((entry) => entry.fd === fd) ?? on[0])?.fd;
+  };
+  const reopened = async (terminal, termios) => {
+    const fd = await kernel.json({ op: "fd-open-tty", name: terminal });
+    try {
+      await setAttr(fd, termios);
+    } finally {
+      await kernel.call({ op: "fd-close", fd });
+    }
+  };
   const restore = async () => {
     for (const [terminal, { fd, termios }] of [...saved].reverse()) {
       saved.delete(terminal);
-      await setAttr(fd, termios).catch(() => void 0);
+      const at = await openOn(terminal, fd).catch(() => void 0);
+      const back = at === void 0 ? reopened(terminal, termios) : setAttr(at, termios);
+      await back.catch(() => void 0);
     }
   };
   return { tty, restore };
@@ -10664,22 +11109,22 @@ function chain(target) {
   return out;
 }
 function hide(target, names) {
-  for (const name of names) {
+  for (const name2 of names) {
     const holders = chain(target);
     for (const holder of holders) {
-      if (Object.getOwnPropertyDescriptor(holder, name)?.configurable) {
-        Reflect.deleteProperty(holder, name);
+      if (Object.getOwnPropertyDescriptor(holder, name2)?.configurable) {
+        Reflect.deleteProperty(holder, name2);
       }
     }
-    const kept = holders.slice(1).some((holder) => Object.hasOwn(holder, name));
-    const defined = Reflect.defineProperty(target, name, {
+    const kept = holders.slice(1).some((holder) => Object.hasOwn(holder, name2));
+    const defined = Reflect.defineProperty(target, name2, {
       value: void 0,
       writable: false,
       enumerable: false,
       configurable: false
     });
-    if (kept || !defined && Reflect.get(target, name) !== void 0) {
-      throw new Error(`slicc-kernel: cannot withhold ${name} from a JS program`);
+    if (kept || !defined && Reflect.get(target, name2) !== void 0) {
+      throw new Error(`slicc-kernel: cannot withhold ${name2} from a JS program`);
     }
   }
 }