@ai-ecoverse/slicc-kernel 1.49.1 → 1.51.0

package/dist/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/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;
     },
@@ -4822,8 +4877,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;
@@ -5559,8 +5614,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 +5627,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 +5689,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 +5918,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 +6203,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 +6222,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 +6308,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 +6354,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 +6680,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 +6692,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) {
@@ -6788,8 +6788,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 +6886,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 +6902,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 +6916,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 +6932,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 +7047,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 +7118,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 +7353,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 +7476,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 +7520,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 +7530,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 +7555,7 @@ var init_wasix_linker = __esm({
       publisher;
       indices;
       types = new FuncTypes();
+      trampolines = new Trampolines();
       memory;
       host;
       constructor(memory, mainInfo, host, thread = false) {
@@ -7450,16 +7619,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 +7657,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 +7688,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 +7716,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 +7818,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 +7865,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 +8119,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 +8185,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 +8197,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 +8206,7 @@ var init_wasix_host = __esm({
     ICANON = 2;
     ECHO = 8;
     FUTEX_SLICE_MS = 50;
+    MAIN_HANDLE = 2147483647;
     WasixHost = class _WasixHost {
       process;
       threads;
@@ -8086,6 +8298,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 +8339,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 +8486,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 +8633,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 +8672,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,6 +8885,7 @@ 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();
   }
@@ -8682,7 +8907,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) {
@@ -8784,12 +9010,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;
 }
@@ -8869,6 +9095,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();
@@ -8940,8 +9167,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 +9500,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 +9548,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 +9600,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 +9613,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 +9628,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 +9830,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 +9975,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 +10059,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;
@@ -10664,22 +10891,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`);
     }
   }
 }