sandboxedjs 0.1.33 → 0.1.35

package/dist/index.cjs

@@ -791,10 +791,10 @@ function globToRegexSource(pattern, opts = {}) {
       continue;
     }
     if (c === "[") {
-      const compiled2 = compileBracket(pattern, i);
-      if (compiled2) {
-        out += guardDot() + compiled2.source;
-        i = compiled2.next;
+      const compiled3 = compileBracket(pattern, i);
+      if (compiled3) {
+        out += guardDot() + compiled3.source;
+        i = compiled3.next;
         atSegmentStart = false;
         continue;
       }
@@ -5707,8 +5707,101 @@ function strerrorOf(e) {
 var EXIT_NOT_EXECUTABLE = 126;
 var EXIT_NOT_FOUND = 127;
 
+// src/wasi/constants.ts
+var WASI_ESUCCESS = 0;
+var WASI_EACCES = 2;
+var WASI_EAGAIN = 6;
+var WASI_EBADF = 8;
+var WASI_EBUSY = 10;
+var WASI_EEXIST = 20;
+var WASI_EFAULT = 21;
+var WASI_EFBIG = 22;
+var WASI_EINVAL = 28;
+var WASI_EIO = 29;
+var WASI_EISDIR = 31;
+var WASI_ELOOP = 32;
+var WASI_EMFILE = 34;
+var WASI_ENAMETOOLONG = 37;
+var WASI_ENOENT = 44;
+var WASI_ENOMEM = 48;
+var WASI_ENOSPC = 51;
+var WASI_ENOSYS = 52;
+var WASI_ENOTDIR = 54;
+var WASI_ENOTEMPTY = 55;
+var WASI_ENOTSUP = 58;
+var WASI_ENOTTY = 59;
+var WASI_EPERM = 63;
+var WASI_EPIPE = 64;
+var WASI_EROFS = 69;
+var WASI_ESPIPE = 70;
+var WASI_EXDEV = 75;
+var WASI_ENOTCAPABLE = 76;
+var WASI_ERRNO_BY_CODE = {
+  EPERM: WASI_EPERM,
+  ENOENT: WASI_ENOENT,
+  EIO: WASI_EIO,
+  EBADF: WASI_EBADF,
+  EAGAIN: WASI_EAGAIN,
+  ENOMEM: WASI_ENOMEM,
+  EACCES: WASI_EACCES,
+  EFAULT: WASI_EFAULT,
+  EBUSY: WASI_EBUSY,
+  EEXIST: WASI_EEXIST,
+  EXDEV: WASI_EXDEV,
+  ENOTDIR: WASI_ENOTDIR,
+  EISDIR: WASI_EISDIR,
+  EINVAL: WASI_EINVAL,
+  EMFILE: WASI_EMFILE,
+  ENOTTY: WASI_ENOTTY,
+  EFBIG: WASI_EFBIG,
+  ENOSPC: WASI_ENOSPC,
+  ESPIPE: WASI_ESPIPE,
+  EROFS: WASI_EROFS,
+  EPIPE: WASI_EPIPE,
+  ENAMETOOLONG: WASI_ENAMETOOLONG,
+  ENOSYS: WASI_ENOSYS,
+  ENOTEMPTY: WASI_ENOTEMPTY,
+  ELOOP: WASI_ELOOP,
+  ENOTSUP: WASI_ENOTSUP
+};
+var FILETYPE_UNKNOWN = 0;
+var FILETYPE_CHARACTER_DEVICE = 2;
+var FILETYPE_DIRECTORY = 3;
+var FILETYPE_REGULAR_FILE = 4;
+var FILETYPE_SYMBOLIC_LINK = 7;
+var O_CREAT = 1 << 0;
+var O_DIRECTORY = 1 << 1;
+var O_EXCL = 1 << 2;
+var O_TRUNC = 1 << 3;
+var FD_APPEND = 1 << 0;
+var LOOKUP_SYMLINK_FOLLOW = 1 << 0;
+var FST_ATIM = 1 << 0;
+var FST_ATIM_NOW = 1 << 1;
+var FST_MTIM = 1 << 2;
+var FST_MTIM_NOW = 1 << 3;
+var WHENCE_SET = 0;
+var WHENCE_CUR = 1;
+var WHENCE_END = 2;
+var EVENTTYPE_CLOCK = 0;
+var EVENTTYPE_FD_READ = 1;
+var EVENTTYPE_FD_WRITE = 2;
+var SUBSCRIPTION_CLOCK_ABSTIME = 1 << 0;
+var RIGHT_FD_READ = 1n << 1n;
+var RIGHT_FD_SEEK = 1n << 2n;
+var RIGHT_FD_WRITE = 1n << 6n;
+var RIGHTS_ALL = (1n << 30n) - 1n;
+var SIZEOF_FILESTAT = 64;
+var SIZEOF_FDSTAT = 24;
+var SIZEOF_DIRENT = 24;
+var SIZEOF_SUBSCRIPTION = 48;
+var SIZEOF_EVENT = 32;
+function isWasmBinary(bytes2) {
+  return bytes2.length >= 4 && bytes2[0] === 0 && bytes2[1] === 97 && bytes2[2] === 115 && bytes2[3] === 109;
+}
+
 // src/kernel/kernel.ts
 var BUILTIN_INTERPRETER = "/proc/self/exe";
+var WASI_INTERPRETER = "/usr/bin/wasi";
 var Kernel = class {
   vfs;
   procs = new ProcessTable();
@@ -5843,12 +5936,17 @@ var Kernel = class {
         if (command) return { kind: "builtin", path: candidate, command };
       }
       let head2 = "";
+      let magic;
       try {
         if (this.vfs.permitted(st, R_OK, cred)) {
-          head2 = new TextDecoder().decode(this.vfs.readFile(real, cred).subarray(0, 256));
+          magic = this.vfs.readFile(real, cred).subarray(0, 256);
+          head2 = new TextDecoder().decode(magic);
         }
       } catch {
       }
+      if (magic && isWasmBinary(magic)) {
+        return { kind: "script", path: real, interpreter: [WASI_INTERPRETER] };
+      }
       if (head2.startsWith("#!")) {
         const lineEnd = head2.indexOf("\n");
         const line = (lineEnd >= 0 ? head2.slice(2, lineEnd) : head2.slice(2)).trim();
@@ -5862,6 +5960,7 @@ var Kernel = class {
       const ext = extname(real);
       if (ext === ".js" || ext === ".mjs" || ext === ".cjs") return { kind: "script", path: real, interpreter: ["/usr/bin/node"] };
       if (ext === ".py") return { kind: "script", path: real, interpreter: ["/usr/bin/python3"] };
+      if (ext === ".wasm") return { kind: "script", path: real, interpreter: [WASI_INTERPRETER] };
       return { kind: "script", path: real, interpreter: ["/bin/sh"] };
     }
     return null;
@@ -15740,9 +15839,9 @@ function makeSum(name, algorithm, path) {
       if (args.has("check")) return checkSums(ctx, algorithm, args.positional, args.has("quiet") || args.has("status"));
       const { sources, ok: ok2 } = await readInputs(ctx, args.positional, { stdinName: "-" });
       for (const source of sources) {
-        const digest = await digestHex(algorithm, source.bytes);
-        if (args.has("tag")) ctx.line(`${algorithm.toUpperCase()} (${source.name}) = ${digest}`);
-        else ctx.line(`${digest}  ${source.name}`);
+        const digest2 = await digestHex(algorithm, source.bytes);
+        if (args.has("tag")) ctx.line(`${algorithm.toUpperCase()} (${source.name}) = ${digest2}`);
+        else ctx.line(`${digest2}  ${source.name}`);
       }
       return ok2 ? 0 : 1;
     }
@@ -18185,6 +18284,55 @@ def _install_processes():
 
 _install_processes()
 `;
+var ASYNCIO_PY = `
+import asyncio
+from pyodide.ffi import can_run_sync, run_sync
+
+_orig_run = asyncio.run
+
+
+def _run(main, *, debug=None, loop_factory=None):
+    if not asyncio.iscoroutine(main) and not asyncio.isfuture(main):
+        raise ValueError("a coroutine was expected, got {!r}".format(main))
+    if not can_run_sync():
+        # No stack switching: the original at least raises a comprehensible
+        # error rather than this shim inventing a new one.
+        return _orig_run(main, debug=debug, loop_factory=loop_factory)
+    return run_sync(main)
+
+
+def _run_until_complete(self, future):
+    if not can_run_sync():
+        raise RuntimeError(
+            "cannot wait for a coroutine on this host: WebAssembly stack "
+            "switching (JSPI) is unavailable."
+        )
+    return run_sync(future)
+
+
+async def _create_server(self, *args, **kwargs):
+    # Pyodide's loop raises a bare NotImplementedError from deep inside
+    # asyncio, which tells a reader nothing about why their server will not
+    # start. Naming the limit is the least this can do until the container can
+    # route connections to Python.
+    raise NotImplementedError(
+        "this container cannot yet accept network connections from Python: "
+        "asyncio's create_server is not implemented on Pyodide's event loop, "
+        "so an ASGI/WSGI server such as uvicorn will install and import but "
+        "not bind a port. Outbound requests do work."
+    )
+
+
+def _install_asyncio():
+    asyncio.run = _run
+    asyncio.runners.run = _run
+    loop_type = type(asyncio.get_event_loop())
+    loop_type.run_until_complete = _run_until_complete
+    loop_type.create_server = _create_server
+
+
+_install_asyncio()
+`;
 var NETWORK_PY = `
 import builtins, email.message, io, sys, urllib.error, urllib.request, urllib.response
 import _sbx_host as _host
@@ -18469,16 +18617,17 @@ function installSyscallBridge(py) {
   py.runPython(BRIDGE_PY);
   py.runPython(PROCESS_PY);
   py.runPython(NETWORK_PY);
+  py.runPython(ASYNCIO_PY);
 }
 function bindProgram(py, binding) {
   py.__sbxSlot.current = binding;
   const { ctx, stdin } = binding;
-  const decoder8 = new TextDecoder();
+  const decoder9 = new TextDecoder();
   py.setStdout({
-    write: (buffer) => (ctx.write(decoder8.decode(buffer)), buffer.length)
+    write: (buffer) => (ctx.write(decoder9.decode(buffer)), buffer.length)
   });
   py.setStderr({
-    write: (buffer) => (ctx.stderr.write(decoder8.decode(buffer)), buffer.length)
+    write: (buffer) => (ctx.stderr.write(decoder9.decode(buffer)), buffer.length)
   });
   py.setStdin({
     read: (buffer) => {
@@ -18742,6 +18891,67 @@ async function runCPythonRepl(ctx) {
   }
   return 0;
 }
+var PIP_PY = `
+import json, re
+
+import micropip
+
+_MISSING = re.compile(r"Can't find a pure Python 3 wheel for '([^']+)'")
+_EXTRAS = re.compile(r"^\\s*([A-Za-z0-9._-]+)\\s*\\[([^\\]]+)\\](.*)$")
+
+
+def _name_of(spec):
+    return re.split(r"[\\[<>=!~;\\s]", spec.strip(), 1)[0]
+
+
+def _installed_version(name):
+    try:
+        found = micropip.list()[name.replace("_", "-").lower()]
+        return getattr(found, "version", None)
+    except Exception:
+        return None
+
+
+async def _install_one(spec):
+    """Install one requirement, retrying without extras if they are impossible."""
+    attempt = spec
+    dropped = None
+    while True:
+        try:
+            await micropip.install(attempt)
+        except ValueError as error:
+            message = str(error)
+            missing = _MISSING.findall(message)
+            extras = _EXTRAS.match(attempt)
+            if missing and extras and dropped is None:
+                dropped = [e.strip() for e in extras.group(2).split(",")]
+                attempt = extras.group(1) + extras.group(3)
+                continue
+            return {
+                "spec": spec, "ok": False, "missing": missing,
+                "reason": message.strip().split("\\n")[0],
+            }
+        except Exception as error:
+            return {"spec": spec, "ok": False, "missing": [], "reason": str(error).strip().split("\\n")[0]}
+
+        name = _name_of(attempt)
+        return {
+            "spec": spec, "ok": True, "name": name,
+            "version": _installed_version(name), "dropped": dropped,
+        }
+
+
+async def __sbx_pip(specs_json):
+    results = []
+    for spec in json.loads(specs_json):
+        try:
+            results.append(await _install_one(spec))
+        except Exception as error:
+            results.append({"spec": spec, "ok": False, "missing": [], "reason": str(error)})
+    return json.dumps(results)
+
+__sbx_pip
+`;
 var micropip = defineCommand({
   name: "micropip",
   path: "/usr/bin/micropip",
@@ -18779,8 +18989,7 @@ var micropip = defineCommand({
       ctx.stderr.write("pip: no packages specified\n");
       return 1;
     }
-    const index = "https://pypi.org";
-    if (!ctx.kernel.net.outboundAllowed(index)) {
+    if (!ctx.kernel.net.outboundAllowed("https://pypi.org")) {
       ctx.stderr.write(
         "pip: outbound network access is disabled for this container (enable with network: { allowOutbound: true })\n"
       );
@@ -18793,22 +19002,42 @@ var micropip = defineCommand({
       ctx.stderr.write("pip: Pyodide is unavailable in this host\n");
       return 127;
     }
+    let outcomes;
     try {
       await py.loadPackage("micropip");
-      const micropipModule = py.pyimport("micropip");
-      for (const name of packages) {
-        ctx.line(`Collecting ${name}`);
-        await micropipModule.install(name);
-        ctx.line(`Successfully installed ${name}`);
-      }
-      return 0;
+      for (const name of packages) ctx.line(`Collecting ${name}`);
+      const install2 = py.runPython(PIP_PY);
+      outcomes = JSON.parse(String(await install2(JSON.stringify(packages))));
     } catch (error) {
       ctx.stderr.write(
-        `Package installation failed: ${error instanceof Error ? error.message : String(error)}
+        `pip: installation failed: ${error instanceof Error ? error.message : String(error)}
 `
       );
       return 1;
     }
+    const installed2 = [];
+    for (const outcome of outcomes) {
+      if (outcome.ok) {
+        installed2.push(
+          outcome.version ? `${outcome.name}-${outcome.version}` : String(outcome.name)
+        );
+        if (outcome.dropped?.length) {
+          ctx.stderr.write(
+            `  WARNING: ${outcome.name}: the ${outcome.dropped.map((extra) => `'${extra}'`).join(", ")} extra needs native code with no WebAssembly build; installed ${outcome.name} without it
+`
+          );
+        }
+        continue;
+      }
+      const missing = outcome.missing ?? [];
+      ctx.stderr.write(
+        missing.length > 0 ? `ERROR: could not install ${outcome.spec}: no WebAssembly build exists for ${missing.map((name) => name.split(/[<>=!~;\s]/)[0]).join(", ")}
+` : `ERROR: could not install ${outcome.spec}: ${outcome.reason ?? "unknown error"}
+`
+      );
+    }
+    if (installed2.length > 0) ctx.line(`Successfully installed ${installed2.join(" ")}`);
+    return outcomes.every((outcome) => outcome.ok) ? 0 : 1;
   }
 });
 
@@ -19012,6 +19241,1001 @@ var ffprobe = defineCommand({
 function ffmpegCommands() {
   return [ffmpeg, ffprobe];
 }
+
+// src/wasi/host.ts
+init_path();
+init_errno();
+init_mode();
+var WasiExit = class extends Error {
+  constructor(code) {
+    super(`wasi exit ${code}`);
+    this.code = code;
+    this.name = "WasiExit";
+  }
+  code;
+};
+var encoder6 = new TextEncoder();
+var decoder7 = new TextDecoder();
+var FIRST_PREOPEN = 3;
+var WasiHost = class {
+  memory;
+  fds = /* @__PURE__ */ new Map();
+  nextFd = FIRST_PREOPEN;
+  opts;
+  startTime;
+  /** Set once `proc_exit` has run, so the runner reports the guest's code. */
+  exitCode = null;
+  constructor(options) {
+    this.opts = {
+      now: Date.now,
+      hrtime: defaultHrtime,
+      random: defaultRandom,
+      sleep: defaultSleep,
+      aborted: () => false,
+      ...options
+    };
+    this.startTime = this.opts.hrtime();
+    this.fds.set(0, { kind: "stdin" });
+    this.fds.set(1, { kind: "stdout", stream: options.stdout });
+    this.fds.set(2, { kind: "stderr", stream: options.stderr });
+    const preopens = options.preopens ?? { "/": "/" };
+    for (const [name, path] of Object.entries(preopens)) {
+      const abs = resolve("/", path);
+      this.fds.set(this.nextFd++, {
+        kind: "dir",
+        path: abs,
+        root: abs,
+        preopen: name,
+        rights: RIGHTS_ALL
+      });
+    }
+  }
+  /** Attach the instance's memory. Called before `_start`. */
+  bind(instance) {
+    const exported = instance.exports.memory;
+    if (!(exported instanceof WebAssembly.Memory)) {
+      throw new Error("wasi: the module does not export a linear memory");
+    }
+    this.memory = exported;
+  }
+  /** Flush every buffered write. Called by the runner when the guest ends. */
+  flushAll() {
+    for (const fd of this.fds.values()) if (fd.kind === "file") this.writeBack(fd);
+  }
+  /**
+   * `wasi_snapshot_preview1`.
+   *
+   * Every entry returns an errno rather than throwing: a JavaScript exception
+   * crossing back into WebAssembly traps the instance, which turns a missing
+   * file into an unrecoverable crash instead of the `ENOENT` the guest is
+   * written to handle. `guard` is what enforces that.
+   */
+  get wasiImport() {
+    const g = (fn) => ((...args) => this.guard(() => fn.apply(this, args)));
+    return {
+      args_get: g(this.args_get),
+      args_sizes_get: g(this.args_sizes_get),
+      environ_get: g(this.environ_get),
+      environ_sizes_get: g(this.environ_sizes_get),
+      clock_res_get: g(this.clock_res_get),
+      clock_time_get: g(this.clock_time_get),
+      fd_advise: g(() => WASI_ESUCCESS),
+      fd_allocate: g(this.fd_allocate),
+      fd_close: g(this.fd_close),
+      fd_datasync: g(this.fd_sync),
+      fd_fdstat_get: g(this.fd_fdstat_get),
+      fd_fdstat_set_flags: g(this.fd_fdstat_set_flags),
+      fd_fdstat_set_rights: g(() => WASI_ESUCCESS),
+      fd_filestat_get: g(this.fd_filestat_get),
+      fd_filestat_set_size: g(this.fd_filestat_set_size),
+      fd_filestat_set_times: g(this.fd_filestat_set_times),
+      fd_pread: g(this.fd_pread),
+      fd_prestat_get: g(this.fd_prestat_get),
+      fd_prestat_dir_name: g(this.fd_prestat_dir_name),
+      fd_pwrite: g(this.fd_pwrite),
+      fd_read: g(this.fd_read),
+      fd_readdir: g(this.fd_readdir),
+      fd_renumber: g(this.fd_renumber),
+      fd_seek: g(this.fd_seek),
+      fd_sync: g(this.fd_sync),
+      fd_tell: g(this.fd_tell),
+      fd_write: g(this.fd_write),
+      path_create_directory: g(this.path_create_directory),
+      path_filestat_get: g(this.path_filestat_get),
+      path_filestat_set_times: g(this.path_filestat_set_times),
+      path_link: g(this.path_link),
+      path_open: g(this.path_open),
+      path_readlink: g(this.path_readlink),
+      path_remove_directory: g(this.path_remove_directory),
+      path_rename: g(this.path_rename),
+      path_symlink: g(this.path_symlink),
+      path_unlink_file: g(this.path_unlink_file),
+      poll_oneoff: g(this.poll_oneoff),
+      proc_exit: ((code) => {
+        this.exitCode = code;
+        throw new WasiExit(code);
+      }),
+      proc_raise: g(() => WASI_ENOSYS),
+      random_get: g(this.random_get),
+      sched_yield: g(() => WASI_ESUCCESS),
+      /* Sockets are the one part of WASI this container cannot honour: its
+       * network is an HTTP router, not a packet path. Saying so with ENOTSUP
+       * lets a guest fall back, where a trap would just kill it. */
+      sock_accept: g(() => WASI_ENOTSUP),
+      sock_recv: g(() => WASI_ENOTSUP),
+      sock_send: g(() => WASI_ENOTSUP),
+      sock_shutdown: g(() => WASI_ENOTSUP)
+    };
+  }
+  /**
+   * `wasi_unstable`, the preview0 name older toolchains still emit.
+   *
+   * Identical but for `fd_seek`, whose `whence` values were reordered before
+   * preview1 was frozen. Aliasing the table without this correction is a
+   * popular bug: every seek in an old binary lands somewhere plausible and
+   * wrong.
+   */
+  get wasiUnstableImport() {
+    const preview0Whence = [WHENCE_CUR, WHENCE_END, WHENCE_SET];
+    return {
+      ...this.wasiImport,
+      fd_seek: ((fd, offset, whence, out) => this.guard(
+        () => this.fd_seek(fd, offset, preview0Whence[whence] ?? WHENCE_SET, out)
+      ))
+    };
+  }
+  // ── memory access ────────────────────────────────────────────────────────
+  //
+  // Views are built per call rather than cached: `memory.grow` detaches every
+  // existing view, so a cached one turns into a silent zero-length buffer the
+  // first time the guest's allocator asks for another page.
+  get view() {
+    if (!this.memory) throw new Error("wasi: memory is not bound");
+    return new DataView(this.memory.buffer);
+  }
+  get bytes() {
+    if (!this.memory) throw new Error("wasi: memory is not bound");
+    return new Uint8Array(this.memory.buffer);
+  }
+  readString(ptr, len) {
+    return decoder7.decode(this.bytes.subarray(ptr, ptr + len));
+  }
+  /** The scatter/gather list `fd_read` and `fd_write` are given. */
+  iovecs(ptr, count) {
+    const view = this.view;
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      const base2 = ptr + i * 8;
+      out.push({ offset: view.getUint32(base2, true), length: view.getUint32(base2 + 4, true) });
+    }
+    return out;
+  }
+  /**
+   * Turn anything thrown inside a syscall into an errno.
+   *
+   * `WasiExit` is re-thrown on purpose: it is the guest unwinding its own
+   * stack, not a failure to be reported through a return value.
+   */
+  guard(fn) {
+    try {
+      return fn();
+    } catch (error) {
+      if (error instanceof WasiExit) throw error;
+      return errnoOf(error);
+    }
+  }
+  // ── descriptors ──────────────────────────────────────────────────────────
+  get(fd) {
+    const found = this.fds.get(fd);
+    if (!found) throw new WasiError(WASI_EBADF);
+    return found;
+  }
+  dir(fd) {
+    const found = this.get(fd);
+    if (found.kind !== "dir") throw new WasiError(WASI_ENOTDIR);
+    return found;
+  }
+  file(fd) {
+    const found = this.get(fd);
+    if (found.kind !== "file") throw new WasiError(WASI_EBADF);
+    return found;
+  }
+  /**
+   * Resolve a guest path against a directory descriptor.
+   *
+   * The confinement check is the one place preopens are enforced: a path that
+   * climbs out of the directory the descriptor was derived from is
+   * `ENOTCAPABLE`, which is exactly the error a capability-oriented guest
+   * expects and knows how to report.
+   */
+  resolveAt(dirfd, path) {
+    const dir3 = this.dir(dirfd);
+    if (path === "") throw new WasiError(WASI_ENOENT);
+    const abs = isAbsolute(path) ? resolve("/", path) : resolve(dir3.path, path);
+    const root = dir3.root;
+    if (root !== "/" && abs !== root && !abs.startsWith(root.endsWith("/") ? root : `${root}/`)) {
+      throw new WasiError(WASI_ENOTCAPABLE);
+    }
+    return { abs, root };
+  }
+  allocate(descriptor) {
+    const fd = this.nextFd++;
+    this.fds.set(fd, descriptor);
+    return fd;
+  }
+  /**
+   * Push a buffered file back to the VFS.
+   *
+   * Called before every path-based call as well as on close, so a guest that
+   * writes a file and then stats or reopens it by name sees what it wrote —
+   * the alternative is a stale read that looks like data loss.
+   */
+  writeBack(fd) {
+    if (!fd.dirty) return;
+    this.opts.vfs.writeFile(fd.path, fd.data.subarray(0, fd.size), { cred: this.opts.cred });
+    fd.dirty = false;
+  }
+  syncPaths() {
+    for (const fd of this.fds.values()) if (fd.kind === "file" && fd.dirty) this.writeBack(fd);
+  }
+  // ── args and environment ─────────────────────────────────────────────────
+  args_get(argvPtr, bufPtr) {
+    return this.writeStringVector(this.opts.argv, argvPtr, bufPtr);
+  }
+  args_sizes_get(countPtr, sizePtr) {
+    return this.writeVectorSizes(this.opts.argv, countPtr, sizePtr);
+  }
+  get envStrings() {
+    return Object.entries(this.opts.env).map(([key, value]) => `${key}=${value}`);
+  }
+  environ_get(envPtr, bufPtr) {
+    return this.writeStringVector(this.envStrings, envPtr, bufPtr);
+  }
+  environ_sizes_get(countPtr, sizePtr) {
+    return this.writeVectorSizes(this.envStrings, countPtr, sizePtr);
+  }
+  writeStringVector(values, pointersPtr, bufPtr) {
+    const view = this.view;
+    const memory = this.bytes;
+    let cursor = bufPtr;
+    values.forEach((value, index) => {
+      view.setUint32(pointersPtr + index * 4, cursor, true);
+      const encoded = encoder6.encode(`${value}\0`);
+      memory.set(encoded, cursor);
+      cursor += encoded.length;
+    });
+    return WASI_ESUCCESS;
+  }
+  writeVectorSizes(values, countPtr, sizePtr) {
+    const view = this.view;
+    view.setUint32(countPtr, values.length, true);
+    view.setUint32(
+      sizePtr,
+      values.reduce((total, value) => total + encoder6.encode(value).length + 1, 0),
+      true
+    );
+    return WASI_ESUCCESS;
+  }
+  // ── clocks and randomness ────────────────────────────────────────────────
+  clock_res_get(_id, out) {
+    this.view.setBigUint64(out, 1000000n, true);
+    return WASI_ESUCCESS;
+  }
+  clock_time_get(id, _precision, out) {
+    this.view.setBigUint64(out, this.clockNow(id), true);
+    return WASI_ESUCCESS;
+  }
+  clockNow(id) {
+    if (id === 0) return BigInt(Math.round(this.opts.now())) * 1000000n;
+    return this.opts.hrtime() - this.startTime;
+  }
+  random_get(ptr, len) {
+    const into = new Uint8Array(len);
+    this.opts.random(into);
+    this.bytes.set(into, ptr);
+    return WASI_ESUCCESS;
+  }
+  // ── reading and writing ──────────────────────────────────────────────────
+  fd_read(fd, iovsPtr, iovsLen, out) {
+    const descriptor = this.get(fd);
+    const iovs = this.iovecs(iovsPtr, iovsLen);
+    let total = 0;
+    if (descriptor.kind === "stdin") {
+      for (const iov of iovs) {
+        if (iov.length === 0) continue;
+        const chunk = this.opts.stdin.read(iov.length);
+        if (chunk.length === 0) break;
+        this.bytes.set(chunk, iov.offset);
+        total += chunk.length;
+        if (chunk.length < iov.length) break;
+      }
+      this.view.setUint32(out, total, true);
+      return WASI_ESUCCESS;
+    }
+    if (descriptor.kind !== "file") throw new WasiError(WASI_EBADF);
+    if ((descriptor.rights & RIGHT_FD_READ) === 0n) throw new WasiError(WASI_EACCES);
+    for (const iov of iovs) {
+      const end = Math.min(descriptor.pos + iov.length, descriptor.size);
+      const chunk = descriptor.data.subarray(descriptor.pos, Math.max(end, descriptor.pos));
+      if (chunk.length === 0) break;
+      this.bytes.set(chunk, iov.offset);
+      descriptor.pos += chunk.length;
+      total += chunk.length;
+      if (chunk.length < iov.length) break;
+    }
+    this.view.setUint32(out, total, true);
+    return WASI_ESUCCESS;
+  }
+  fd_pread(fd, iovsPtr, iovsLen, offset, out) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind !== "file") throw new WasiError(WASI_ESPIPE);
+    const saved = descriptor.pos;
+    descriptor.pos = Number(offset);
+    try {
+      return this.fd_read(fd, iovsPtr, iovsLen, out);
+    } finally {
+      descriptor.pos = saved;
+    }
+  }
+  fd_write(fd, iovsPtr, iovsLen, out) {
+    const descriptor = this.get(fd);
+    const iovs = this.iovecs(iovsPtr, iovsLen);
+    let total = 0;
+    if (descriptor.kind === "stdout" || descriptor.kind === "stderr") {
+      for (const iov of iovs) {
+        const chunk = this.bytes.slice(iov.offset, iov.offset + iov.length);
+        try {
+          descriptor.stream.write(chunk);
+        } catch (error) {
+          if (isSysError(error) && error.code === "EPIPE") throw new WasiError(WASI_EPIPE);
+          throw error;
+        }
+        total += chunk.length;
+      }
+      this.view.setUint32(out, total, true);
+      return WASI_ESUCCESS;
+    }
+    if (descriptor.kind !== "file") throw new WasiError(WASI_EBADF);
+    if ((descriptor.rights & RIGHT_FD_WRITE) === 0n) throw new WasiError(WASI_EACCES);
+    if (descriptor.append) descriptor.pos = descriptor.size;
+    for (const iov of iovs) {
+      const chunk = this.bytes.subarray(iov.offset, iov.offset + iov.length);
+      reserve(descriptor, descriptor.pos + chunk.length);
+      descriptor.data.set(chunk, descriptor.pos);
+      descriptor.pos += chunk.length;
+      descriptor.size = Math.max(descriptor.size, descriptor.pos);
+      total += chunk.length;
+    }
+    descriptor.dirty = true;
+    this.view.setUint32(out, total, true);
+    return WASI_ESUCCESS;
+  }
+  fd_pwrite(fd, iovsPtr, iovsLen, offset, out) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind !== "file") throw new WasiError(WASI_ESPIPE);
+    const saved = descriptor.pos;
+    const appended = descriptor.append;
+    descriptor.pos = Number(offset);
+    descriptor.append = false;
+    try {
+      return this.fd_write(fd, iovsPtr, iovsLen, out);
+    } finally {
+      descriptor.pos = saved;
+      descriptor.append = appended;
+    }
+  }
+  fd_seek(fd, offset, whence, out) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind !== "file") throw new WasiError(WASI_ESPIPE);
+    if ((descriptor.rights & RIGHT_FD_SEEK) === 0n) throw new WasiError(WASI_EACCES);
+    const base2 = whence === WHENCE_SET ? 0 : whence === WHENCE_CUR ? descriptor.pos : descriptor.size;
+    const next = base2 + Number(offset);
+    if (next < 0) throw new WasiError(WASI_EINVAL);
+    descriptor.pos = next;
+    this.view.setBigUint64(out, BigInt(next), true);
+    return WASI_ESUCCESS;
+  }
+  fd_tell(fd, out) {
+    this.view.setBigUint64(out, BigInt(this.file(fd).pos), true);
+    return WASI_ESUCCESS;
+  }
+  fd_close(fd) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind === "file") this.writeBack(descriptor);
+    this.fds.delete(fd);
+    return WASI_ESUCCESS;
+  }
+  fd_sync(fd) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind === "file") this.writeBack(descriptor);
+    return WASI_ESUCCESS;
+  }
+  fd_renumber(from, to) {
+    const descriptor = this.get(from);
+    const replaced = this.fds.get(to);
+    if (replaced?.kind === "file") this.writeBack(replaced);
+    this.fds.set(to, descriptor);
+    this.fds.delete(from);
+    return WASI_ESUCCESS;
+  }
+  fd_allocate(fd, offset, len) {
+    const descriptor = this.file(fd);
+    const size = Number(offset + len);
+    if (descriptor.size < size) {
+      reserve(descriptor, size);
+      descriptor.data.fill(0, descriptor.size, size);
+      descriptor.size = size;
+      descriptor.dirty = true;
+    }
+    return WASI_ESUCCESS;
+  }
+  fd_filestat_set_size(fd, size) {
+    const descriptor = this.file(fd);
+    const length = Number(size);
+    reserve(descriptor, length);
+    if (length > descriptor.size) descriptor.data.fill(0, descriptor.size, length);
+    descriptor.size = length;
+    if (descriptor.pos > length) descriptor.pos = length;
+    descriptor.dirty = true;
+    return WASI_ESUCCESS;
+  }
+  // ── metadata ─────────────────────────────────────────────────────────────
+  fd_fdstat_get(fd, out) {
+    const descriptor = this.get(fd);
+    const view = this.view;
+    const [filetype, flags, rights] = (() => {
+      switch (descriptor.kind) {
+        case "dir":
+          return [FILETYPE_DIRECTORY, 0, descriptor.rights];
+        case "file":
+          return [FILETYPE_REGULAR_FILE, descriptor.flags, descriptor.rights];
+        default:
+          return [FILETYPE_CHARACTER_DEVICE, 0, RIGHTS_ALL];
+      }
+    })();
+    zero(this.bytes, out, SIZEOF_FDSTAT);
+    view.setUint8(out, filetype);
+    view.setUint16(out + 2, flags, true);
+    view.setBigUint64(out + 8, rights, true);
+    view.setBigUint64(out + 16, rights, true);
+    return WASI_ESUCCESS;
+  }
+  fd_fdstat_set_flags(fd, flags) {
+    const descriptor = this.file(fd);
+    descriptor.flags = flags;
+    descriptor.append = (flags & FD_APPEND) !== 0;
+    return WASI_ESUCCESS;
+  }
+  fd_filestat_get(fd, out) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind === "file" || descriptor.kind === "dir") {
+      this.syncPaths();
+      this.writeFilestat(out, this.opts.vfs.stat(descriptor.path, { cred: this.opts.cred }));
+      return WASI_ESUCCESS;
+    }
+    zero(this.bytes, out, SIZEOF_FILESTAT);
+    this.view.setUint8(out + 16, FILETYPE_CHARACTER_DEVICE);
+    return WASI_ESUCCESS;
+  }
+  fd_filestat_set_times(fd, atim, mtim, flags) {
+    const descriptor = this.get(fd);
+    if (descriptor.kind !== "file" && descriptor.kind !== "dir") return WASI_ESUCCESS;
+    return this.setTimes(descriptor.path, atim, mtim, flags);
+  }
+  path_filestat_get(dirfd, lookupFlags, pathPtr, pathLen, out) {
+    this.syncPaths();
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    const follow = (lookupFlags & LOOKUP_SYMLINK_FOLLOW) !== 0;
+    this.writeFilestat(
+      out,
+      follow ? this.opts.vfs.stat(abs, { cred: this.opts.cred }) : this.opts.vfs.lstat(abs)
+    );
+    return WASI_ESUCCESS;
+  }
+  path_filestat_set_times(dirfd, _lookupFlags, pathPtr, pathLen, atim, mtim, flags) {
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    return this.setTimes(abs, atim, mtim, flags);
+  }
+  setTimes(path, atim, mtim, flags) {
+    const current = this.opts.vfs.stat(path, { cred: this.opts.cred });
+    const now = this.opts.now();
+    const atime = flags & FST_ATIM_NOW ? now : flags & FST_ATIM ? Number(atim / 1000000n) : current.atimeMs;
+    const mtime = flags & FST_MTIM_NOW ? now : flags & FST_MTIM ? Number(mtim / 1000000n) : current.mtimeMs;
+    this.opts.vfs.utimes(path, atime, mtime, this.opts.cred);
+    return WASI_ESUCCESS;
+  }
+  writeFilestat(out, stat2) {
+    const view = this.view;
+    zero(this.bytes, out, SIZEOF_FILESTAT);
+    view.setBigUint64(out, BigInt(stat2.dev), true);
+    view.setBigUint64(out + 8, BigInt(stat2.ino), true);
+    view.setUint8(out + 16, filetypeOf(stat2.mode));
+    view.setBigUint64(out + 24, BigInt(stat2.nlink), true);
+    view.setBigUint64(out + 32, BigInt(stat2.size), true);
+    view.setBigUint64(out + 40, msToNs(stat2.atimeMs), true);
+    view.setBigUint64(out + 48, msToNs(stat2.mtimeMs), true);
+    view.setBigUint64(out + 56, msToNs(stat2.ctimeMs), true);
+  }
+  // ── preopens ─────────────────────────────────────────────────────────────
+  fd_prestat_get(fd, out) {
+    const descriptor = this.fds.get(fd);
+    if (!descriptor || descriptor.kind !== "dir" || descriptor.preopen === void 0) {
+      throw new WasiError(WASI_EBADF);
+    }
+    const view = this.view;
+    view.setUint8(
+      out,
+      0
+      /* preopentype: dir */
+    );
+    view.setUint32(out + 4, encoder6.encode(descriptor.preopen).length, true);
+    return WASI_ESUCCESS;
+  }
+  fd_prestat_dir_name(fd, ptr, len) {
+    const descriptor = this.fds.get(fd);
+    if (!descriptor || descriptor.kind !== "dir" || descriptor.preopen === void 0) {
+      throw new WasiError(WASI_EBADF);
+    }
+    const name = encoder6.encode(descriptor.preopen);
+    if (name.length > len) throw new WasiError(WASI_EINVAL);
+    this.bytes.set(name, ptr);
+    return WASI_ESUCCESS;
+  }
+  // ── paths ────────────────────────────────────────────────────────────────
+  path_open(dirfd, _lookupFlags, pathPtr, pathLen, oflags, rightsBase, _rightsInheriting, fdflags, out) {
+    this.syncPaths();
+    const { abs, root } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    const vfs = this.opts.vfs;
+    const cred = this.opts.cred;
+    const exists = vfs.lexists(abs);
+    if (oflags & O_EXCL && oflags & O_CREAT && exists) throw new WasiError(WASI_EEXIST);
+    if (exists && vfs.stat(abs, { cred }).isDirectory()) {
+      if (rightsBase & RIGHT_FD_WRITE) throw new WasiError(WASI_EISDIR);
+      this.view.setUint32(out, this.allocate({ kind: "dir", path: abs, root, rights: RIGHTS_ALL }), true);
+      return WASI_ESUCCESS;
+    }
+    if (oflags & O_DIRECTORY) throw new WasiError(exists ? WASI_ENOTDIR : WASI_ENOENT);
+    if (!exists) {
+      if (!(oflags & O_CREAT)) throw new WasiError(WASI_ENOENT);
+      vfs.writeFile(abs, new Uint8Array(0), { cred, mode: 420 });
+    }
+    const truncate = (oflags & O_TRUNC) !== 0;
+    const data = truncate ? new Uint8Array(0) : vfs.readFile(abs, cred);
+    if (truncate) vfs.writeFile(abs, data, { cred });
+    const size = data.length;
+    const rights = rightsBase === 0n ? RIGHTS_ALL : rightsBase;
+    const append = (fdflags & FD_APPEND) !== 0;
+    this.view.setUint32(
+      out,
+      this.allocate({
+        kind: "file",
+        path: abs,
+        root,
+        data,
+        size,
+        pos: append ? size : 0,
+        dirty: false,
+        append,
+        rights,
+        flags: fdflags
+      }),
+      true
+    );
+    return WASI_ESUCCESS;
+  }
+  fd_readdir(fd, buf, bufLen, cookie, out) {
+    this.syncPaths();
+    const descriptor = this.dir(fd);
+    const vfs = this.opts.vfs;
+    const cred = this.opts.cred;
+    const entries = [
+      { name: ".", type: FILETYPE_DIRECTORY },
+      { name: "..", type: FILETYPE_DIRECTORY },
+      ...vfs.readdirWithTypes(descriptor.path, cred).map((entry) => ({
+        name: entry.name,
+        type: entry.kind === "directory" ? FILETYPE_DIRECTORY : entry.kind === "symlink" ? FILETYPE_SYMBOLIC_LINK : entry.kind === "file" ? FILETYPE_REGULAR_FILE : FILETYPE_UNKNOWN
+      }))
+    ];
+    const view = this.view;
+    const memory = this.bytes;
+    let written = 0;
+    for (let index = Number(cookie); index < entries.length; index++) {
+      const entry = entries[index];
+      const name = encoder6.encode(entry.name);
+      if (written + SIZEOF_DIRENT > bufLen) break;
+      const at = buf + written;
+      view.setBigUint64(at, BigInt(index + 1), true);
+      view.setBigUint64(at + 8, BigInt(inodeOf(descriptor.path, entry.name)), true);
+      view.setUint32(at + 16, name.length, true);
+      view.setUint8(at + 20, entry.type);
+      written += SIZEOF_DIRENT;
+      const room = Math.min(name.length, bufLen - written);
+      memory.set(name.subarray(0, room), buf + written);
+      written += room;
+      if (room < name.length) break;
+    }
+    view.setUint32(out, written, true);
+    return WASI_ESUCCESS;
+  }
+  path_create_directory(dirfd, pathPtr, pathLen) {
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    this.opts.vfs.mkdir(abs, { cred: this.opts.cred, mode: 493 });
+    return WASI_ESUCCESS;
+  }
+  path_remove_directory(dirfd, pathPtr, pathLen) {
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    this.opts.vfs.rmdir(abs, this.opts.cred);
+    return WASI_ESUCCESS;
+  }
+  path_unlink_file(dirfd, pathPtr, pathLen) {
+    this.syncPaths();
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    this.opts.vfs.unlink(abs, this.opts.cred);
+    return WASI_ESUCCESS;
+  }
+  path_rename(oldDirfd, oldPtr, oldLen, newDirfd, newPtr, newLen) {
+    this.syncPaths();
+    const from = this.resolveAt(oldDirfd, this.readString(oldPtr, oldLen));
+    const to = this.resolveAt(newDirfd, this.readString(newPtr, newLen));
+    this.opts.vfs.rename(from.abs, to.abs, this.opts.cred);
+    return WASI_ESUCCESS;
+  }
+  path_symlink(targetPtr, targetLen, dirfd, pathPtr, pathLen) {
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    this.opts.vfs.symlink(this.readString(targetPtr, targetLen), abs, this.opts.cred);
+    return WASI_ESUCCESS;
+  }
+  path_link(oldDirfd, _lookupFlags, oldPtr, oldLen, newDirfd, newPtr, newLen) {
+    this.syncPaths();
+    const from = this.resolveAt(oldDirfd, this.readString(oldPtr, oldLen));
+    const to = this.resolveAt(newDirfd, this.readString(newPtr, newLen));
+    this.opts.vfs.link(from.abs, to.abs, this.opts.cred);
+    return WASI_ESUCCESS;
+  }
+  path_readlink(dirfd, pathPtr, pathLen, buf, bufLen, out) {
+    const { abs } = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+    const target = encoder6.encode(this.opts.vfs.readlink(abs, this.opts.cred));
+    const room = Math.min(target.length, bufLen);
+    this.bytes.set(target.subarray(0, room), buf);
+    this.view.setUint32(out, room, true);
+    return WASI_ESUCCESS;
+  }
+  // ── polling ──────────────────────────────────────────────────────────────
+  /**
+   * `poll_oneoff`, which is how a WASI guest sleeps and how it waits on I/O.
+   *
+   * Files and the standard streams are always ready here — nothing in this
+   * container can leave a read pending, since stdin was drained before the
+   * guest started. That leaves the clock, which is the case that matters:
+   * `sleep()` compiles to a lone clock subscription, and it is honoured by
+   * actually waiting, in slices, so that killing the process interrupts it.
+   */
+  poll_oneoff(inPtr, outPtr, count, nevents) {
+    if (count === 0) {
+      this.view.setUint32(nevents, 0, true);
+      return WASI_ESUCCESS;
+    }
+    const subscriptions = [];
+    for (let index = 0; index < count; index++) {
+      const at = inPtr + index * SIZEOF_SUBSCRIPTION;
+      const view2 = this.view;
+      subscriptions.push({
+        userdata: view2.getBigUint64(at, true),
+        type: view2.getUint8(at + 8),
+        fd: view2.getUint32(at + 16, true),
+        clockId: view2.getUint32(at + 16, true),
+        timeout: view2.getBigUint64(at + 24, true),
+        flags: view2.getUint16(at + 40, true)
+      });
+    }
+    const ready = subscriptions.filter((s) => s.type !== EVENTTYPE_CLOCK);
+    if (ready.length === 0) {
+      const delays = subscriptions.map((s) => {
+        const nanoseconds = (s.flags & SUBSCRIPTION_CLOCK_ABSTIME) !== 0 ? s.timeout - this.clockNow(s.clockId) : s.timeout;
+        return Number(nanoseconds < 0n ? 0n : nanoseconds) / 1e6;
+      });
+      this.sleepInterruptibly(Math.min(...delays));
+    }
+    const events = ready.length > 0 ? ready : subscriptions;
+    const view = this.view;
+    events.forEach((subscription, index) => {
+      const at = outPtr + index * SIZEOF_EVENT;
+      zero(this.bytes, at, SIZEOF_EVENT);
+      view.setBigUint64(at, subscription.userdata, true);
+      view.setUint16(at + 8, WASI_ESUCCESS, true);
+      view.setUint8(at + 10, subscription.type);
+      if (subscription.type === EVENTTYPE_FD_READ) {
+        const available = subscription.fd === 0 ? this.opts.stdin.available : this.bytesLeft(subscription.fd);
+        view.setBigUint64(at + 16, BigInt(available), true);
+      } else if (subscription.type === EVENTTYPE_FD_WRITE) {
+        view.setBigUint64(at + 16, BigInt(64 * 1024), true);
+      }
+    });
+    view.setUint32(nevents, events.length, true);
+    return WASI_ESUCCESS;
+  }
+  bytesLeft(fd) {
+    const descriptor = this.fds.get(fd);
+    return descriptor?.kind === "file" ? Math.max(0, descriptor.size - descriptor.pos) : 0;
+  }
+  /** Wait in slices so that a `SIGKILL` does not have to outlast the sleep. */
+  sleepInterruptibly(milliseconds) {
+    let remaining = milliseconds;
+    while (remaining > 0) {
+      if (this.opts.aborted()) return;
+      const slice = Math.min(remaining, 50);
+      this.opts.sleep(slice);
+      remaining -= slice;
+    }
+  }
+};
+var WasiError = class extends Error {
+  constructor(errno) {
+    super(`wasi errno ${errno}`);
+    this.errno = errno;
+    this.name = "WasiError";
+  }
+  errno;
+};
+function errnoOf(error) {
+  if (error instanceof WasiError) return error.errno;
+  if (isSysError(error)) return WASI_ERRNO_BY_CODE[error.code] ?? WASI_EIO;
+  if (error instanceof RangeError) return WASI_EFAULT;
+  return WASI_EIO;
+}
+function filetypeOf(mode) {
+  const kind = mode & 61440;
+  if (kind === S_IFDIR) return FILETYPE_DIRECTORY;
+  if (kind === S_IFREG) return FILETYPE_REGULAR_FILE;
+  if (kind === S_IFLNK) return FILETYPE_SYMBOLIC_LINK;
+  if (kind === S_IFCHR) return FILETYPE_CHARACTER_DEVICE;
+  return FILETYPE_UNKNOWN;
+}
+function msToNs(milliseconds) {
+  return BigInt(Math.round(milliseconds)) * 1000000n;
+}
+function zero(memory, at, length) {
+  memory.fill(0, at, at + length);
+}
+function reserve(descriptor, length) {
+  if (length <= descriptor.data.length) return;
+  const grown = new Uint8Array(Math.max(length, descriptor.data.length * 2, 1024));
+  grown.set(descriptor.data.subarray(0, descriptor.size));
+  descriptor.data = grown;
+}
+function inodeOf(dir3, name) {
+  let hash = 2166136261;
+  const path = `${dir3}/${name}`;
+  for (let index = 0; index < path.length; index++) {
+    hash ^= path.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function defaultHrtime() {
+  return BigInt(Math.round(performance.now() * 1e6));
+}
+function defaultRandom(into) {
+  crypto.getRandomValues(into);
+}
+function defaultSleep(milliseconds) {
+  try {
+    const buffer = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(buffer, 0, 0, milliseconds);
+  } catch {
+  }
+}
+
+// src/wasi/run.ts
+var compiled2 = /* @__PURE__ */ new Map();
+var MAX_CACHED_MODULES = 32;
+async function runWasi(ctx, bytes2, options = {}) {
+  if (!isWasmBinary(bytes2)) {
+    ctx.warn("cannot execute binary file: not a WebAssembly module");
+    return EXIT_NOT_EXECUTABLE;
+  }
+  const argv = options.argv ?? ctx.argv;
+  const host2 = new WasiHost({
+    argv,
+    /* `PWD` is set truthfully, but do not mistake it for a working directory:
+     * wasi-libc keeps its own cwd, fixed at `/`, and ignores this. A guest's
+     * relative path therefore resolves from the root — the same thing it does
+     * under wasmtime, and why programs run here are given absolute paths. */
+    env: { ...ctx.env, PWD: ctx.cwd },
+    vfs: ctx.vfs,
+    cred: ctx.cred,
+    cwd: ctx.cwd,
+    stdin: await primeStdin(ctx),
+    stdout: ctx.stdout,
+    stderr: ctx.stderr,
+    ...options.preopens ? { preopens: options.preopens } : {},
+    now: ctx.kernel.now,
+    aborted: () => ctx.signal.aborted
+  });
+  let instance;
+  try {
+    const module = await compile(bytes2);
+    instance = await WebAssembly.instantiate(module, {
+      ...options.imports,
+      wasi_snapshot_preview1: host2.wasiImport,
+      wasi_unstable: host2.wasiUnstableImport
+    });
+  } catch (error) {
+    ctx.warn(describeStartupFailure(error));
+    return EXIT_NOT_EXECUTABLE;
+  }
+  try {
+    host2.bind(instance);
+  } catch (error) {
+    ctx.warn(error instanceof Error ? error.message : String(error));
+    return EXIT_NOT_EXECUTABLE;
+  }
+  const start2 = instance.exports._start ?? instance.exports._initialize;
+  if (typeof start2 !== "function") {
+    ctx.warn("not a WASI command: the module exports neither _start nor _initialize");
+    return EXIT_NOT_EXECUTABLE;
+  }
+  try {
+    start2();
+    return host2.exitCode ?? 0;
+  } catch (error) {
+    if (error instanceof WasiExit) return error.code;
+    ctx.warn(error instanceof Error ? error.message : String(error));
+    return 134;
+  } finally {
+    try {
+      host2.flushAll();
+    } catch (error) {
+      ctx.warn(`failed to flush open files: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+async function compile(bytes2) {
+  const key = await digest(bytes2);
+  const hit = compiled2.get(key);
+  if (hit) {
+    compiled2.delete(key);
+    compiled2.set(key, hit);
+    return hit;
+  }
+  const module = await WebAssembly.compile(sliceForWasm(bytes2));
+  compiled2.set(key, module);
+  if (compiled2.size > MAX_CACHED_MODULES) {
+    const oldest = compiled2.keys().next().value;
+    if (oldest !== void 0) compiled2.delete(oldest);
+  }
+  return module;
+}
+async function digest(bytes2) {
+  const hash = await crypto.subtle.digest("SHA-256", sliceForWasm(bytes2));
+  return Array.from(new Uint8Array(hash, 0, 16), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function sliceForWasm(bytes2) {
+  return bytes2.buffer.slice(bytes2.byteOffset, bytes2.byteOffset + bytes2.byteLength);
+}
+async function primeStdin(ctx) {
+  let pending = new Uint8Array(0);
+  if (!ctx.stdin.isTTY) {
+    try {
+      pending = await ctx.stdin.readAll();
+    } catch {
+      pending = new Uint8Array(0);
+    }
+  }
+  return {
+    read(size) {
+      const chunk = pending.slice(0, Math.min(size, pending.length));
+      pending = pending.subarray(chunk.length);
+      return chunk;
+    },
+    get available() {
+      return pending.length;
+    },
+    isTTY: ctx.stdin.isTTY
+  };
+}
+function describeStartupFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof WebAssembly.LinkError) {
+    return `${message} \u2014 the module needs imports this container does not provide. Build it for wasm32-wasi (a plain wasm32-unknown-unknown or emscripten build will not run here).`;
+  }
+  return message;
+}
+
+// src/wasi/command.ts
+var wasi = defineCommand({
+  name: "wasi",
+  path: "/usr/bin/wasi",
+  summary: "run a WebAssembly (wasm32-wasi) binary",
+  usage: "wasi [--dir PATH] [--mapdir GUEST=PATH] [--env K=V] MODULE.wasm [args...]",
+  manual: `Runs a WebAssembly module built for wasm32-wasi as a container
+process: it sees the container's filesystem, environment and standard streams,
+and can be piped and redirected like any other command.
+
+By default the module is given the whole filesystem, which is what an ordinary
+program compiled by clang, Rust, Zig or TinyGo expects. Passing --dir or
+--mapdir replaces that default with exactly what is listed, confining the
+module to those directories.
+
+A WASI program has no working directory: wasi-libc fixes its own at / and
+resolves relative paths from there, exactly as it does under wasmtime. Pass
+absolute paths, or preopen a directory with --mapdir to give the program a
+name for it.
+
+Executable .wasm files are dispatched here automatically, so ./tool.wasm runs
+without naming this command.
+
+Sockets are not available: this container's network is an HTTP router rather
+than a packet path, and socket calls report ENOTSUP.`,
+  async run(ctx) {
+    const preopens = {};
+    const env2 = {};
+    let module;
+    let rest = [];
+    const args = ctx.args;
+    for (let index = 0; index < args.length; index++) {
+      const arg = args[index];
+      if (arg === "--help" || arg === "-h") {
+        ctx.line(wasi.usage);
+        return 0;
+      }
+      if (arg === "--") {
+        module = args[index + 1];
+        rest = args.slice(index + 2);
+        break;
+      }
+      if (arg === "--dir") {
+        const dir3 = args[++index];
+        if (dir3 === void 0) return ctx.reportError(new UsageError("--dir needs a path"));
+        preopens[ctx.path(dir3)] = ctx.path(dir3);
+        continue;
+      }
+      if (arg === "--mapdir") {
+        const pair = args[++index];
+        const split2 = pair?.indexOf("=") ?? -1;
+        if (pair === void 0 || split2 < 0) {
+          return ctx.reportError(new UsageError("--mapdir needs GUEST=PATH"));
+        }
+        preopens[pair.slice(0, split2)] = ctx.path(pair.slice(split2 + 1));
+        continue;
+      }
+      if (arg === "--env") {
+        const pair = args[++index];
+        const split2 = pair?.indexOf("=") ?? -1;
+        if (pair === void 0 || split2 < 0) {
+          return ctx.reportError(new UsageError("--env needs KEY=VALUE"));
+        }
+        env2[pair.slice(0, split2)] = pair.slice(split2 + 1);
+        continue;
+      }
+      module = arg;
+      rest = args.slice(index + 1);
+      break;
+    }
+    if (module === void 0) return ctx.reportError(new UsageError("a module is required"));
+    const abs = ctx.path(module);
+    let bytes2;
+    try {
+      bytes2 = ctx.vfs.readFile(abs, ctx.cred);
+    } catch (error) {
+      ctx.reportError(error, abs);
+      return EXIT_NOT_FOUND;
+    }
+    if (!isWasmBinary(bytes2)) {
+      return ctx.fail(`${abs}: not a WebAssembly module`, 126);
+    }
+    Object.assign(ctx.env, env2);
+    return await runWasi(ctx, bytes2, {
+      /* argv[0] is the path as the user wrote it, not the resolved one: a
+       * program printing its own usage should echo what was typed. */
+      argv: [module, ...rest],
+      ...Object.keys(preopens).length > 0 ? { preopens } : {}
+    });
+  }
+});
+function wasiCommands() {
+  return [wasi];
+}
 var platformBuffer = globalThis.Buffer;
 var Buffer2 = platformBuffer ?? addBase64UrlSupport(index_js.Buffer);
 function addBase64UrlSupport(BufferClass) {
@@ -19202,8 +20426,8 @@ function verifyIntegrity(data, integrity, shasum, identity) {
       const dash = choice.indexOf("-");
       const algorithm = choice.slice(0, dash);
       const expected = choice.slice(dash + 1).replace(/\?.*$/, "");
-      const digest = algorithm === "sha512" ? sha512.sha512(data) : algorithm === "sha256" ? sha256.sha256(data) : null;
-      if (digest && Buffer2.from(digest).toString("base64") === expected) return;
+      const digest2 = algorithm === "sha512" ? sha512.sha512(data) : algorithm === "sha256" ? sha256.sha256(data) : null;
+      if (digest2 && Buffer2.from(digest2).toString("base64") === expected) return;
     }
     throw new Error(`Integrity check failed for ${identity}`);
   }
@@ -20173,6 +21397,7 @@ function allCommands() {
     ...nodeCommands(),
     ...pythonCommands(),
     ...ffmpegCommands(),
+    ...wasiCommands(),
     ...packageCommands()
   ];
 }
@@ -20332,15 +21557,15 @@ var Session = class {
   async run(command, opts = {}) {
     if (this.closed) throw new Error("session is closed");
     const combined = [];
-    const decoder8 = new TextDecoder();
+    const decoder9 = new TextDecoder();
     const stdout = new BufferSink((chunk) => {
-      const text2 = decoder8.decode(chunk, { stream: true });
+      const text2 = decoder9.decode(chunk, { stream: true });
       combined.push(text2);
       opts.onStdout?.(text2);
       this.hooks.onStdout?.(text2);
     });
     const stderr = new BufferSink((chunk) => {
-      const text2 = decoder8.decode(chunk, { stream: true });
+      const text2 = decoder9.decode(chunk, { stream: true });
       combined.push(text2);
       opts.onStderr?.(text2);
       this.hooks.onStderr?.(text2);
@@ -22794,8 +24019,8 @@ function createCryptoModule() {
       queueMicrotask(() => done?.(null, target));
     },
     hash(algorithm, data, encoding = "hex") {
-      const digest = Buffer2.from(hashFor(algorithm)(toBytes2(data)));
-      return encoding === "buffer" ? digest : digest.toString(encoding);
+      const digest2 = Buffer2.from(hashFor(algorithm)(toBytes2(data)));
+      return encoding === "buffer" ? digest2 : digest2.toString(encoding);
     },
     timingSafeEqual(a, b) {
       if (a.length !== b.length) throw new RangeError("Input buffers must have the same byte length");
@@ -24730,7 +25955,7 @@ var MemoryStat = class {
     return this.inode.kind === "symlink";
   }
 };
-var encoder6 = new TextEncoder();
+var encoder7 = new TextEncoder();
 var MemoryVolume = class {
   entries = /* @__PURE__ */ new Map();
   nextIno = 2;
@@ -24748,7 +25973,7 @@ var MemoryVolume = class {
   writeFileSync(path, data) {
     const key = this.key(path);
     this.requireParent(key, "open");
-    const bytes2 = typeof data === "string" ? encoder6.encode(data) : data.slice();
+    const bytes2 = typeof data === "string" ? encoder7.encode(data) : data.slice();
     const current = this.entries.get(key);
     if (current?.kind === "directory") throw new VolumeError("EISDIR", "open", key);
     if (current?.kind === "symlink") throw new VolumeError("EINVAL", "open", key);
@@ -24761,7 +25986,7 @@ var MemoryVolume = class {
   }
   appendFileSync(path, data) {
     const key = this.key(path);
-    const bytes2 = typeof data === "string" ? encoder6.encode(data) : data;
+    const bytes2 = typeof data === "string" ? encoder7.encode(data) : data;
     const current = this.entries.get(key);
     if (!current) return this.writeFileSync(key, bytes2);
     if (current.kind !== "file") throw new VolumeError(current.kind === "directory" ? "EISDIR" : "EINVAL", "open", key);
@@ -24899,7 +26124,7 @@ var MemoryVolume = class {
       if (node2.kind === "directory") directoryCount++;
       else {
         fileCount++;
-        totalBytes += node2.kind === "file" ? node2.data.length : encoder6.encode(node2.target).length;
+        totalBytes += node2.kind === "file" ? node2.data.length : encoder7.encode(node2.target).length;
       }
     }
     return { totalBytes, fileCount, directoryCount, dirCount: directoryCount };
@@ -25781,10 +27006,10 @@ function attachRolldownMirror(binding, volume, root) {
 }
 
 // src/runtime/remote-volume.ts
-var encoder7 = new TextEncoder();
-var decoder7 = new TextDecoder();
+var encoder8 = new TextEncoder();
+var decoder8 = new TextDecoder();
 function encodeFrame(header, body) {
-  const json = encoder7.encode(JSON.stringify(header));
+  const json = encoder8.encode(JSON.stringify(header));
   const frame = new Uint8Array(4 + json.length + (body?.length ?? 0));
   new DataView(frame.buffer).setUint32(0, json.length, true);
   frame.set(json, 4);
@@ -25794,7 +27019,7 @@ function encodeFrame(header, body) {
 function decodeFrame(frame) {
   const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
   const headerLength = view.getUint32(0, true);
-  const header = JSON.parse(decoder7.decode(frame.subarray(4, 4 + headerLength)));
+  const header = JSON.parse(decoder8.decode(frame.subarray(4, 4 + headerLength)));
   return { header, body: frame.subarray(4 + headerLength) };
 }
 function flattenStat(stat2) {
@@ -26597,15 +27822,15 @@ var Container = class _Container {
   }
   makeStdio(opts) {
     const combined = [];
-    const decoder8 = new TextDecoder();
+    const decoder9 = new TextDecoder();
     const stdout = new BufferSink((chunk) => {
-      const text2 = decoder8.decode(chunk, { stream: true });
+      const text2 = decoder9.decode(chunk, { stream: true });
       combined.push(text2);
       opts.onStdout?.(text2);
       this.hooks.onStdout?.(text2);
     });
     const stderr = new BufferSink((chunk) => {
-      const text2 = decoder8.decode(chunk, { stream: true });
+      const text2 = decoder9.decode(chunk, { stream: true });
       combined.push(text2);
       opts.onStderr?.(text2);
       this.hooks.onStderr?.(text2);
@@ -27350,6 +28575,9 @@ exports.VirtualHttpServer = VirtualHttpServer;
 exports.VirtualIncomingMessage = VirtualIncomingMessage;
 exports.VirtualServerResponse = VirtualServerResponse;
 exports.WASM_ALIASES = WASM_ALIASES;
+exports.WasiError = WasiError;
+exports.WasiExit = WasiExit;
+exports.WasiHost = WasiHost;
 exports.WorkerRuntimePod = WorkerRuntimePod;
 exports.allCommands = allCommands;
 exports.applyChmod = applyChmod;
@@ -27383,6 +28611,7 @@ exports.isBuiltinName = isBuiltinName;
 exports.isCPythonAvailable = isCPythonAvailable;
 exports.isPythonAvailable = isPythonAvailable;
 exports.isSysError = isSysError;
+exports.isWasmBinary = isWasmBinary;
 exports.looksLikeEsm = looksLikeEsm;
 exports.makeCred = makeCred;
 exports.normalizeSignal = normalizeSignal;
@@ -27392,11 +28621,13 @@ exports.parseUmask = parseUmask;
 exports.posixPath = path_exports;
 exports.renderInto = renderInto;
 exports.resetPidCounter = resetPidCounter;
+exports.runWasi = runWasi;
 exports.shellQuote = shellQuote;
 exports.startRuntimeWorker = startRuntimeWorker;
 exports.strerror = strerror;
 exports.syncChannelSupported = syncChannelSupported;
 exports.transformEsm = transformEsm;
 exports.unameInfo = unameInfo;
+exports.wasiCommand = wasi;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map