@ai-ecoverse/slicc-kernel 1.50.0 → 1.52.0

package/dist/node-process-worker.js

@@ -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/process/js/lockdown.ts
@@ -23,22 +23,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`);
     }
   }
 }
@@ -75,11 +75,11 @@ var init_lockdown = __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;
@@ -520,10 +520,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;
     },
@@ -969,6 +969,10 @@ function kernelEntry() {
 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 } : {},
@@ -1076,8 +1080,8 @@ var init_wasi_fds = __esm({
         } catch {
           return out;
         }
-        for (const name of [.../* @__PURE__ */ new Set([...names, "dev", ...SYNTHETIC_DIRS])].sort()) {
-          const path = `/${name}`;
+        for (const name2 of [.../* @__PURE__ */ new Set([...names, "dev", ...SYNTHETIC_DIRS])].sort()) {
+          const path = `/${name2}`;
           if (path === "/dev") {
             out.push({ type: "dir", path, preopen: path });
             continue;
@@ -1436,6 +1440,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) });
       }
@@ -1813,8 +1818,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);
@@ -1826,8 +1831,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) {
@@ -1888,8 +1893,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();
@@ -2117,13 +2122,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)
         };
@@ -2402,14 +2407,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);
@@ -2421,7 +2426,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 {
@@ -2483,18 +2488,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;
@@ -2809,7 +2814,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],
@@ -2821,8 +2826,8 @@ function processes(host, call2, inThread) {
         };
         const pid = restarted(() => 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) {
@@ -3388,7 +3393,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()) {
@@ -3436,7 +3441,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),
@@ -3488,7 +3493,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;
@@ -3501,8 +3506,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;
 }
@@ -3516,8 +3521,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;
 }
@@ -3718,7 +3723,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;
@@ -3863,9 +3868,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 = () => {
@@ -3947,7 +3952,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;
@@ -4444,10 +4449,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 };
@@ -5078,13 +5098,13 @@ var init_js_runtime = __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;
@@ -5126,7 +5146,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,
@@ -5204,8 +5224,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);
@@ -5223,9 +5243,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;
@@ -5392,15 +5412,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;
@@ -5413,7 +5433,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,
@@ -5440,11 +5460,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 {
       }
@@ -5454,18 +5474,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;
@@ -5728,28 +5748,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 {
@@ -5790,8 +5810,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;
@@ -5839,7 +5859,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_DIRS2) if (!candidates.includes(dir)) candidates.push(dir);
   const dirs = [];
   for (const dir of candidates) {
@@ -5984,14 +6004,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() {
@@ -5999,12 +6019,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;
@@ -6013,21 +6033,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 {
@@ -6064,18 +6084,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);
           };
@@ -6162,15 +6182,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);
@@ -6183,14 +6203,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;
         }
@@ -6487,11 +6507,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;
@@ -6500,10 +6520,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);
     }
   }
 }
@@ -6547,7 +6567,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;
@@ -6587,10 +6607,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)) {
@@ -6654,11 +6674,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);
       }
@@ -6760,8 +6780,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)
@@ -6798,13 +6818,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 {
     }
   }
@@ -6856,14 +6876,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:
 `
   };
 }
@@ -7672,9 +7692,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_NONBLOCK2) !== 0;
@@ -7712,8 +7732,8 @@ var init_process_sockets = __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);
@@ -7800,12 +7820,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
 `;
@@ -7829,18 +7849,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}
 `;
@@ -7899,8 +7919,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: () => {
     } };
@@ -7913,8 +7933,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());
@@ -7936,15 +7956,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));
@@ -7957,25 +7977,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];
     }
@@ -7985,18 +8005,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) : [".", ".."])
   };
@@ -8131,9 +8151,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}`));
@@ -8224,8 +8244,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) {
@@ -8555,9 +8575,9 @@ var init_process_runtime = __esm({
 
 // 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;
@@ -8625,6 +8645,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({
@@ -8665,8 +8870,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;
@@ -8763,11 +8968,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))];
           })
         );
       }
@@ -8779,9 +8984,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) {
@@ -8793,7 +8998,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) {
@@ -8809,12 +9014,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 {
     }
   }
@@ -8924,8 +9129,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;
         }
       }
@@ -8995,6 +9200,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--) {
@@ -9063,10 +9435,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) {
@@ -9186,8 +9558,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);
         }
@@ -9230,8 +9602,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;
@@ -9240,6 +9612,7 @@ var init_wasix_linker = __esm({
     "use strict";
     init_dylink();
     init_wasi_files();
+    init_wasix_trampoline();
     init_wasm_functypes();
     TABLE_BASE2 = 1;
     PAGE2 = 65536;
@@ -9264,6 +9637,7 @@ var init_wasix_linker = __esm({
       publisher;
       indices;
       types = new FuncTypes();
+      trampolines = new Trampolines();
       memory;
       host;
       constructor(memory, mainInfo, host, thread = false) {
@@ -9327,16 +9701,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);
@@ -9356,6 +9739,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;
       }
@@ -9368,6 +9770,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);
@@ -9392,14 +9798,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);
@@ -9494,46 +9900,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;
@@ -9541,14 +9947,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) {
@@ -9786,8 +10201,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");
@@ -9852,7 +10267,7 @@ function posixSignal(sig) {
 function nsToMs(ns) {
   return Math.ceil(Number(ns) / 1e6);
 }
-var FDFLAGSEXT_CLOEXEC, SPAWN_OP_SIZE, SPAWN_OPS, RIGHTS_FD_WRITE, ICANON2, ECHO2, FUTEX_SLICE_MS, WasixHost;
+var FDFLAGSEXT_CLOEXEC, SPAWN_OP_SIZE, SPAWN_OPS, RIGHTS_FD_WRITE, ICANON2, ECHO2, FUTEX_SLICE_MS, MAIN_HANDLE, WasixHost;
 var init_wasix_host = __esm({
   "src/process/wasi/wasix-host.ts"() {
     "use strict";
@@ -9864,6 +10279,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;
@@ -9872,6 +10288,7 @@ var init_wasix_host = __esm({
     ICANON2 = 2;
     ECHO2 = 8;
     FUTEX_SLICE_MS = 50;
+    MAIN_HANDLE = 2147483647;
     WasixHost = class _WasixHost {
       process;
       threads;
@@ -9963,6 +10380,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);
@@ -9992,7 +10421,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),
@@ -10139,23 +10568,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() {
@@ -10286,10 +10715,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) {
@@ -10325,29 +10754,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);
@@ -10538,11 +10967,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;
@@ -10559,7 +10998,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) {
@@ -10613,7 +11053,10 @@ async function runWasiProcess(init, port3) {
     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) {
@@ -10661,12 +11104,12 @@ async function runWasiProcess(init, port3) {
     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;
 }
@@ -10704,7 +11147,7 @@ async function runWasiThread(init, port3) {
     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);
@@ -10746,6 +11189,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();
@@ -10758,6 +11202,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();
@@ -10817,8 +11262,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);
@@ -10858,19 +11303,19 @@ var NODE_SLOTS = [
   "clearImmediate"
 ];
 function vacate(target, names) {
-  for (const name of names) {
+  for (const name2 of names) {
     for (let at = target; at && at !== Object.prototype; ) {
-      if (Object.getOwnPropertyDescriptor(at, name)?.configurable) Reflect.deleteProperty(at, name);
+      if (Object.getOwnPropertyDescriptor(at, name2)?.configurable) Reflect.deleteProperty(at, name2);
       at = Object.getPrototypeOf(at);
     }
-    Reflect.defineProperty(target, name, {
+    Reflect.defineProperty(target, name2, {
       value: void 0,
       writable: true,
       enumerable: false,
       configurable: true
     });
-    if (Reflect.get(target, name) !== void 0) {
-      throw new Error(`slicc-kernel: cannot withhold ${name} from a JS program`);
+    if (Reflect.get(target, name2) !== void 0) {
+      throw new Error(`slicc-kernel: cannot withhold ${name2} from a JS program`);
     }
   }
 }